chore(main): release 4.2.6

Release-As: 4.2.6

.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/CODEOWNERS

@@ -1 +1 @@
-src/* @jacoobes
+* @jacoobes

.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

@@ -1,44 +0,0 @@
-name: Continuous Integration
-
-on:
-  # Trigger the workflow on push or pull request or custom
-  push:
-    branches:
-      main
-  pull_request_target:
-    branches:
-      main
-  workflow_dispatch:
-
-jobs:
-  Prettier:
-    name: Run Prettier
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check out Git repository
-        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # tag=v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@2fddd8803e2f5c9604345a0b591c3020ee971a93 # tag=v3
-        with:
-          node-version: 17
-
-      # Prettier must be in `package.json`
-      - name: Install Node.js dependencies
-        run: npm i -g prettier && npm i
-
-      - name: Run Prettier
-        run: prettier --write .
-
-      - name: Create Pull Request
-        id: cpr
-        uses: peter-evans/create-pull-request@v4
-        with:
-          commit-message: "style: pretty please"
-          branch: prettier
-          delete-branch: true
-          branch-suffix: short-commit-hash
-          title: "style: pretty please"
-          body: "pretty pretty prettier"
-          reviewers: EvolutionX-10

.github/workflows/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-dev.yml

@@ -0,0 +1,34 @@
+name: Continuous Delivery
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'src/**'
+      - 'package.json'
+
+jobs:
+  Publish:
+    name: Publishing Dev
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
+        with:
+          node-version: 18
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install Node.js dependencies
+        run: npm i && npm run build:dev
+
+      - name: Publish to npm
+        run: |
+          npm version premajor --preid "dev.$(git rev-parse --verify --short HEAD)" --git-tag-version=false
+          npm publish --tag dev
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/npm-publish.yml

@@ -1,30 +1,22 @@
 name: NPM / Publish
 
 on:
-  release:
-    types: [created]
-
+  workflow_dispatch:
+  # 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/setup-node@v3
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+      - uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7 # v3
         with:
-          node-version: 16
-      - run: npm ci
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+          node-version: 18
+      - run: npm i
+      - run: npm run build:prod
+      - uses: JS-DevTools/npm-publish@0f451a94170d1699fd50710966d48fb26194d939 # v1
         with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+          token: ${{ secrets.NPM_TOKEN }}
+          access: "public"

.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,28 @@
+# 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
+    - run: npm run 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
-dist
-
+test
 # VisualStudio Config file
 .vs
 
@@ -108,6 +108,9 @@ tsup.config.js
 
 tsconfig-base.json
 
-tsconfig.cjs.json
+tsconfig-cjs.json
 
-tsconfig.esm.json
+tsconfig-esm.json
+
+renovate.json
+fortnite

.prettierignore

@@ -1,2 +1,3 @@
 .github/
-*.md
+*.md
+dist/

.prettierrc

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

CHANGELOG.md

@@ -1,5 +1,337 @@
 # Changelog
 
+## [4.2.6](https://github.com/sern-handler/handler/compare/v4.2.5...v4.2.6) (2025-09-22)
+
+
+### Miscellaneous Chores
+
+* release 4.2.6 ([#402](https://github.com/sern-handler/handler/issues/402)) ([0eecb08](https://github.com/sern-handler/handler/commit/0eecb08e87e26102030ccf6ef38ddd81051ec373))
+
+## [4.2.5](https://github.com/sern-handler/handler/compare/v4.2.4...v4.2.5) (2025-08-31)
+
+
+### Bug Fixes
+
+* make message module warn rather than throwing ([#399](https://github.com/sern-handler/handler/issues/399)) ([797442e](https://github.com/sern-handler/handler/commit/797442ece3999bf2cb6b5ba0688ce0177e72a22f))
+
+## [4.2.4](https://github.com/sern-handler/handler/compare/v4.2.3...v4.2.4) (2025-03-06)
+
+
+### Bug Fixes
+
+* flat autocomplete ([#395](https://github.com/sern-handler/handler/issues/395)) ([89d7409](https://github.com/sern-handler/handler/commit/89d74095363befddc3222b9e5c89c35e7c6457b9))
+
+## [4.2.3](https://github.com/sern-handler/handler/compare/v4.2.2...v4.2.3) (2025-03-04)
+
+
+### Bug Fixes
+
+* autocomplete sdt.module not present ([#393](https://github.com/sern-handler/handler/issues/393)) ([2414992](https://github.com/sern-handler/handler/commit/2414992b73a40065464b20f2d53826c78fcd3a5f))
+
+## [4.2.2](https://github.com/sern-handler/handler/compare/v4.2.1...v4.2.2) (2025-02-03)
+
+
+### Bug Fixes
+
+* faster autocomplete lookup ([#387](https://github.com/sern-handler/handler/issues/387)) ([974c30f](https://github.com/sern-handler/handler/commit/974c30fa6cccaae7b1c2c3246ffa9eecb6bc7bf9))
+
+## [4.2.1](https://github.com/sern-handler/handler/compare/v4.2.0...v4.2.1) (2025-01-24)
+
+
+### Bug Fixes
+
+* context-interactions error ([#382](https://github.com/sern-handler/handler/issues/382)) ([a52ad27](https://github.com/sern-handler/handler/commit/a52ad270d843e92db5bf2049d07527eed59d428c))
+
+## [4.2.0](https://github.com/sern-handler/handler/compare/v4.1.1...v4.2.0) (2025-01-18)
+
+
+### Features
+
+* 4.2.0 load multiple directories & `handleModuleErrors` ([#378](https://github.com/sern-handler/handler/issues/378)) ([f9e7eaf](https://github.com/sern-handler/handler/commit/f9e7eaf92d22b76d3d02a1bbe8324ca6813f48f8))
+
+## [4.1.1](https://github.com/sern-handler/handler/compare/v4.1.0...v4.1.1) (2025-01-13)
+
+
+### Bug Fixes
+
+* remove rxjs ([#376](https://github.com/sern-handler/handler/issues/376)) ([59d08ef](https://github.com/sern-handler/handler/commit/59d08ef207c486ce1cf0aba267e6f862838e0dfb))
+* This puts the light back into lightweight (\- 4.1 MB)
+
+## [4.1.0](https://github.com/sern-handler/handler/compare/v4.0.3...v4.1.0) (2025-01-06)
+
+
+### Features
+
+* moduleinfo-in-eventplugins ([#373](https://github.com/sern-handler/handler/issues/373)) ([220a60e](https://github.com/sern-handler/handler/commit/220a60ecf853df8d288de2533c669562a430c3f9))
+
+
+### Bug Fixes
+
+* update github username ([#371](https://github.com/sern-handler/handler/issues/371)) ([55715d5](https://github.com/sern-handler/handler/commit/55715d565990fe686159f3c1eda3754d1262c72c))
+
+## [4.0.3](https://github.com/sern-handler/handler/compare/v4.0.2...v4.0.3) (2024-10-06)
+
+
+### Bug Fixes
+
+* async presence ([#369](https://github.com/sern-handler/handler/issues/369)) ([eabfb81](https://github.com/sern-handler/handler/commit/eabfb81819b53a4656d8eac6e21cfb488b724a42))
+* fix eventModule typing for Discord events ([#368](https://github.com/sern-handler/handler/issues/368)) ([1789ccb](https://github.com/sern-handler/handler/commit/1789ccb2f22f502f87538fecdb07106ff7110434))
+
+## [4.0.2](https://github.com/sern-handler/handler/compare/v4.0.1...v4.0.2) (2024-08-13)
+
+
+### Bug Fixes
+
+* type issue ([2106cdc](https://github.com/sern-handler/handler/commit/2106cdc1d033f88b6ee4ccca6754fe7a595a9328))
+
+## [4.0.1](https://github.com/sern-handler/handler/compare/v4.0.0...v4.0.1) (2024-07-19)
+
+
+### Bug Fixes
+
+* add SDT typings to autocomplete commands ([#363](https://github.com/sern-handler/handler/issues/363)) ([92623d2](https://github.com/sern-handler/handler/commit/92623d2914fb80e31365f06cf896bb37f36fc814))
+
+## [4.0.0](https://github.com/sern-handler/handler/compare/v3.3.4...v4.0.0) (2024-07-18)
+
+
+### Features
+
+* v4 ([#361](https://github.com/sern-handler/handler/issues/361)) ([9a8904f](https://github.com/sern-handler/handler/commit/9a8904f5aed4fa36b018ad73bbe58049bae33274))
+
+
+### Miscellaneous Chores
+
+* release 4.0.0 ([dda0e33](https://github.com/sern-handler/handler/commit/dda0e3395b6704862bfd3fda2a201e2cb9b45d2f))
+
+## [3.3.4](https://github.com/sern-handler/handler/compare/v3.3.3...v3.3.4) (2024-03-18)
+
+
+### Bug Fixes
+
+* sern emitter err ([#358](https://github.com/sern-handler/handler/issues/358)) ([90e55df](https://github.com/sern-handler/handler/commit/90e55dfa1466c91e5da48922251309331921b1ef))
+
+## [3.3.3](https://github.com/sern-handler/handler/compare/v3.3.2...v3.3.3) (2024-02-25)
+
+
+### Bug Fixes
+
+* rm deprecated class modules, clean up, rm indirection ([#355](https://github.com/sern-handler/handler/issues/355)) ([48f9f6e](https://github.com/sern-handler/handler/commit/48f9f6ec16e650d574bd24dcbb0ed176933bfe17))
+* singleton init not being fired when inserting function ([07b11b3](https://github.com/sern-handler/handler/commit/07b11b357baac0c3c7055c022bc353995c80f766))
+* typings and cleanup ([#356](https://github.com/sern-handler/handler/issues/356)) ([ce8c4bf](https://github.com/sern-handler/handler/commit/ce8c4bf6492b9680fb1c1a530d3e0028f214ad2f))
+
+## [3.3.2](https://github.com/sern-handler/handler/compare/v3.3.1...v3.3.2) (2024-01-08)
+
+
+### Bug Fixes
+
+* presence feature not working on cjs applications ([#351](https://github.com/sern-handler/handler/issues/351)) ([4f23871](https://github.com/sern-handler/handler/commit/4f2387119acfde036d0d1626553e9050f55627d1))
+
+## [3.3.1](https://github.com/sern-handler/handler/compare/v3.3.0...v3.3.1) (2024-01-07)
+
+
+### Bug Fixes
+
+* crashing when slash command is used as text command ([#349](https://github.com/sern-handler/handler/issues/349)) ([a359f73](https://github.com/sern-handler/handler/commit/a359f73fa24127a4964d411c8c1c0dfea5edc0f1))
+
+
+### Reverts
+
+* the last commit ([655bb8d](https://github.com/sern-handler/handler/commit/655bb8d35815fe0ce9797d8b169310a07b284ae0))
+
+## [3.3.0](https://github.com/sern-handler/handler/compare/v3.2.1...v3.3.0) (2023-12-27)
+
+
+### Features
+
+* presence ([#345](https://github.com/sern-handler/handler/issues/345)) ([7458bef](https://github.com/sern-handler/handler/commit/7458befe8a5900480cd71900df02a8364837dc00))
+
+## [3.2.1](https://github.com/sern-handler/handler/compare/v3.2.0...v3.2.1) (2023-12-21)
+
+
+### Bug Fixes
+
+* logger swap failing ([daac37c](https://github.com/sern-handler/handler/commit/daac37c28858c42b21042bdcb8141239db634e7d))
+
+## [3.2.0](https://github.com/sern-handler/handler/compare/v3.1.1...v3.2.0) (2023-12-15)
+
+
+### Miscellaneous Chores
+
+* release 3.2.0 ([237c853](https://github.com/sern-handler/handler/commit/237c8537c66052309d7e13a7e6e0a4f7995c2558))
+
+## [3.1.1](https://github.com/sern-handler/handler/compare/v3.1.0...v3.1.1) (2023-11-06)
+
+
+### Bug Fixes
+
+* queuing events ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
+* queuing events ([#332](https://github.com/sern-handler/handler/issues/332)) @Benzo-Fury ([#333](https://github.com/sern-handler/handler/issues/333)) ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
+
+## [3.1.0](https://github.com/sern-handler/handler/compare/v3.0.2...v3.1.0) (2023-09-04)
+
+
+### 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)
+
+
+### Bug Fixes
+
+* **autocomplete:** now support multiple autocomplete options ([#147](https://github.com/sern-handler/handler/issues/147)) ([cbad738](https://github.com/sern-handler/handler/commit/cbad7380e1993b96c643f365726457f63e4fbd5d))
+
+## [1.2.0](https://github.com/sern-handler/handler/compare/v1.1.0...v1.2.0) (2022-09-28)
+
+
+### Features
+
+* allow constructable modules ([#133](https://github.com/sern-handler/handler/issues/133)) ([03936eb](https://github.com/sern-handler/handler/commit/03936eb2ea1d1af7cada04d77bb8345d63a5e20f))
+* classmodules@arcs ([#143](https://github.com/sern-handler/handler/issues/143)) ([5028886](https://github.com/sern-handler/handler/commit/50288867a5b171511941a1be3877d721694e9f77))
+* update CODEOWNERS ([6b8995d](https://github.com/sern-handler/handler/commit/6b8995d149c857558415a6c151a3f575ec373445))
+
+
+### Reverts
+
+* feat of allow constructable modules ([#138](https://github.com/sern-handler/handler/issues/138)) ([82bbdda](https://github.com/sern-handler/handler/commit/82bbddac8d656b60b3a1fb2471ea03ee5224f5c3))
+
 ## [1.1.0](https://github.com/sern-handler/handler/compare/v1.0.0...v1.1.0) (2022-08-29)
 
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-**Copyright (c) 2022 Sern**
+Copyright (c) 2025 sern
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -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

@@ -1,105 +1,79 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px">
+  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px" />
 </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" style="margin-top: 10px">
-  <img src="https://img.shields.io/badge/open-source-brightgreen">
+<div align="center" styles="margin-top: 10px">
+  <img src="https://img.shields.io/badge/open-source-brightgreen" />
+  <img src="https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev"/>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/v/@sern/handler?maxAge=3600" alt="NPM version" /></a>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/dt/@sern/handler?maxAge=3600" alt="NPM downloads" /></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT"></a>
-  <a href="https://sern-handler.js.org"><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">
+  <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.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
-
-```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
+[Start here!!](https://sern.dev/v4/reference/getting-started)
 
 ## 👶 Basic Usage
+<details><summary>ping.ts</summary>
 
-#### ` index.js (CommonJS)`
-
-```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 } = require('@sern/handler');
-
-exports.default = commandModule({
-  name: 'ping',
-  description: 'A ping pong command',
+```ts
+export default commandModule({
   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>
 
-See our [templates](https://github.com/sern-handler/templates) for TypeScript examples and more
+# Show off your sern Discord Bot!
+
+## Badge
+- Copy this and add it to your [README.md](https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev)
+<img src="https://img.shields.io/badge/built_with-sern-pink?labelColor=%230C3478&color=%23ed5087&link=https%3A%2F%2Fsern.dev">
+
+## 🤖 Bots Using sern 
+- [Community Bot](https://github.com/sern-handler/sern-community) - The community bot for our [Discord server](https://sern.dev/discord).
+- [Vinci](https://github.com/SrIzan10/vinci) - The bot for Mara Turing.
+- [Bask](https://github.com/baskbotml/bask) - Listen to your favorite artists on Discord.
+- [Murayama](https://github.com/murayamabot/murayama) - :pepega:
+- [Protector](https://github.com/GlitchApotamus/Protector) - Just a simple bot to help enhance a private Minecraft server.
+- [SmokinWeed 💨](https://github.com/Peter-MJ-Parker/sern-bud) - A fun bot for a small, but growing server.
+- [Man Nomic](https://github.com/jacoobes/man-nomic) - A simple information bot to provide information to the nomic-ai Discord community.
+- [Linear-Discord](https://github.com/sern-handler/linear-discord) - Display and manage a linear dashboard.
+- [ZenithBot](https://github.com/CodeCraftersHaven/ZenithBot) - A versatile bot coded in TypeScript, designed to enhance server management and user interaction through its robust features.
 
 ## 💻 CLI
 
 It is **highly encouraged** to use the [command line interface](https://github.com/sern-handler/cli) for your project. Don't forget to view it.
 
+
+
 ## 🔗 Links
 
-- [Official Documentation and Guide](https://sern-handler.js.org)
-- [Support Server](https://discord.com/invite/mmyCTnYtbF)
+- [Official Documentation and Guide](https://sern.dev)
+- [Support Server](https://sern.dev/discord)
 
 ## 👋 Contribute
-
-- Read our contribution [guidelines](https://github.com/sern-handler/handler) carefully
+- Read our contribution [guidelines](https://github.com/sern-handler/handler/blob/main/.github/CONTRIBUTING.md) 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,28 @@
 {
     "name": "@sern/handler",
-    "version": "1.1.0",
-    "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
-    "main": "dist/cjs/index.cjs",
-    "module": "dist/esm/index.mjs",
-    "types": "dist/index.d.ts",
+    "packageManager": "yarn@3.5.0",
+    "version": "4.2.6",
+    "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
     "exports": {
         ".": {
-            "import": "./dist/esm/index.mjs",
-            "require": "./dist/cjs/index.cjs"
+            "import": "./dist/index.js",
+            "require": "./dist/index.js"
         }
     },
     "scripts": {
-        "watch": "tsup --watch --dts",
-        "clean-modules": "rimraf node_modules/ && npm install",
+        "watch": "tsc --watch",
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
-        "build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
-        "publish": "npm run build && npm publish"
+        "build:dev": "tsc",
+        "build:prod": "tsc",
+        "prepare": "tsc",
+        "pretty": "prettier --write .",
+        "tdd": "vitest",
+        "benchmark": "vitest bench",
+        "test": "vitest --run",
+        "analyze-imports": "npx depcruise src --include-only \"^src\" --output-type dot | dot -T svg > dependency-graph.svg"
     },
     "keywords": [
         "sern-handler",
@@ -31,24 +36,62 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
-        "rxjs": "^7.5.6",
-        "ts-pattern": "^4.0.2",
-        "ts-results-es": "^3.5.0"
+        "@sern/ioc": "^1.1.2",
+        "callsites": "^3.1.0",
+        "cron": "^3.1.7",
+        "deepmerge": "^4.3.1"
     },
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "5.35.1",
-        "@typescript-eslint/parser": "5.35.1",
-        "eslint": "8.22.0",
-        "prettier": "2.7.1",
-        "tsup": "^6.1.3",
-        "typescript": "4.7.4"
+        "@faker-js/faker": "^8.0.1",
+        "@types/node": "^20.0.0",
+        "@types/node-cron": "^3.0.11",
+        "@typescript-eslint/eslint-plugin": "5.58.0",
+        "@typescript-eslint/parser": "5.59.1",
+        "discord.js": "^14.22.1",
+        "eslint": "8.39.0",
+        "typescript": "5.0.2",
+        "vitest": "^1.6.0"
     },
-    "peerDependencies": {
-        "discord.js": "^14.2.x"
+    "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"
+    "engines": {
+        "node": ">= 20.0.x"
+    },
+    "homepage": "https://sern.dev",
+    "overrides": {
+        "ws": "8.17.1"
+    },
+    "resolutions": {
+        "ws": "8.17.1"
+    }
 }

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/functions.ts

@@ -0,0 +1,124 @@
+import type { Module, SernAutocompleteData, SernOptionsData } from '../types/core-modules';
+import type {
+    AnySelectMenuInteraction,
+    ButtonInteraction,
+    ChatInputCommandInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+    AutocompleteInteraction,
+} from 'discord.js';
+import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
+import { PluginType } from './structures/enums';
+import type { Payload, UnpackedDependencies } from '../types/utility';
+import path from 'node:path'
+
+export const createSDT = (module: Module, deps: UnpackedDependencies, params: string|undefined) => {
+    return {
+        state: {},
+        deps,
+        params, 
+        type: module.type,
+        module: {
+            name: module.name,
+            description: module.description,
+            locals: module.locals,
+            meta: module.meta
+        }
+    }
+}
+
+/**
+ * Removes the first character(s) _[depending on prefix length]_ of the message
+ * @param msg
+ * @param prefix The prefix to remove
+ * @returns The message without the prefix
+ * @example
+ * message.content = '!ping';
+ * console.log(fmt(message.content, '!'));
+ * // [ 'ping' ]
+ */
+export function fmt(msg: string, prefix?: string): string[] {
+    if(!prefix) throw Error("Unable to parse message without prefix");
+    return msg.slice(prefix.length).trim().split(/\s+/g);
+}
+
+
+export function partitionPlugins<T,V>
+(arr: Array<{ type: PluginType }> = []): [T[], V[]] {
+    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] as [T[], V[]];
+}
+
+export const createLookupTable = (options: SernOptionsData[]): Map<string, SernAutocompleteData> => {
+    const table = new Map<string, SernAutocompleteData>();
+    _createLookupTable(table, options, "<parent>");
+    return table;
+}
+
+const _createLookupTable = (table: Map<string, SernAutocompleteData>, options: SernOptionsData[], parent: string) => {
+    for (const opt of options) {
+        const name = path.posix.join(parent, opt.name)
+        switch(opt.type) {
+            case ApplicationCommandOptionType.Subcommand: {
+                    _createLookupTable(table, opt.options ?? [], name);
+            } break;
+            case ApplicationCommandOptionType.SubcommandGroup: {
+                    _createLookupTable(table, opt.options ?? [], name);
+            } break;
+            default: {
+                if(Reflect.get(opt, 'autocomplete') === true) {
+                    table.set(name, opt as SernAutocompleteData)
+                }
+            } break;
+        }
+    } 
+
+}
+
+interface InteractionTypable {
+    type: InteractionType;
+}
+//discord.js pls fix ur typings or i will >:(
+type AnyMessageComponentInteraction = AnySelectMenuInteraction | ButtonInteraction;
+type AnyCommandInteraction =
+    | ChatInputCommandInteraction
+    | MessageContextMenuCommandInteraction
+    | UserContextMenuCommandInteraction;
+
+export function isMessageComponent(i: InteractionTypable): i is AnyMessageComponentInteraction {
+    return i.type === InteractionType.MessageComponent;
+}
+export function isCommand(i: InteractionTypable): i is AnyCommandInteraction {
+    return i.type === InteractionType.ApplicationCommand;
+}
+export function isContextCommand(i: AnyCommandInteraction): i is MessageContextMenuCommandInteraction | UserContextMenuCommandInteraction {
+    return i.isContextMenuCommand();
+}
+export function isAutocomplete(i: InteractionTypable): i is AutocompleteInteraction {
+    return i.type === InteractionType.ApplicationCommandAutocomplete;
+}
+
+export function isModal(i: InteractionTypable): i is ModalSubmitInteraction {
+    return i.type === InteractionType.ModalSubmit;
+}
+
+export function resultPayload<T extends 'success'|'warning'|'failure'>
+(type: T, module?: Module, reason?: unknown) {
+    return { type, module, reason } as Payload & { type : T };
+}
+
+export function pipe<T>(arg: unknown, firstFn: Function, ...fns: Function[]): T {
+  let result = firstFn(arg);
+  for (let fn of fns) {
+    result = fn(result);
+  }
+  return result;
+}

src/core/id.ts

@@ -0,0 +1,74 @@
+import { ApplicationCommandType, ComponentType, type Interaction, InteractionType } from 'discord.js';
+import { CommandType, EventType } from './structures/enums';
+
+const parseParams = (event: { customId: string }, append: string) => {
+    const hasSlash = event.customId.indexOf('/')
+    if(hasSlash === -1) {
+        return { id:event.customId+append };
+    }
+    const baseid = event.customId.substring(0, hasSlash);
+    const params = event.customId.substring(hasSlash+1);
+    return { id: baseid+append, params }
+}
+/**
+ * Construct unique ID for a given interaction object.
+ * @param event The interaction object for which to create an ID.
+ * @returns An array of unique string IDs based on the type and properties of the interaction object.
+ */
+export function reconstruct<T extends Interaction>(event: T) {
+    switch (event.type) {
+        case InteractionType.MessageComponent: {
+            const data = parseParams(event, `_C${event.componentType}`)
+            return [data];
+        }
+        case InteractionType.ApplicationCommand:
+        case InteractionType.ApplicationCommandAutocomplete: 
+            return [{ id: `${event.commandName}_A${event.commandType}` }, { id: `${event.commandName}_B` }];
+        //Modal interactions are classified as components for sern
+        case InteractionType.ModalSubmit: {
+            const data = parseParams(event, '_M');
+            return [data];
+        }
+    }
+}
+/**
+ *
+ * A magic number to represent any commandtype that is an ApplicationCommand.
+ */
+const PUBLISHABLE = 0b000000001111;
+
+
+const TypeMap = new Map<number, number>([[CommandType.Text, 0],
+                                        [CommandType.Both, 0],
+                                        [CommandType.Slash, ApplicationCommandType.ChatInput],
+                                        [CommandType.CtxUser, ApplicationCommandType.User],
+                                        [CommandType.CtxMsg, ApplicationCommandType.Message],
+                                        [CommandType.Button, ComponentType.Button],
+                                        [CommandType.StringSelect, ComponentType.StringSelect],
+                                        [CommandType.Modal, InteractionType.ModalSubmit],
+                                        [CommandType.UserSelect, ComponentType.UserSelect],
+                                        [CommandType.MentionableSelect, ComponentType.MentionableSelect],
+                                        [CommandType.RoleSelect, ComponentType.RoleSelect],
+                                        [CommandType.ChannelSelect, ComponentType.ChannelSelect]]);
+
+/*
+ * Generates an id based on name and CommandType.
+ * A is for any ApplicationCommand. C is for any ComponentCommand
+ * Then, another number fetched from TypeMap
+ */
+export function create(name: string, type: CommandType | EventType) {
+    if(type == CommandType.Text) {
+        return `${name}_T`;
+    }
+    if(type == CommandType.Both) {
+        return `${name}_B`;
+    }
+    if(type == CommandType.Modal) {
+        return `${name}_M`;
+    }
+    const am = (PUBLISHABLE & type) !== 0 ? 'A' : 'C';
+    return `${name}_${am}${TypeMap.get(type)!}`
+}
+
+
+

src/core/interfaces.ts

@@ -0,0 +1,55 @@
+import type { AnyFunction } from '../types/utility';
+
+
+/**
+ * Represents an initialization contract.
+ * Let dependencies implement this to initiate some logic.
+ */
+export interface Init {
+    init(): unknown;
+}
+
+/**
+ * Represents a Disposable contract.
+ * Let dependencies implement this to dispose and cleanup.
+ */
+export interface Disposable {
+    dispose(): unknown;
+}
+
+
+export interface Emitter {
+    addListener(eventName: string | symbol, listener: AnyFunction): this;
+    removeListener(eventName: string | symbol, listener: AnyFunction): this;
+    emit(eventName: string | symbol, ...payload: any[]): boolean;
+}
+
+
+/**
+ * @since 2.0.0
+ */
+export interface ErrorHandling {
+    /**
+     * @deprecated
+     * Version 4 will remove this method
+     */
+    crash(err: Error): never;
+    /**
+     * A function that is called on every throw.
+     * @param error
+     */
+    updateAlive(error: Error): void;
+
+}
+
+/**
+ * @since 2.0.0
+ */
+export interface Logging<T = unknown> {
+    error(payload: LogPayload<T>): void;
+    warning(payload: LogPayload<T>): void;
+    info(payload: LogPayload<T>): void;
+    debug(payload: LogPayload<T>): void;
+}
+
+export type LogPayload<T = unknown> = { message: T };

src/core/ioc.ts

@@ -0,0 +1,163 @@
+import { Service as $Service, Services as $Services } from '@sern/ioc/global'
+import { Container } from '@sern/ioc';
+import * as Contracts from './interfaces';
+import * as  __Services from './structures/default-services';
+import type { Logging } from './interfaces';
+import { __init_container, useContainerRaw } from '@sern/ioc/global';
+import { EventEmitter } from 'node:events';
+import { Client } from 'discord.js';
+import { Module } from '../types/core-modules';
+import { UnpackFunction } from '../types/utility';
+
+export function disposeAll(logger: Logging|undefined) {
+   useContainerRaw() 
+        ?.disposeAll()
+        .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
+}
+
+type Insertable = | ((container: Dependencies) => object)
+                  | object
+
+const dependencyBuilder = (container: Container) => {
+    return {
+        /**
+          * Insert a dependency into your container.
+          * Supply the correct key and dependency
+          */
+        add(key: keyof Dependencies, v: Insertable) {
+            if(typeof v !== 'function') {
+                container.addSingleton(key, v)
+            } else {
+                //@ts-ignore
+                container.addWiredSingleton(key, (cntr) => v(cntr))
+            }
+        },
+        /**
+          * @param key the key of the dependency
+          * @param v The dependency to swap out.
+          * Swap out a preexisting dependency.
+          */
+        swap(key: keyof Dependencies, v: Insertable) {
+            if(typeof v !== 'function') {
+                container.swap(key, v);
+            } else {
+                container.swap(key, v(container.deps()));
+            }
+        },
+   };
+};
+
+type ValidDependencyConfig =
+    (c: ReturnType<typeof dependencyBuilder>) => any
+
+/**
+  * makeDependencies constructs a dependency injection container for sern handler to use.
+  * This is required to start the handler, and is to be called before Sern.init.
+  * @example
+  * ```ts
+  * await makeDependencies(({ add }) => {
+  *     add('@sern/client', new Client({ intents, partials }) 
+  * })
+  * ```
+  */
+export async function makeDependencies (conf: ValidDependencyConfig) {
+    const container = await __init_container({ autowire: false });
+    //We only include logger if it does not exist 
+    const includeLogger = !container.hasKey('@sern/logger');
+
+    if(includeLogger) {
+        container.addSingleton('@sern/logger', new __Services.DefaultLogging);
+    }
+    container.addSingleton('@sern/errors', new __Services.DefaultErrorHandling);
+    container.addSingleton('@sern/modules', new Map);
+    container.addSingleton('@sern/emitter', new EventEmitter({ captureRejections: true }))
+    container.addSingleton('@sern/scheduler', new __Services.TaskScheduler)
+    conf(dependencyBuilder(container));
+    await container.ready();
+}
+
+
+/**
+ * The Service api, which allows users to access dependencies in places IOC cannot reach. 
+ * To obtain intellisense, ensure a .d.ts file exists in the root of compilation.
+ * Our scaffolding tool takes care of this.
+ * Note: this method only works AFTER your container has been initiated
+ * @since 3.0.0
+ * @example
+ * ```ts
+ * const client = Service('@sern/client');
+ * ```
+ * @param key a key that corresponds to a dependency registered.
+ * @throws if container is absent or not present
+ */
+export function Service<const T extends keyof Dependencies>(key: T) {
+    return $Service(key) as Dependencies[T]
+}
+/**
+ * @since 3.0.0
+ * The plural version of {@link Service}
+ * @throws if container is absent or not present
+ * @returns array of dependencies, in the same order of keys provided
+ *
+ */
+export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]) {
+    return $Services<T, IntoDependencies<T>>(...keys)
+}
+
+/**
+ * @deprecated
+ * Creates a singleton object.
+ * @param cb
+ */
+export function single<T>(cb: () => T) { 
+    console.log('The `single` function is deprecated and has no effect')
+    return cb(); 
+}
+
+/**
+ * @deprecated
+ * @since 2.0.0
+ * Creates a transient object
+ * @param cb
+ */
+export function transient<T>(cb: () => () => T) { 
+    console.log('The `transient` function is deprecated and has no effect')
+    return cb()(); 
+}
+
+export type DependencyFromKey<T extends keyof Dependencies> = Dependencies[T];
+
+
+
+export type IntoDependencies<Tuple extends [...any[]]> = {
+    [Index in keyof Tuple]: UnpackFunction<NonNullable<DependencyFromKey<Tuple[Index]>>>; //Unpack and make NonNullable
+} & { length: Tuple['length'] };
+
+export interface CoreDependencies {
+    /**
+      * discord.js client.
+      */
+    '@sern/client':  Client;
+    /**
+      * sern emitter listens to events that happen throughout
+      * the handler. some include module.register, module.activate.
+      */
+    '@sern/emitter': Contracts.Emitter;
+    /**
+      * An error handler which is the final step before 
+      * the sern process actually crashes.
+      */
+    '@sern/errors':  Contracts.ErrorHandling;
+    /**
+      * Optional logger. Performs ... logging
+      */
+    '@sern/logger'?: Contracts.Logging;
+    /**
+      * Readonly module store. sern stores these 
+      * by module.meta.id -> Module
+      */
+    '@sern/modules': Map<string, Module>;
+
+    '@sern/scheduler': __Services.TaskScheduler
+}
+

src/core/module-loading.ts

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { readdir } from 'fs/promises';
+import assert from 'node:assert';
+import * as Id from './id'
+import { Module } from '../types/core-modules';
+
+export const parseCallsite = (site: string) => {
+    const pathobj = path.posix.parse(site.replace(/file:\\?/, "")
+                                   .split(path.sep)
+                                   .join(path.posix.sep))
+    return { name: pathobj.name,
+             absPath : path.posix.format(pathobj) }
+}
+
+export const shouldHandle = (pth: string, filenam: string) => {
+    const file_name = filenam+path.extname(pth);
+    let newPath = path.join(path.dirname(pth), file_name)
+                      .replace(/file:\\?/, "");
+    return { exists: existsSync(newPath),
+             path: 'file://'+newPath };
+}
+
+
+/**
+ * Import 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: Module = fileModule.default;
+
+    assert(commandModule , `No default export @ ${absPath}`);
+    if ('default' in commandModule) {
+        commandModule = commandModule.default as Module;
+    }
+    const p = path.parse(absPath)
+    commandModule.name ??= p.name; commandModule.description ??= "...";
+    commandModule.meta = {
+        id: Id.create(commandModule.name, commandModule.type),
+        absPath,
+    };
+    return { module: commandModule as T };
+}
+
+
+export async function* readRecursive(dir: string): AsyncGenerator<string> {
+    const files = await readdir(dir, { withFileTypes: true });
+    for (const file of files) {
+        const fullPath = path.posix.join(dir, file.name);
+        if (file.isDirectory()) {
+            if (!file.name.startsWith('!')) {
+                yield* readRecursive(fullPath);
+            }
+        } else if (!file.name.startsWith('!')) {
+            yield "file:///"+path.resolve(fullPath);
+        }
+    }
+}
+
+

src/core/modules.ts

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

src/core/plugin.ts

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

src/core/presences.ts

@@ -0,0 +1,65 @@
+import type { ActivitiesOptions } from "discord.js";
+import type { IntoDependencies } from "./ioc";
+import type { Emitter } from "./interfaces";
+import { Awaitable } from "../types/utility";
+
+type Status = 'online' | 'idle' | 'invisible' | 'dnd'
+type PresenceReduce = (previous: Presence.Result) => Awaitable<Presence.Result>;
+
+export const Presence = {
+    /**
+     * A small wrapper to provide type inference.
+     * Create a Presence module which **MUST** be put in a file called presence.(language-extension)
+     * adjacent to the file where **Sern.init** is CALLED.
+     */
+    module : <T extends (keyof Dependencies)[]>(conf: Presence.Config<T>) => conf,
+    /**
+     * Create a Presence body which can be either: 
+     * - once, the presence is activated only once.
+     * - repeated, per cycle or event, the presence can be changed.
+     */
+    of : (root: Omit<Presence.Result, 'repeat' | 'onRepeat'>) => {
+        return { 
+            /**
+             * @example
+             * Presence
+             *     .of({ activities: [{ name: "deez nuts" }] }) //starts presence with "deez nuts".
+             *     .repeated(prev => { 
+             *         return {
+             *             afk: true,
+             *             activities: prev.activities?.map(s => ({ ...s, name: s.name+"s" }))
+             *         };
+             *     }, 10000)) //every 10 s, the callback sets the presence to the value returned.
+             */
+            repeated: (onRepeat: PresenceReduce, repeat: number | [Emitter, string]) => {
+                return { repeat, onRepeat, ...root }
+            },
+            /**
+             * @example
+             * ```ts
+             * Presence.of({
+             *    activities: [{ name: "Chilling out" }]
+             * }).once() // Sets the presence once, with what's provided in '.of()'
+             *  ```
+             */
+            once: () => root
+        };
+    }
+}
+export declare namespace Presence {
+    export type Config<T extends (keyof Dependencies)[]> = {
+        inject?: [...T]
+        execute: (...v: IntoDependencies<T>) => Awaitable<Presence.Result>;
+
+    }
+
+    export interface Result { 
+        status?: Status;
+        afk?: boolean;
+        activities?: ActivitiesOptions[];
+        shardId?: number[];
+        repeat?: number | [Emitter, string];
+        onRepeat?: PresenceReduce 
+    }
+}
+

src/core/structures/context.ts

@@ -0,0 +1,131 @@
+import type {
+    BaseInteraction,
+    ChatInputCommandInteraction,
+    Client,
+    InteractionReplyOptions,
+    Message,
+    MessageReplyOptions,
+    Snowflake,
+    User,
+} from 'discord.js';
+import { Result, Ok, Err, val } from './result';
+import * as assert from 'assert';
+import type { ReplyOptions } from '../../types/utility';
+import { fmt } from '../functions'
+import { SernError } from './enums';
+
+
+/**
+ * @since 1.0.0
+ * Provides values shared between
+ * Message and ChatInputCommandInteraction
+ */
+export class Context {
+    
+    get options() {
+        if(this.isMessage()) {
+            const [, ...rest] = fmt(this.message.content, this.prefix);
+            return rest;
+        } 
+        return this.interaction.options;
+    }
+    
+
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>,
+                          private __prefix?: string) { }
+    public get prefix() {
+        return this.__prefix;
+    }
+    public get id(): Snowflake {
+        return val(this.ctx).id
+    }
+
+    public get channel() {
+        return val(this.ctx).channel;
+    }
+
+    public get channelId(): Snowflake {
+        return val(this.ctx).channelId;
+    }
+    
+    /**
+     * If context is holding a message, message.author
+     * else, interaction.user
+     */
+    public get user(): User {
+        if(this.ctx.ok) {
+            return this.ctx.value.author;
+        } 
+        return this.ctx.error.user;
+        
+    }
+
+    public get userId(): Snowflake {
+        return this.user.id;
+    }
+
+    public get createdTimestamp(): number {
+        return val(this.ctx).createdTimestamp;
+    }
+
+    public get guild() {
+        return val(this.ctx).guild;
+    }
+
+    public get guildId() {
+        return val(this.ctx).guildId;
+    }
+    /*
+     * interactions can return APIGuildMember if the guild it is emitted from is not cached
+     */
+    public get member() {
+        return val(this.ctx).member;
+    }
+
+    get message(): Message {
+        if(this.ctx.ok) {
+            return this.ctx.value;
+        }
+        throw Error(SernError.MismatchEvent);
+    }
+    public isMessage(): this is Context & { ctx: Result<Message, never> } {
+        return this.ctx.ok;
+    }
+
+    public isSlash(): this is Context & { ctx: Result<never, ChatInputCommandInteraction> } {
+        return !this.isMessage();
+    }
+
+    get interaction(): ChatInputCommandInteraction {
+        if(!this.ctx.ok) {
+            return this.ctx.error;
+        }
+        throw Error(SernError.MismatchEvent);
+    }
+
+
+    public get client(): Client {
+        return val(this.ctx).client;
+    }
+
+    public get inGuild(): boolean {
+        return val(this.ctx).inGuild()
+    }
+
+    public async reply(content: ReplyOptions) {
+        if(this.ctx.ok) {
+            return this.ctx.value.reply(content as MessageReplyOptions)
+        } 
+        interface FetchReply { fetchReply: true };
+        return this.ctx.error.reply(content as InteractionReplyOptions & FetchReply)
+       
+    }
+
+    static wrap(wrappable: BaseInteraction | Message, prefix?: string): Context {
+        if ('interaction' in wrappable) {
+            return new Context(Ok(wrappable), prefix);
+        }
+        assert.ok(wrappable.isChatInputCommand(), "Context created with bad interaction.");
+        return new Context(Err(wrappable), prefix);
+    }
+}

src/core/structures/default-services.ts

@@ -0,0 +1,89 @@
+import { ScheduledTask } from '../../types/core-modules';
+import type { LogPayload, Logging, ErrorHandling, Disposable } from '../interfaces';
+import { CronJob } from 'cron';
+
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using the defaults!
+ */
+export class DefaultErrorHandling implements ErrorHandling {
+    crash(err: Error): never {
+        throw err;
+    }
+    updateAlive(err: Error) {
+        throw err;
+    }
+}
+
+
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
+ */
+export class DefaultLogging implements Logging {
+    private date() { return new Date() } 
+    debug(payload: LogPayload): void {
+        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    error(payload: LogPayload): void {
+        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    info(payload: LogPayload): void {
+        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    warning(payload: LogPayload): void {
+        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+}
+
+
+export class TaskScheduler implements Disposable {
+    private __tasks: Map<string, CronJob<any, any>> = new Map();
+
+    schedule(uuid: string, task: ScheduledTask, deps: Dependencies) {
+        if (this.__tasks.has(uuid)) {
+            throw Error("while scheduling a task \
+                         found another task of same name. Not scheduling " +
+                         uuid + "again."  );
+        }
+        try {
+            const onTick = async function(this: CronJob) {
+                task.execute({ id: uuid,
+                               lastTimeExecution: this.lastExecution,
+                               nextTimeExecution: this.nextDate().toJSDate() }, { deps })
+           }
+           const job = CronJob.from({ cronTime: task.trigger, onTick, timeZone: task.timezone });
+           job.start();
+           this.__tasks.set(uuid, job);
+        } catch (error) {
+           throw Error(`while scheduling a task ${uuid} ` +  error);
+        }
+    }
+  
+    kill(taskName: string): boolean {
+        const job = this.__tasks.get(taskName);
+        if (job) {
+            job.stop();
+            this.__tasks.delete(taskName);
+            return true;
+        }
+        return false;
+    }
+  
+    get tasks(): string[] {
+        return Array.from(this.__tasks.keys());
+    }
+
+    dispose() {
+        this.__tasks.forEach((_, id) => {
+            this.kill(id);
+            this.__tasks.delete(id);
+        })
+    }
+    
+}

src/core/structures/enums.ts

@@ -0,0 +1,134 @@
+/**
+ * @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,
+    /**
+     * The EventType for handling sern events
+     */
+    Sern,
+    /**
+     * The EventType for handling external events.
+     * Could be for example, `process` events, database events
+     */
+    External,
+}
+
+/**
+ * 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,
+}
+/**
+ * @deprecated - Use strings 'success' | 'failure' | 'warning'
+ * @enum { string }
+ */
+export enum PayloadType {
+    Success = 'success',
+    Failure = 'failure',
+    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/result.ts

@@ -0,0 +1,20 @@
+export type Result<Ok, Err> =
+  | { ok: true; value: Ok }
+  | { ok: false; error: Err };
+
+export const Ok = <Ok>(value: Ok) => ({ ok: true, value } as const);
+export const Err = <Err>(error: Err) => ({ ok: false, error } as const);
+
+export const val = <O, E>(r: Result<O, E>) => r.ok ? r.value : r.error;
+export const EMPTY_ERR = Err(undefined);
+
+/**
+ * Wrap an async operation that may throw an Error (`try-catch` style) into checked exception style
+ * @param op The operation function
+ */
+export async function wrapAsync<T, E = unknown>(op: () => Promise<T>): Promise<Result<T, E>> {
+    try { return op()
+            .then(Ok)
+            .catch(Err); } 
+    catch (e) { return Promise.resolve(Err(e as E)); }
+}

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,121 +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, EventModule } from './structures/module';
-import { 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);
-}
-
-/**
- *
- * @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;
-}

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,147 +0,0 @@
-import type { APIGuildMember } from 'discord-api-types/v10';
-import type {
-    ChatInputCommandInteraction,
-    Client,
-    Guild,
-    GuildMember,
-    InteractionReplyOptions,
-    Message,
-    ReplyMessageOptions,
-    Snowflake,
-    TextBasedChannel,
-    User,
-} from 'discord.js';
-import { type Option, None, Some } from 'ts-results-es';
-import type { Nullish } 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: string | Omit<InteractionReplyOptions, 'fetchReply'> | ReplyMessageOptions,
-    ) {
-        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 | ReplyMessageOptions);
-            }),
-        )!;
-    }
-}

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,20 +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 {
-    readonly client: Client;
-    readonly sernEmitter?: SernEmitter;
-    readonly defaultPrefix?: string;
-    readonly commands: string;
-    readonly events?:
-        | string
-        | { mod: EventModule; absPath: string }[]
-        | (() => { 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,86 +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 Ok({ mod, absPath });
-                } else return Err(SernError.UndefinedModule);
-            }),
-        ),
-    ).pipe(concatAll());
-}
-
-export function getCommands(dir: string): string[] {
-    return readPath(join(process.cwd(), dir));
-}

src/handler/utilities/treeSearch.ts

@@ -1,40 +0,0 @@
-import type { SernOptionsData } from '../structures/module';
-import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
-
-export default function treeSearch(
-    iAutocomplete: AutocompleteInteraction,
-    options: SernOptionsData[] | undefined,
-) {
-    if (options === undefined) return undefined;
-    const _options = options.slice(); // required to prevent direct mutation of options
-    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) {
-                            return cur;
-                        }
-                        return undefined;
-                    }
-                }
-                break;
-        }
-    }
-}

src/handlers/event-utils.ts

@@ -0,0 +1,74 @@
+import type { Emitter, Logging } from '../core/interfaces';
+import { SernError } from '../core/structures/enums'
+import { Ok, wrapAsync} from '../core/structures/result';
+import type {  Module } from '../types/core-modules';
+import { inspect } from 'node:util'
+import { resultPayload } from '../core/functions'
+import merge from 'deepmerge'
+
+
+interface ExecutePayload {
+    module: Module;
+    args: unknown[];
+    [key: string]: unknown
+}
+
+
+function isObject(item: unknown) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+//_module is frozen, preventing from mutations
+export async function callInitPlugins(_module: Module, deps: Dependencies, emit?: boolean) {
+    let module = _module;
+    const emitter = deps['@sern/emitter'];
+    for(const plugin of module.plugins ?? []) {
+        const result = await plugin.execute({ module, absPath: module.meta.absPath, deps });
+        if (!result) throw Error("Plugin did not return anything. " + inspect(plugin, false, Infinity, true));
+        if(!result.ok) {
+            if(emit) {
+                emitter?.emit('module.register',
+                              resultPayload('failure', module, result.error ?? SernError.PluginFailure));
+            }
+            throw Error((result.error ?? SernError.PluginFailure) +
+                        'on module ' + module.name + " " + module.meta.absPath);
+        }
+    }
+    return module
+}
+
+export function executeModule(emitter: Emitter, logger: Logging|undefined, { module, args } : ExecutePayload) {
+    
+    const moduleCalled = wrapAsync(async () => {
+        return module.execute(...args);
+    })
+    moduleCalled 
+        .then((res) => {
+            if(res.ok) {
+                emitter.emit('module.activate', resultPayload('success', module))    
+            } else {
+                if(!emitter.emit('error', resultPayload('failure', module, res.error))) {
+                    // node crashes here.
+                    logger?.error({ 'message': res.error })
+                }
+            }
+        })
+        .catch(err => { 
+            throw err 
+        })
+};
+
+
+export async function callPlugins({ args, module }: ExecutePayload) {
+    let state = {};
+    for(const plugin of module.onEvent??[]) {
+        const result = await plugin.execute(...args);
+        if(!result.ok) {
+            return result;
+        }
+        if(isObject(result.value)) {
+            state = merge(state, result.value!);
+        }
+    }
+    return Ok(state);
+}

src/handlers/interaction.ts

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

src/handlers/message.ts

@@ -0,0 +1,54 @@
+import type { Message } from 'discord.js';
+import { callPlugins, executeModule } from './event-utils';
+import { SernError } from '../core/structures/enums'
+import { createSDT, fmt, resultPayload } from '../core/functions'
+import type { UnpackedDependencies } from '../types/utility';
+import type { Module } from '../types/core-modules';
+import { Context } from '../core/structures/context';
+
+/**
+ * Ignores messages from any person / bot except itself
+ * @param prefix
+ */
+function isBotOrNoPrefix(msg: Message, prefix: string) {
+    return 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 (deps: UnpackedDependencies, defaultPrefix?: string) {
+    const {"@sern/emitter": emitter,  
+           '@sern/logger': log, 
+           '@sern/modules': mg,
+           '@sern/client': client} = deps
+
+    if (!defaultPrefix) {
+        log?.debug({ message: 'No prefix found. message handler shutting down' });
+        return;
+    }
+    client.on('messageCreate', async message => {
+        if(isBotOrNoPrefix(message, defaultPrefix)) {
+           return 
+        }
+        const [prefix] = fmt(message.content, defaultPrefix);
+        let module = mg.get(`${prefix}_T`) ?? mg.get(`${prefix}_B`) as Module;
+        if(!module) {
+            log?.warning({ message: 'Possibly undefined behavior: could not find a static id to resolve' });
+        }
+        const payload = { module, args: [Context.wrap(message, defaultPrefix), createSDT(module, deps, undefined)] }
+        const result = await callPlugins(payload)
+        if (!result.ok) {
+            emitter.emit('module.activate', resultPayload('failure', module, result.error ?? SernError.PluginFailure))
+            return
+        }
+
+        //@ts-ignore
+        payload.args[1].state = result.value
+
+        executeModule(emitter, log, payload)
+    })
+    
+}

src/handlers/presence.ts

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

src/handlers/ready.ts

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

src/handlers/tasks.ts

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

src/handlers/user-defined-events.ts

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

src/index.ts

@@ -1,7 +1,55 @@
-import SernEmitter from './handler/sernEmitter';
-export { eventModule, commandModule } from './handler/sern';
-export * as Sern from './handler/sern';
-export * from './types/handler';
-export * from './handler/structures/structxports';
-export * from './handler/plugins/plugin';
-export { SernEmitter };
+export * as Sern from './sern';
+
+export type {
+    Module,
+    CommandModule,
+    EventModule,
+    BothCommand,
+    ContextMenuMsg,
+    ContextMenuUser,
+    SlashCommand,
+    TextCommand,
+    ButtonCommand,
+    StringSelectCommand,
+    MentionableSelectCommand,
+    UserSelectCommand,
+    ChannelSelectCommand,
+    RoleSelectCommand,
+    ModalSubmitCommand,
+    DiscordEventCommand,
+    SernEventCommand,
+    ExternalEventCommand,
+    CommandModuleDefs,
+    EventModuleDefs,
+    SernAutocompleteData,
+    SernOptionsData,
+    SernSubCommandData,
+    SernSubCommandGroupData,
+    SDT,
+    ScheduledTask
+} from './types/core-modules';
+
+export type {
+    PluginResult,
+    InitPlugin,
+    ControlPlugin,
+    Plugin,
+    AnyPlugin,
+} from './types/core-plugin';
+
+
+export type { Payload, SernEventsMapping, Wrapper } from './types/utility';
+
+export {
+    commandModule,
+    eventModule,
+    discordEvent,
+    scheduledTask
+} from './core/modules';
+
+export * from './core/presences'
+export * from './core/interfaces'
+export * from './core/plugin';
+export { CommandType, PluginType, PayloadType, EventType } from './core/structures/enums';
+export { Context } from './core/structures/context';
+export { type CoreDependencies, makeDependencies, single, transient, Service, Services } from './core/ioc';

src/sern.ts

@@ -0,0 +1,80 @@
+//side effect: global container
+import { useContainerRaw } from '@sern/ioc/global';
+// set asynchronous capturing of errors
+import events from 'node:events'
+events.captureRejections = true;
+
+import callsites from 'callsites';
+import * as  Files from './core/module-loading';
+import eventsHandler from './handlers/user-defined-events';
+import ready  from './handlers/ready';
+import { interactionHandler } from './handlers/interaction';
+import { messageHandler } from './handlers/message'
+import { presenceHandler } from './handlers/presence';
+import type { Payload, UnpackedDependencies, Wrapper } from './types/utility';
+import type { Presence} from './core/presences';
+import { registerTasks } from './handlers/tasks';
+
+
+/**
+ * @since 1.0.0
+ * @param maybeWrapper 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 = { commands: "./dist/commands" }) {
+    const startTime = performance.now();
+    const deps = useContainerRaw().deps<UnpackedDependencies>();
+    if (maybeWrapper.events !== undefined) {
+        eventsHandler(deps, maybeWrapper)
+            .then(() => {
+                deps['@sern/logger']?.info({ message: "Events registered" });
+            });
+    } else {
+        deps['@sern/logger']?.info({ message: "No events registered" });
+    }
+
+    // autohandle errors that occur in modules.
+    // convenient for rapid iteration
+    if(maybeWrapper.handleModuleErrors) {
+        if(!deps['@sern/logger']) {
+            throw Error('A logger is required to handleModuleErrors.\n A default logger is already supplied!');
+        }
+        deps['@sern/logger']?.info({ 'message': 'handleModuleErrors enabled' })
+        deps['@sern/emitter'].addListener('error', (payload: Payload) => {
+            if(payload.type === 'failure') {
+                deps['@sern/logger']?.error({ message: payload.reason })
+            } else {
+                deps['@sern/logger']?.warning({ message: "error event should only have payloads of 'failure'" });
+            }
+        })
+    }
+
+    const initCallsite = callsites()[1].getFileName();
+    const presencePath = Files.shouldHandle(initCallsite!, "presence");
+    //Ready event: load all modules and when finished, time should be taken and logged
+    ready(maybeWrapper.commands, deps)
+        .then(() => {
+            const time = ((performance.now() - startTime) / 1000).toFixed(2);
+            deps['@sern/logger']?.info({ message: `sern: registered in ${time} s` });
+            if(presencePath.exists) {
+                const setPresence = async (p: Presence.Result) => {
+                    return deps['@sern/client'].user?.setPresence(p);
+                }
+                presenceHandler(presencePath.path, setPresence);
+            }
+            if(maybeWrapper.tasks) {
+                registerTasks(maybeWrapper.tasks, deps);
+            }
+        })
+        .catch(err => { throw err });
+    interactionHandler(deps, maybeWrapper.defaultPrefix);
+    messageHandler(deps, maybeWrapper.defaultPrefix)
+}

src/types/core-modules.ts

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

src/types/core-plugin.ts

@@ -0,0 +1,72 @@
+/*
+ * 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 {
+    Module,
+    Processed,
+    SDT,
+} from './core-modules';
+import type { Awaitable } from './utility';
+import type { CommandType, PluginType } from '../core/structures/enums'
+import type { Context } from '../core/structures/context'
+import type {
+    ButtonInteraction,
+    ChannelSelectMenuInteraction,
+    ChatInputCommandInteraction,
+    MentionableSelectMenuInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+    UserContextMenuCommandInteraction,
+    UserSelectMenuInteraction,
+} from 'discord.js';
+import { Result } from '../core/structures/result';
+
+export type PluginResult = Awaitable<Result<Record<string,unknown>|undefined, string|undefined>>;
+export interface InitArgs<T extends Processed<Module> = Processed<Module>> {
+    module: T;
+    absPath: string;
+    deps: Dependencies
+}
+export interface Plugin<Args extends any[] = any[]> {
+    type: PluginType;
+    execute: (...args: Args) => PluginResult;
+}
+
+export interface InitPlugin<Args extends any[] = any[]> extends Plugin<Args> {
+    type: PluginType.Init;
+    execute: (...args: Args) => PluginResult;
+}
+export interface ControlPlugin<Args extends any[] = any[]> extends Plugin<Args> {
+    type: PluginType.Control;
+}
+
+export type AnyPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<Module>>]>;
+
+export type CommandArgs<I extends CommandType = CommandType> = CommandArgsMatrix[I]
+
+interface CommandArgsMatrix {
+    [CommandType.Text]: [Context & { get options(): string[]}, SDT];
+    [CommandType.Slash]: [Context  & { get options(): ChatInputCommandInteraction['options']}, SDT];
+    [CommandType.Both]: [Context, SDT];
+    [CommandType.CtxMsg]: [MessageContextMenuCommandInteraction, SDT];
+    [CommandType.CtxUser]: [UserContextMenuCommandInteraction, SDT];
+    [CommandType.Button]: [ButtonInteraction, SDT];
+    [CommandType.StringSelect]: [StringSelectMenuInteraction, SDT];
+    [CommandType.RoleSelect]: [RoleSelectMenuInteraction, SDT];
+    [CommandType.ChannelSelect]: [ChannelSelectMenuInteraction, SDT];
+    [CommandType.MentionableSelect]: [MentionableSelectMenuInteraction, SDT];
+    [CommandType.UserSelect]: [UserSelectMenuInteraction, SDT];
+    [CommandType.Modal]: [ModalSubmitInteraction, SDT];
+}

src/types/dependencies.d.ts

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

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';
-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 }[]);
-
-export type Reconstruct<T> = T extends Omit<infer O, never> ? O & Reconstruct<O> : T;
-
-export type IsOptional<T> = {
-    [K in keyof T]-?: T[K] extends Required<T>[K] ? false : true;
-};
-
-/**
- * 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];
-};

src/types/utility.ts

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

test/autocomp.bench.ts

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

test/core/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,11 @@
+import { assertType, describe, it } from 'vitest';
+
+import * as  __Services  from '../../src/core/structures/default-services';
+import * as Contracts from '../../src/core/interfaces';
+
+describe('default contracts', () => {
+    it('should satisfy contracts', () => {
+        assertType<Contracts.Logging>(new __Services.DefaultLogging());
+        assertType<Contracts.ErrorHandling>(new __Services.DefaultErrorHandling());
+    });
+});

test/core/create-plugin.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import {
+    CommandControlPlugin,
+    CommandInitPlugin,
+    EventInitPlugin,
+} from '../../src';
+import { PluginType, controller } from '../../src';
+
+describe('create-plugins', () => {
+    it('should make proper control plugins', () => {
+        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,294 @@
+//@ts-nocheck
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { PluginType, SernOptionsData, controller } from '../../src/index';
+import { createLookupTable, partitionPlugins, treeSearch } from '../../src/core/functions';
+import { faker } from '@faker-js/faker';
+import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import { createRandomChoice, createRandomPlugins } from '../setup/util';
+
+describe('functions', () => {
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    
+    
+    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);
+    });
+
+    describe('autocomplete', ( ) => {
+        
+        it('should tree search options tree depth 1', () => {
+            const options: SernOptionsData[] = [
+                createRandomChoice(),
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: 'autocomplete',
+                    description: 'here',
+                    autocomplete: true,
+                    command: { onEvent: [], execute: vi.fn() },
+                },
+            ];
+            const table = createLookupTable(options)
+            const result = table.get('<parent>/autocomplete')
+            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', () => {
+                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: () => {},
+                                },
+                            },
+                        ],
+                    },
+                ];
+                const table = createLookupTable(options)
+                const result = table.get(`<parent>/${subcommandName}/nested`)
+                expect(result == undefined).to.be.false;
+                expect(result.name).to.be.eq('nested');
+                expect(result.command).to.be.not.undefined;
+            });
+
+        it('should tree search depth n > 2', () => {
+            const subgroupName = faker.string.alpha()
+            const subcommandName = faker.string.alpha();
+            const options: SernOptionsData[] = [
+                {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: subgroupName,
+                    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(),
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const table = createLookupTable(options)
+            const result = table.get(`<parent>/${subgroupName}/${subcommandName}/nested`)
+            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 ', () => {
+            const subcommandName = faker.string.alpha();
+            const groupname = faker.string.alpha()
+            const options: SernOptionsData[] = [
+                {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: groupname,
+                    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: () => {},
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const table = createLookupTable(options)
+            const result = table.get(`<parent>/${groupname}/${subcommandName}/nested`);
+            expect(result).toBeTruthy();
+            expect(result.name).to.be.eq('nested');
+            expect(result.command).to.be.not.undefined;
+        });
+        it('two subcommands with an option of the same name', () => {
+            const groupName = faker.string.alpha()
+            const subcommandName = faker.string.alpha();
+            const options: SernOptionsData[] = [
+                {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: groupName,
+                    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 + 'anothera',
+                            description: faker.string.alpha(),
+                            options: [
+                                createRandomChoice(),
+                                {
+                                    type: ApplicationCommandOptionType.String,
+                                    name: 'nested',
+                                    description: faker.string.alpha(),
+                                    autocomplete: true,
+                                    command: {
+                                        onEvent: [],
+                                        execute: () => {},
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            
+            const table = createLookupTable(options)
+            const result = table.get(`<parent>/${groupName}/${subcommandName}/nested`);
+            expect(result).toBeTruthy();
+            expect(result.name).to.be.eq('nested');
+            expect(result.command).to.be.not.undefined;
+
+
+        });
+
+        it('simulates autocomplete typing and resolution', () => {
+            const subcommandGroupName = faker.string.alpha()
+            const subcommandName = faker.string.alpha();
+            const optionName = faker.word.noun();
+            const options: SernOptionsData[] = [
+                {
+                    type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: subcommandGroupName,
+                    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;
+            const table = createLookupTable(options)
+            for (const char of optionName) {
+                accumulator += char;
+
+                const focusedValue = {
+                    name: accumulator,
+                    value: faker.string.alpha(),
+                    focused: true,
+                };
+                result = table.get(`<parent>/${subcommandGroupName}/${subcommandName}/${focusedValue.name}` );
+            }
+            expect(result).toBeTruthy();
+        });
+    })
+
+
+});

test/core/id.test.ts

@@ -0,0 +1,94 @@
+//@ts-nocheck
+import { expect, test, vi } from 'vitest'
+import { CommandType } from '../../src/core/structures/enums';
+
+import * as Id from '../../src/core/id'
+import { ButtonInteraction, ModalSubmitInteraction } from 'discord.js';
+
+test('id -> Text', () => {
+    expect(Id.create("ping", CommandType.Text)).toBe("ping_T")
+})
+
+test('id -> Both', () => {
+    expect(Id.create("ping", CommandType.Both)).toBe("ping_B")
+})
+
+test('id -> CtxMsg', () => {
+    expect(Id.create("ping", CommandType.CtxMsg)).toBe("ping_A3")
+})
+test('id -> CtxUsr', () => {
+    expect(Id.create("ping", CommandType.CtxUser)).toBe("ping_A2")
+})
+test('id -> Modal', () => {
+    expect(Id.create("my-modal", CommandType.Modal)).toBe("my-modal_M");
+})
+
+test('id -> Button', () => {
+    expect(Id.create("my-button", CommandType.Button)).toBe("my-button_C2");
+})
+
+test('id -> Slash', () => {
+    expect(Id.create("myslash", CommandType.Slash)).toBe("myslash_A1");
+})
+
+test('id -> StringSelect', () => {
+    expect(Id.create("mystringselect", CommandType.StringSelect)).toBe("mystringselect_C3");
+})
+
+test('id -> UserSelect', () => {
+    expect(Id.create("myuserselect", CommandType.UserSelect)).toBe("myuserselect_C5");
+})
+
+test('id -> RoleSelect', () => {
+    expect(Id.create("myroleselect", CommandType.RoleSelect)).toBe("myroleselect_C6");
+})
+
+test('id -> MentionSelect', () => {
+    expect(Id.create("mymentionselect", CommandType.MentionableSelect)).toBe("mymentionselect_C7");
+})
+
+test('id -> ChannelSelect', () => {
+    const modal = Id.create("mychannelselect", CommandType.ChannelSelect)
+    expect(modal).toBe("mychannelselect_C8");
+})
+
+test('id reconstruct button', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn"))
+    expect(idload[0].id).toBe("btn_C2")
+})
+
+test('id reconstruct button with params', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn/asdf"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("asdf")
+})
+test('id reconstruct modal with params', () => {
+    const idload = Id.reconstruct(new ModalSubmitInteraction("btn/asdf"))
+    expect(idload[0].id).toBe("btn_M")
+    expect(idload[0].params).toBe("asdf")
+})
+test('id reconstruct modal', () => {
+    const idload = Id.reconstruct(new ModalSubmitInteraction("btn"))
+    expect(idload[0].id).toBe("btn_M")
+    expect(idload[0].params).toBe(undefined)
+})
+test('id reconstruct button with empty params', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn/"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("")
+})
+test('id reconstruct with multiple slashes', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn//"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("/")
+})
+
+
+test('id reconstruct button', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe(undefined)
+})
+
+
+

test/core/module-loading.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest'
+import path from 'node:path'
+import * as Files from '../../src/core/module-loading'
+import { Module } from '../../src/types/core-modules'
+import { AssertionError } from 'node:assert'
+//TODO: mock fs?
+describe('module-loading', () => {
+    it('should get the filename of the commandmodule (linux, esm)', () => {
+        const fname = "///home/pooba/Projects/sern/halibu/dist/commands/ping.js"
+        const callsiteinfo = Files.parseCallsite(fname)
+        expect(callsiteinfo.name).toBe("ping")
+    })
+    it('should get filename of commandmodule (linux, cjs)', () => {
+        const fname = "file:///home/pooba/Projects/sern/halibu/dist/commands/ping.js"
+        const callsiteinfo = Files.parseCallsite(fname)
+        expect(callsiteinfo.name).toBe("ping")
+
+    })
+    it('should get the filename of the commandmodule (windows, cjs)', () => {
+        //this test case is impossible on linux.
+        if(process.platform == 'win32') {
+            const fname = "C:\\pooba\\Projects\\sern\\halibu\\dist\\commands\\ping.js"
+            const callsiteinfo = Files.parseCallsite(fname)
+            expect(callsiteinfo.name).toEqual("ping");
+        }
+    })
+    it('should get filename of commandmodule (windows, esm)', () => {
+        //this test case is impossible on linux.
+        if(process.platform == 'win32') {
+            const fname = "file:///C:\\pooba\\Projects\\sern\\halibu\\dist\\commands\\ping.js"
+            const callsiteinfo = Files.parseCallsite(fname)
+            expect(callsiteinfo.name).toEqual("ping");
+        }
+        
+    })
+
+    it('should import a commandModule properly', async () => {
+        const { module } = await Files.importModule<Module>(path.resolve("test", 'mockules', "module.ts"));
+        expect(module.name).toBe('module')
+    })
+    it('should throw when failed commandModule import', async () => {
+        try {
+            await Files.importModule(path.resolve('test', 'mockules', 'failed.ts'))
+        } catch(e) {
+            expect(e instanceof AssertionError)
+        }
+    })
+    it('should throw when failed commandModule import', async () => {
+        try {
+            await Files.importModule(path.resolve('test', 'mockules', 'failed.ts'))
+        } catch(e) {
+            expect(e instanceof AssertionError)
+        }
+    })
+
+    it('reads all modules in mockules', async () => {
+        const ps = [] as string[]
+        for await (const fpath of Files.readRecursive(path.resolve('test', 'mockules'))) {
+            ps.push(fpath)
+        }
+        expect(ps.length === 4)
+    })
+
+}) 

test/core/presence.test.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Presence } from '../../src';
+import * as Files from '../../src/core/module-loading'
+import { presenceHandler } from '../../src/handlers/presence'
+
+// Example test suite for the module function
+describe('module function', () => {
+  it('should return a valid configuration', () => {
+    const config = Presence.module({
+      inject: ['dependency1', 'dependency2'],
+      execute: vi.fn(),
+    });
+
+    expect(config).toBeDefined();
+    expect(config.inject).toEqual(['dependency1', 'dependency2']);
+    expect(typeof config.execute).toBe('function');
+  });
+});
+
+
+describe('of function', () => {
+  it('should return a valid presence configuration without repeat and onRepeat', () => {
+    const presenceConfig = Presence.of({
+      status: 'online',
+      afk: false,
+      activities: [{ name: 'Test Activity' }],
+      shardId: [1, 2, 3],
+    }).once();
+
+    expect(presenceConfig).toBeDefined();
+    //@ts-ignore Maybe fix?
+    expect(presenceConfig.repeat).toBeUndefined();
+    //@ts-ignore Maybe fix?
+    expect(presenceConfig.onRepeat).toBeUndefined();
+    expect(presenceConfig).toMatchObject({
+      status: 'online',
+      afk: false,
+      activities: [{ name: 'Test Activity' }],
+      shardId: [1, 2, 3],
+    });
+  });
+
+  it('should return a valid presence configuration with repeat and onRepeat', () => {
+    const onRepeatCallback = vi.fn();
+    const presenceConfig = Presence.of({
+      status: 'idle',
+      activities: [{ name: 'Another Test Activity' }],
+    }).repeated(onRepeatCallback, 5000);
+
+    expect(presenceConfig).toBeDefined();
+    expect(presenceConfig.repeat).toBe(5000);
+    expect(presenceConfig.onRepeat).toBe(onRepeatCallback);
+    expect(presenceConfig).toMatchObject({
+      status: 'idle',
+      activities: [{ name: 'Another Test Activity' }],
+    });
+  });
+
+
+})
+
+
+describe('Presence module execution', () => {
+    const mockExecuteResult = Presence.of({
+        status: 'online',
+    }).once();
+  
+    const mockModule = Presence.module({ 
+        inject: [ '@sern/client'],
+        execute: vi.fn().mockReturnValue(mockExecuteResult)
+    })
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock Files.importModule
+        vi.spyOn(Files, 'importModule').mockResolvedValue({
+          module: mockModule
+        });
+
+
+        
+    }); 
+    it('should set presence once.', async () => {
+        const setPresenceMock = vi.fn();
+        const mockPath = '/path/to/presence/config';
+    
+        await presenceHandler(mockPath, setPresenceMock);
+
+        expect(Files.importModule).toHaveBeenCalledWith(mockPath);
+        expect(setPresenceMock).toHaveBeenCalledOnce();
+    })
+
+})

test/handlers.test.ts

@@ -0,0 +1,65 @@
+//@ts-nocheck
+import { beforeEach, describe, expect, it, test } from 'vitest';
+import { callInitPlugins } from '../src/handlers/event-utils';
+
+import { Client } from 'discord.js'
+import { faker } from '@faker-js/faker';
+import { EventEmitter } from 'events';
+import { CommandControlPlugin, CommandType, controller } from '../src';
+import { createRandomModule, createRandomInitPlugin } from './setup/util';
+
+
+
+function mockDeps() {
+   return {
+        '@sern/client': new Client(),
+        '@sern/emitter': new EventEmitter()
+   }
+}
+ 
+describe('calling init plugins', async () => {
+   let deps;
+   beforeEach(() => {
+       deps = mockDeps()
+   });
+
+   test ('call init plugins', async () => {
+       const plugins = createRandomInitPlugin('go', { name: "abc" })
+       const mod = createRandomModule([plugins])
+       const s = await callInitPlugins(mod, deps, false)
+       expect("abc").equal(s.name)
+   })
+   test('init plugins replace array', async () => {
+       const plugins = createRandomInitPlugin('go', { opts: [] })
+       const plugins2 = createRandomInitPlugin('go', { opts: ['a'] })
+       const mod = createRandomModule([plugins, plugins2])
+       const s = await callInitPlugins(mod, deps, false)
+       expect(['a']).deep.equal(s.opts)
+   })
+
+})
+
+
+
+
+test('form sdt', async () => {
+
+    const expectedObject = { 
+        "plugin/abc": faker.person.jobArea(),
+        "plugin2/abc": faker.git.branch(),
+        "plugin3/cheese": faker.person.jobArea()
+    }
+    
+    const plugin = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin/abc": expectedObject['plugin/abc'] });
+    });
+    const plugin2 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin2/abc": expectedObject['plugin2/abc'] });
+    });
+    const plugin3 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin3/cheese": expectedObject['plugin3/cheese'] });
+    });
+    
+})
+
+

test/mockules/module.ts

@@ -0,0 +1,6 @@
+import { CommandType, commandModule } from '../../src/'
+export default commandModule({ 
+    type: CommandType.Both,
+    description: "",
+    execute: (Ctx, args) => {}
+})

test/mockules/ug/pass.ts

@@ -0,0 +1,6 @@
+import { CommandType, commandModule } from '../../../src/'
+export default commandModule({ 
+    type: CommandType.Both,
+    description: "",
+    execute: (Ctx, args) => {}
+})

test/setup/setup-tests.ts

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

test/setup/util.ts

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

tsconfig-base.json

@@ -1,17 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": "src",
-        "strict": true,
-        "esModuleInterop": true,
-        "noImplicitAny": true,
-        "strictNullChecks": true,
-        "importsNotUsedAsValues": "error",
-        "moduleResolution": "node",
-        "skipLibCheck": true,
-        "declaration": true,
-        "allowSyntheticDefaultImports": true,
-        "forceConsistentCasingInFileNames": true
-    },
-    "exclude": ["node_modules", "dist"],
-    "include": ["src"]
-}

tsconfig-cjs.json

@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig-base.json",
-    "compilerOptions": {
-        "module": "commonjs",
-        "outDir": "dist/cjs",
-        "target": "esnext"
-    }
-}

tsconfig-esm.json

@@ -1,8 +0,0 @@
-{
-    "extends": "./tsconfig-base.json",
-    "compilerOptions": {
-        "module": "esnext",
-        "outDir": "dist/esm",
-        "target": "esnext"
-    }
-}

tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "strictNullChecks": true,
+        "moduleResolution": "node16",
+        "skipLibCheck": true,
+        "declaration": true,
+        "preserveSymlinks": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "isolatedModules": true,
+        "outDir": "dist",
+        "module": "node16",
+        "target": "esnext",
+        "sourceMap": true
+    },
+    "exclude": ["node_modules", "dist"],
+    "include": ["./src", "./src/**/*.d.ts"]
+}

tsup.config.js

@@ -1,38 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig([
-    {
-        entry: ['src/index.ts'],
-        format: 'esm',
-        sourcemap: false,
-        target: 'node16',
-        tsconfig: './tsconfig-esm.json',
-        outDir: './dist/esm',
-        platform: 'node',
-        external: ['discord.js'],
-        clean: true,
-        treeshake: true,
-        outExtension() {
-            return {
-                js: '.mjs',
-            };
-        },
-    },
-    {
-        entry: ['src/index.ts'],
-        format: 'cjs',
-        splitting: false,
-        sourcemap: false,
-        external: ['discord.js'],
-        clean: true,
-        target: 'node16',
-        tsconfig: './tsconfig-cjs.json',
-        outDir: './dist/cjs',
-        platform: 'node',
-        outExtension() {
-            return {
-                js: '.cjs',
-            };
-        },
-    },
-]);

vitest.config.ts

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