Merge branch 'main' into fix/dispose

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

.eslintrc

@@ -1,13 +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,
-        "@typescript-eslint/ban-types": 0,
-        "@typescript-eslint/no-explicit-any": "off"
-    }
-}

.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,47 +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@ac593985615ec2ede58e132d2e21d2b1cbd6127c # v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3
-        with:
-          node-version: 17
-
-      - name: Install pnpm
-        run: npm i -g pnpm
-
-      # Prettier must be in `package.json`
-      - name: Install Node.js dependencies
-        run:  pnpm i
-
-      - name: Run Prettier
-        run: pnpm run pretty
-
-      - 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

.prettierrc

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

CHANGELOG.md

@@ -1,5 +1,238 @@
 # Changelog
 
+## [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)
 
 

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

@@ -3,10 +3,11 @@
 </div>
 
 <h1 align="center">Handlers. Redefined.</h1>
-<h4 align="center">A customizable, batteries-included, powerful discord.js framework to streamline bot development.</h4>
+<h4 align="center">A complete, customizable, typesafe, & reactive framework for discord bots</h4>
 
 <div align="center" styles="margin-top: 10px">
   <img src="https://img.shields.io/badge/open-source-brightgreen" />
+  <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>
@@ -14,108 +15,65 @@
   <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
-```
-## Why?
-- Most handlers don't support discord.js 14.7+
-- Customizable commands
-- Plug and play or customize to your liking
-- Embraces reactive programming for consistent and reliable backend
-- Customizable logger, error handling, and more
-- Active development and growing [community](https://sern.dev/discord)
-## 👀 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');
-
-const client = new Client({
-  intents: [
-    GatewayIntentBits.Guilds,
-    GatewayIntentBits.GuildMembers,
-    GatewayIntentBits.GuildMessages
-  ]
-});
-export const useContainer = Sern.makeDependencies({
-    build: root => root
-        .add({ '@sern/client': single(client)  })
-        .upsert({ '@sern/logger': single(new DefaultLogging()) })
-});
-
-//View docs for all options
-Sern.init({
-	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
-	commands: 'src/commands',
-	// events: 'src/events' (optional),
-	containerConfig : {
-		get: useContainer
-	}
-});
-
-client.login("YOUR_BOT_TOKEN_HERE");
-```
-
-#### ` ping.js (CommonJS)`
-
-```js
-const { CommandType, commandModule } = 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>
+
+# 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 your favorite artists on Discord.
-- [ava](https://github.com/SrIzan10/ava), A discord bot that plays KNGI and Gensokyo Radio.
-- [Siamese (WIP)](https://github.com/Benzo-Fury/Siamese-Bot), Using AI to unleash the power in your server.
-- [Protector (WIP)](https://github.com/needhamgary/Protector), Just a simple bot to help enhance a private minecraft server.
+- [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.dev)
 - [Support Server](https://sern.dev/discord)
 
 ## 👋 Contribute
-
 - 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.
 
-

bot/.gitignore

@@ -0,0 +1,4 @@
+/node_modules
+/dist
+.env
+.sern

bot/README.md

@@ -0,0 +1,6 @@
+# Test bot
+
+
+## add .env
+DISCORD_TOKEN=<token>
+NODE_ENV=<production|development>

bot/assets/locals/en-US.json

@@ -0,0 +1,12 @@
+{
+    "command/ping": {
+        "name": "ping",
+        "description": "yeth",
+        "options": { 
+            "asdfs": {
+                "name": "shidenglish",
+                "description": "yeah"
+            }
+        }
+    }
+}

bot/assets/locals/es-ES.json

@@ -0,0 +1,12 @@
+{
+    "command/ping": {
+        "name": "ping",
+        "description": "hola",
+        "options": { 
+            "asdfs": {
+                "name": "shidspnaol",
+                "description": "si"
+            }
+        }
+    }
+}

bot/assets/test.txt

@@ -0,0 +1 @@
+{ "sdfasdfas": "asdf" }

bot/package-lock.json

@@ -0,0 +1,418 @@
+{
+  "name": "plugtest",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "plugtest",
+      "version": "1.0.0",
+      "license": "UNLICENSED",
+      "dependencies": {
+        "@sern/handler": "file:../",
+        "@sern/localizer": "^1.1.3",
+        "@sern/publisher": "^1.1.2",
+        "discord.js": "^14.15.0",
+        "dotenv": "^16.4.5"
+      },
+      "devDependencies": {
+        "@types/node": "^17.0.25",
+        "typescript": "latest"
+      }
+    },
+    "..": {
+      "name": "@sern/handler",
+      "version": "4.2.4",
+      "license": "MIT",
+      "dependencies": {
+        "@sern/ioc": "^1.1.2",
+        "callsites": "^3.1.0",
+        "cron": "^3.1.7",
+        "deepmerge": "^4.3.1"
+      },
+      "devDependencies": {
+        "@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.14.1",
+        "eslint": "8.39.0",
+        "typescript": "5.0.2",
+        "vitest": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 20.0.x"
+      }
+    },
+    "../../tools/packages/builder": {
+      "name": "@sern/builder",
+      "version": "1.0.0-rc1",
+      "extraneous": true,
+      "license": "ISC",
+      "dependencies": {
+        "discord-api-types": "latest"
+      },
+      "devDependencies": {
+        "@types/node": "^20.1.0"
+      }
+    },
+    "../handler": {
+      "name": "@sern/handler",
+      "version": "4.2.3",
+      "extraneous": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sern/ioc": "^1.1.2",
+        "callsites": "^3.1.0",
+        "cron": "^3.1.7",
+        "deepmerge": "^4.3.1"
+      },
+      "devDependencies": {
+        "@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.14.1",
+        "eslint": "8.39.0",
+        "typescript": "5.0.2",
+        "vitest": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 20.0.x"
+      }
+    },
+    "../tools/packages/builder": {
+      "name": "@sern/builder",
+      "version": "1.0.0-rc1",
+      "extraneous": true,
+      "license": "ISC",
+      "dependencies": {
+        "discord-api-types": "latest"
+      },
+      "devDependencies": {
+        "@types/node": "^20.1.0"
+      }
+    },
+    "../tools/packages/localizer": {
+      "name": "@sern/localizer",
+      "version": "1.1.1",
+      "extraneous": true,
+      "license": "ISC",
+      "dependencies": {
+        "shrimple-locales": "^0.2.1"
+      },
+      "devDependencies": {
+        "@sern/handler": "^4.0.0",
+        "discord.js": "^14.15.3",
+        "vitest": "^1.2.2"
+      }
+    },
+    "node_modules/@discordjs/builders": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-1.10.0.tgz",
+      "integrity": "sha512-ikVZsZP+3shmVJ5S1oM+7SveUCK3L9fTyfA8aJ7uD9cNQlTqF+3Irbk2Y22KXTb3C3RNUahRkSInClJMkHrINg==",
+      "dependencies": {
+        "@discordjs/formatters": "^0.6.0",
+        "@discordjs/util": "^1.1.1",
+        "@sapphire/shapeshift": "^4.0.0",
+        "discord-api-types": "^0.37.114",
+        "fast-deep-equal": "^3.1.3",
+        "ts-mixer": "^6.0.4",
+        "tslib": "^2.6.3"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/collection": {
+      "version": "1.5.3",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-1.5.3.tgz",
+      "integrity": "sha512-SVb428OMd3WO1paV3rm6tSjM4wC+Kecaa1EUGX7vc6/fddvw/6lg90z4QtCqm21zvVe92vMMDt9+DkIvjXImQQ==",
+      "engines": {
+        "node": ">=16.11.0"
+      }
+    },
+    "node_modules/@discordjs/formatters": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/formatters/-/formatters-0.6.0.tgz",
+      "integrity": "sha512-YIruKw4UILt/ivO4uISmrGq2GdMY6EkoTtD0oS0GvkJFRZbTSdPhzYiUILbJ/QslsvC9H9nTgGgnarnIl4jMfw==",
+      "dependencies": {
+        "discord-api-types": "^0.37.114"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/rest": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/@discordjs/rest/-/rest-2.4.2.tgz",
+      "integrity": "sha512-9bOvXYLQd5IBg/kKGuEFq3cstVxAMJ6wMxO2U3wjrgO+lHv8oNCT+BBRpuzVQh7BoXKvk/gpajceGvQUiRoJ8g==",
+      "dependencies": {
+        "@discordjs/collection": "^2.1.1",
+        "@discordjs/util": "^1.1.1",
+        "@sapphire/async-queue": "^1.5.3",
+        "@sapphire/snowflake": "^3.5.3",
+        "@vladfrangu/async_event_emitter": "^2.4.6",
+        "discord-api-types": "^0.37.114",
+        "magic-bytes.js": "^1.10.0",
+        "tslib": "^2.6.3",
+        "undici": "6.19.8"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/rest/node_modules/@discordjs/collection": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-2.1.1.tgz",
+      "integrity": "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg==",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/util": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/util/-/util-1.1.1.tgz",
+      "integrity": "sha512-eddz6UnOBEB1oITPinyrB2Pttej49M9FZQY8NxgEvc3tq6ZICZ19m70RsmzRdDHk80O9NoYN/25AqJl8vPVf/g==",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/ws": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/ws/-/ws-1.2.0.tgz",
+      "integrity": "sha512-QH5CAFe3wHDiedbO+EI3OOiyipwWd+Q6BdoFZUw/Wf2fw5Cv2fgU/9UEtJRmJa9RecI+TAhdGPadMaEIur5yJg==",
+      "dependencies": {
+        "@discordjs/collection": "^2.1.0",
+        "@discordjs/rest": "^2.4.1",
+        "@discordjs/util": "^1.1.0",
+        "@sapphire/async-queue": "^1.5.2",
+        "@types/ws": "^8.5.10",
+        "@vladfrangu/async_event_emitter": "^2.2.4",
+        "discord-api-types": "^0.37.114",
+        "tslib": "^2.6.2",
+        "ws": "^8.17.0"
+      },
+      "engines": {
+        "node": ">=16.11.0"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@discordjs/ws/node_modules/@discordjs/collection": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-2.1.1.tgz",
+      "integrity": "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg==",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/@sapphire/async-queue": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.5.5.tgz",
+      "integrity": "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg==",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@sapphire/shapeshift": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@sapphire/shapeshift/-/shapeshift-4.0.0.tgz",
+      "integrity": "sha512-d9dUmWVA7MMiKobL3VpLF8P2aeanRTu6ypG2OIaEv/ZHH/SUQ2iHOVyi5wAPjQ+HmnMuL0whK9ez8I/raWbtIg==",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "lodash": "^4.17.21"
+      },
+      "engines": {
+        "node": ">=v16"
+      }
+    },
+    "node_modules/@sapphire/snowflake": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/@sapphire/snowflake/-/snowflake-3.5.3.tgz",
+      "integrity": "sha512-jjmJywLAFoWeBi1W7994zZyiNWPIiqRRNAmSERxyg93xRGzNYvGjlZ0gR6x0F4gPRi2+0O6S71kOZYyr3cxaIQ==",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@sern/handler": {
+      "resolved": "..",
+      "link": true
+    },
+    "node_modules/@sern/localizer": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@sern/localizer/-/localizer-1.1.3.tgz",
+      "integrity": "sha512-hTn0DtiAzIWSuokqMsvnVuFqU+P776p/Yv5etlrq+CWDgw332Hwuj3geyqN1C0yEjwF+ceyXJE/kGu2/inkEyg==",
+      "dependencies": {
+        "shrimple-locales": "^0.2.1"
+      }
+    },
+    "node_modules/@sern/publisher": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@sern/publisher/-/publisher-1.1.2.tgz",
+      "integrity": "sha512-1zh99JZykKUhqHhE75ZXfiLsBtf1WI+NnDCojv8UlpnGBEyzO8xyI1X7PNf6cPKRs4W9XqY3PqTJ+hrqzIsMkg=="
+    },
+    "node_modules/@types/node": {
+      "version": "17.0.45",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz",
+      "integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="
+    },
+    "node_modules/@types/ws": {
+      "version": "8.5.14",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.5.14.tgz",
+      "integrity": "sha512-bd/YFLW+URhBzMXurx7lWByOu+xzU9+kb3RboOteXYDfW+tr+JZa99OyNmPINEGB/ahzKrEuc8rcv4gnpJmxTw==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@vladfrangu/async_event_emitter": {
+      "version": "2.4.6",
+      "resolved": "https://registry.npmjs.org/@vladfrangu/async_event_emitter/-/async_event_emitter-2.4.6.tgz",
+      "integrity": "sha512-RaI5qZo6D2CVS6sTHFKg1v5Ohq/+Bo2LZ5gzUEwZ/WkHhwtGTCB/sVLw8ijOkAUxasZ+WshN/Rzj4ywsABJ5ZA==",
+      "engines": {
+        "node": ">=v14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/discord-api-types": {
+      "version": "0.37.119",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.37.119.tgz",
+      "integrity": "sha512-WasbGFXEB+VQWXlo6IpW3oUv73Yuau1Ig4AZF/m13tXcTKnMpc/mHjpztIlz4+BM9FG9BHQkEXiPto3bKduQUg=="
+    },
+    "node_modules/discord.js": {
+      "version": "14.17.3",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-14.17.3.tgz",
+      "integrity": "sha512-8/j8udc3CU7dz3Eqch64UaSHoJtUT6IXK4da5ixjbav4NAXJicloWswD/iwn1ImZEMoAV3LscsdO0zhBh6H+0Q==",
+      "dependencies": {
+        "@discordjs/builders": "^1.10.0",
+        "@discordjs/collection": "1.5.3",
+        "@discordjs/formatters": "^0.6.0",
+        "@discordjs/rest": "^2.4.2",
+        "@discordjs/util": "^1.1.1",
+        "@discordjs/ws": "^1.2.0",
+        "@sapphire/snowflake": "3.5.3",
+        "discord-api-types": "^0.37.114",
+        "fast-deep-equal": "3.1.3",
+        "lodash.snakecase": "4.1.1",
+        "tslib": "^2.6.3",
+        "undici": "6.19.8"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/discordjs/discord.js?sponsor"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.4.7",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
+      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
+    },
+    "node_modules/lodash.snakecase": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz",
+      "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw=="
+    },
+    "node_modules/magic-bytes.js": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/magic-bytes.js/-/magic-bytes.js-1.10.0.tgz",
+      "integrity": "sha512-/k20Lg2q8LE5xiaaSkMXk4sfvI+9EGEykFS4b0CHHGWqDYU0bGUFSwchNOMA56D7TCs9GwVTkqe9als1/ns8UQ=="
+    },
+    "node_modules/shrimple-locales": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/shrimple-locales/-/shrimple-locales-0.2.1.tgz",
+      "integrity": "sha512-j2vNBDXJgED3XqGXCD/vqXBSqwlDXP1iGkseVos8mCtZqHp3R+0FImx8xwtjeYufJcYfhjBMkaBTWgsBi8eJZw=="
+    },
+    "node_modules/ts-mixer": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.4.tgz",
+      "integrity": "sha512-ufKpbmrugz5Aou4wcr5Wc1UUFWOLhq+Fm6qa6P0w0K5Qw2yhaUoiWszhCVuNQyNwrlGiscHOmqYoAox1PtvgjA=="
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
+    },
+    "node_modules/typescript": {
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici": {
+      "version": "6.19.8",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.19.8.tgz",
+      "integrity": "sha512-U8uCCl2x9TK3WANvmBavymRzxbfFYG+tAu+fgx3zxQy3qdagQqBLwJVrdyO1TBfUXvfKveMKJZhpvUYoOjM+4g==",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.18.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
+      "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

bot/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "plugtest",
+  "version": "1.0.0",
+  "description": "a descriptiuon",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "sern build",
+    "start": "node ./dist/index.js",
+    "run": "node ./dist/index.js"
+  },
+  "keywords": [
+    "typescript",
+    "sern",
+    "discord.js"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@sern/handler": "file:../",
+    "@sern/localizer": "^1.1.3",
+    "@sern/publisher": "^1.1.2",
+    "discord.js": "^14.15.0",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.25",
+    "typescript": "latest"
+  },
+  "type": "module"
+}

bot/rm.py

@@ -0,0 +1,11 @@
+import os
+
+for root, dirs, files in os.walk('.'):
+    for filename in files:
+        if filename.endswith('.js'):
+            file_path = os.path.join(root, filename)
+            try:
+                os.remove(file_path)
+                print(f'Successfully deleted: {file_path}')
+            except OSError as e:
+                print(f'Error deleting {file_path}: {e.strerror}')

bot/sern.config.json

@@ -0,0 +1,13 @@
+{
+   "language": "typescript",
+   "defaultPrefix": "!",
+   "paths": {
+      "base": "src",
+      "commands": "commands",
+      "events": "events"
+   }, 
+   "app": { 
+        "tags": ["Nice ass bot"],
+        "description": "A bot"
+   }
+}

bot/src/commands/add.ts

@@ -0,0 +1,37 @@
+import { CommandType, commandModule } from "@sern/handler";
+import { ApplicationCommandOptionType } from "discord.js";
+
+export default commandModule({
+	name: 'add',
+	type: CommandType.Slash,
+	description: 'Adds numbers together',
+	options: [
+	    {
+		type: ApplicationCommandOptionType.String,
+		name: 'numbers',
+		description: 'Numbers to add together separated by a space.',
+		required: true,
+		min_length: 3,
+            },
+	],
+	execute: async (ctx) => {
+		let numbers = ctx.options.getString('numbers')?.split(' ')!;
+
+		numbers = numbers.filter((num) => num !== '');
+
+		if (!numbers.every((num) => !isNaN(parseFloat(num)))) {
+			return ctx.reply({
+				content: 'You can only input numbers.',
+				ephemeral: true,
+			});
+		}
+
+		const sum = numbers.reduce((acc, num) => acc + parseFloat(num), 0);
+
+
+		return ctx.reply({
+		    content: `The sum is ${sum}`,
+		    ephemeral: true,
+		});
+	},
+});

bot/src/commands/admin/!plugins.ts

@@ -0,0 +1,8 @@
+import { filter, hasRole } from "../../plugins/filter.js";
+import { ownerOnly } from "../../plugins/ownerOnly.js";
+import { ADMIN } from '../../constants.js'
+
+export default [
+    ownerOnly(),
+    filter({ condition: [hasRole(ADMIN)] })
+]

bot/src/commands/admin/admin.ts

@@ -0,0 +1,11 @@
+import { commandModule, CommandType } from '@sern/handler'
+
+
+
+export default commandModule({ 
+    type: CommandType.Slash,
+    description: "A",
+    execute: (ctx, args) => {
+        
+    }
+})

bot/src/commands/btn.ts

@@ -0,0 +1,14 @@
+import { CommandType, commandModule } from "@sern/handler"; 
+import { json } from "../plugins/json-params.js";
+
+export default commandModule({ 
+    type: CommandType.Button,
+    plugins: [json],
+    execute(ctx, args) {
+        console.log(args.state['json/data'])
+        //@ts-ignore
+        ctx.reply(args.state['json/data'].uid)
+    }
+
+
+})

bot/src/commands/channelselect.ts

@@ -0,0 +1,9 @@
+import { CommandType, commandModule } from "@sern/handler";
+
+export default commandModule({ 
+    type: CommandType.ChannelSelect,
+    execute: (s) => {
+        s.reply('clicked channel');
+    }
+
+});

bot/src/commands/chicken.ts

@@ -0,0 +1,25 @@
+import { CommandType, commandModule } from "@sern/handler";
+import { publishConfig } from "@sern/publisher";
+import { PermissionFlagsBits } from "discord.js";
+
+export default commandModule({
+    type: CommandType.Slash,
+    plugins: [
+        publishConfig({ 
+            integrationTypes: ['User'],
+            contexts: [0,1,2],
+            defaultMemberPermissions: 
+                PermissionFlagsBits.Speak
+                | PermissionFlagsBits.Connect 
+                | PermissionFlagsBits.BanMembers
+                
+
+            
+        })
+    ],
+    description: "yo",
+    execute:(ctx) => {
+        ctx.reply("hello");
+    }
+
+})

bot/src/commands/collectors.ts

@@ -0,0 +1,103 @@
+import { CommandType, Context, commandModule } from "@sern/handler";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from "discord.js";
+
+export default commandModule ({
+    type: CommandType.Slash,
+    description: 'collectors',
+    execute: async (ctx) => {
+        //await close(ctx)
+        await testCollect(ctx)
+    }
+})
+
+const testCollect = async (ctx: Context) => {
+    const msgcmpt = ctx.interaction.channel?.createMessageComponentCollector()
+    const buttonRow = new ActionRowBuilder<ButtonBuilder>().addComponents(
+	    new ButtonBuilder().setCustomId("closeyes").setLabel("Yes").setStyle(ButtonStyle.Success),
+	    new ButtonBuilder().setCustomId("closeno").setLabel("No").setStyle(ButtonStyle.Danger)
+    );
+    ctx.reply({ components: [buttonRow] })
+    msgcmpt?.on('collect', async button => {
+
+	await button.deferUpdate();
+        if (button.customId === "closeyes") {
+		try {
+                    await button.editReply('closing')
+		} catch (e) {
+		    await button.editReply({ content: "An error has occurred and I could not close the ticket...", components: [] });
+		}
+	} else {
+		await button.editReply({ content: "This ticket will remain open.", components: [] });
+		msgcmpt.stop();
+	}
+    });
+}
+//export const quiz = async(client: Client,  ctx: Context) => {
+//	try {
+//		const pokemon = Math.round(Math.random() * 890)
+//		const question = `https://cdn.dagpi.xyz/wtp/pokemon/${pokemon}q.png`;
+//		const answer = `https://cdn.dagpi.xyz/wtp/pokemon/${pokemon}a.png`;
+//
+//		const correctPokemon = await (await fetch(`https://pokeapi.co/api/v2/pokemon/${pokemon}`)).json();
+//		const allPokemon = await (await fetch("https://pokeapi.co/api/v2/pokemon?limit=899")).json();
+//
+//		const options: string[] = [];
+//		//client.utils.log("WARNING", "INFO", `Correct answer is ${correctPokemon.name}`);
+//
+//		while (options.length < 9) {
+//			let option = allPokemon.results[pokemon];
+//			if (options.includes(option.name)) continue;
+//			options.push(option.name);
+//		}
+//
+//		if (!options.includes(correctPokemon.name)) {
+//			options.splice(client.utils.randomRange(0, 10), 0, correctPokemon.name.toLowerCase());
+//		} else {
+//			while (options.length < 10) {
+//				let option = allPokemon.results[client.utils.randomRange(1, 890)];
+//				if (options.includes(option.name)) continue;
+//				options.push(option.name);
+//			}
+//		}
+//
+//		const msgEmbed = (await client.utils.CustomEmbed({ userID: ctx.user.id })).setTitle("Who's that Pokémon?").setImage(question);
+//		const row = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
+//			new StringSelectMenuBuilder().setCustomId("pokequiz").addOptions(
+//				options.sort().map((opt) => {
+//					return { label: client.utils.titleCase(opt), value: opt.toLowerCase() };
+//				})
+//			)
+//		);
+//
+//		const msg = await client.utils.fetchReply(ctx.interaction, { embeds: [msgEmbed], components: [row] });
+//		const filter = (i: StringSelectMenuInteraction) => i.user.id === ctx.user.id && i.message.id === msg.id;
+//
+//		const collector = msg.createMessageComponentCollector({ filter, componentType: ComponentType.StringSelect, time: 1000 * 20 });
+//		collector.on("collect", async (i) => {
+//			const guess = i.values[0].toLowerCase();
+//
+//			msgEmbed.setImage(answer).setTitle(`It's ${client.utils.titleCase(correctPokemon.name)}!`);
+//
+//			if (guess === correctPokemon.name.toLowerCase()) msgEmbed.setColor("Green").setFooter({ text: "You're correct!" });
+//			else msgEmbed.setColor("Red").setFooter({ text: `You guessed ${client.utils.titleCase(guess)}.` });
+//
+//			await i.update({ embeds: [msgEmbed], components: [] });
+//			collector.stop("Guessed");
+//		});
+//
+//		collector.on("end", async (i, reason) => {
+//			if (reason === "Guessed") return;
+//
+//			msgEmbed
+//				.setImage(answer)
+//				.setTitle(`It's ${client.utils.titleCase(correctPokemon.name)}!`)
+//				.setColor("Red")
+//				.setFooter({ text: "You did not guess in time." });
+//
+//			await ctx.interaction.editReply({ embeds: [msgEmbed], components: [] });
+//		});
+//	} catch (e) {
+//		client.utils.log("ERROR", __filename, `${e}`);
+//		return ctx.interaction.reply({ content: "An error has occurred. Please try again.", ephemeral: true });
+//	}
+//};

bot/src/commands/dmMe.ts

@@ -0,0 +1,6 @@
+import { CommandType, commandModule } from "@sern/handler";
+
+export default commandModule({
+    type: CommandType.Modal,
+    execute: (modal) => modal.reply('thanks')
+});

bot/src/commands/flat-autocmp.ts

@@ -0,0 +1,24 @@
+import { commandModule, CommandType } from "@sern/handler";
+import { ApplicationCommandOptionType } from "discord.js";
+
+export default commandModule({
+  description: "testing",
+  type: CommandType.Slash,
+  options: [
+    {
+      name: "option",
+      description: "option desc",
+      type: ApplicationCommandOptionType.String,
+      required: true,
+      autocomplete: true,
+      command: {
+        execute: (i) => {
+          i.respond([{ name: "rah", value: "rah" }]);
+        },
+      },
+    },
+  ],
+  execute: (ctx) => {
+    return ctx.reply("rah");
+  },
+});

bot/src/commands/nested.ts

@@ -0,0 +1,52 @@
+import { commandModule, CommandType } from "@sern/handler";
+import { ActionRowBuilder, ApplicationCommandOptionType, ModalBuilder, TextInputBuilder, TextInputStyle } from "discord.js";
+
+export default commandModule({
+        type: CommandType.Slash,
+        description : 'a ping command',
+        options: [
+            {
+                name: "nest",
+                description: "testing nested",
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                options : [
+                    {
+                        name: "nest",
+                        description: "testing nested",
+                        type: ApplicationCommandOptionType.Subcommand,
+                        options : [
+                            {
+                                name: "sdfasd",
+                                description: "testing autocomplete",
+                                autocomplete: true,
+                                type: ApplicationCommandOptionType.String,
+                                command : {
+                                    onEvent : [],
+                                    async execute(autocmp, sdt) {
+                                        //console.log(autocmp)
+                                        const choices = ['butt', 'deez', 'lmao', 'lmfao', 'nuts', 'chicken'];
+                                        await autocmp.respond(choices.map((e,i) => ({ name : e, value: i.toString()})));
+                                    }
+                                }
+                            }
+                        ]
+                    },
+                ]
+            },
+        ],
+        async execute ({ interaction }) {
+            const modal = new ModalBuilder()
+			.setCustomId('dmMe')
+			.setTitle('send something to my dm (nothing bad pls)');
+
+            const input = new TextInputBuilder()
+			.setCustomId('message')
+			.setLabel("Send something to me")
+			.setStyle(TextInputStyle.Short);
+
+            const firstActionRow = new ActionRowBuilder<TextInputBuilder>().addComponents([input]);
+            modal.addComponents([firstActionRow]);
+            await interaction.showModal(modal);
+        }
+});
+

bot/src/commands/ping-ctx-msg.ts

@@ -0,0 +1,8 @@
+import { CommandType, commandModule } from '@sern/handler'
+
+export default commandModule({ 
+    type: CommandType.CtxMsg,
+    execute: (i, sdt) => {
+        i.reply('pong msg')
+    }
+})

bot/src/commands/ping-ctx.ts

@@ -0,0 +1,9 @@
+import { CommandType, commandModule } from "@sern/handler";
+
+
+export default commandModule({ 
+    type: CommandType.CtxUser,
+    execute: (i, sdt) => {
+        i.reply('pong')
+    }
+})

bot/src/commands/ping.ts

@@ -0,0 +1,84 @@
+import {commandModule, CommandType,  controller, CommandInitPlugin, CommandControlPlugin } from '@sern/handler';
+import {
+    ActionRowBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    ChannelSelectMenuBuilder,
+    RoleSelectMenuBuilder,
+    UserSelectMenuBuilder,
+} from "discord.js";
+import { localize } from '@sern/localizer';
+
+const plugin = CommandControlPlugin(() => {
+    return controller.next({ a: 'from plugin1' });
+});
+
+const plugin2 = CommandControlPlugin(() => {
+    return controller.next({ a: 'from plugin2' });
+})
+
+const updateDescription = (description: string) => {
+  return CommandInitPlugin(() => {
+    if(description.length > 100) {
+        console.error("Description is invalid")
+        return controller.stop("From updateDescription: description is invalid");
+    }
+    return controller.next({ description }); // continue to next plugin
+  });
+};
+
+export default commandModule({
+    type: CommandType.Slash,
+    plugins: [localize()],
+    description: 'A ping command I just updated',
+    options: [
+        str(name("asdfs"),
+            description("sdfds"))
+    ],
+    execute: async (ctx, sdt) => {
+        ctx.interaction
+        const btn = new ButtonBuilder()
+            .setStyle(ButtonStyle.Link)
+            .setLabel("Click me")
+            .setURL('https://www.youtube.com/watch?v=dQw4w9WgXcQ&pp=ygUIcmlja3JvbGw%3D')
+
+        const editButton = new ButtonBuilder({
+            customId: `btn/{"uid":"1061421834341462036"}`,
+            label: "click me also",
+            emoji: "🛠",
+            style: ButtonStyle.Primary,
+        });
+
+        ctx.reply({ components: [
+            new ActionRowBuilder<ButtonBuilder>().addComponents(btn, editButton),
+            new ActionRowBuilder<UserSelectMenuBuilder>({
+                components: [
+                  new UserSelectMenuBuilder({
+                    custom_id: "userselect",
+                    placeholder: "select channel",
+                    minValues: 1,
+                  }),
+                ],
+              }),
+            new ActionRowBuilder<ChannelSelectMenuBuilder>().addComponents(
+                  new ChannelSelectMenuBuilder({
+                    custom_id: "channelselect",
+                    placeholder: "select channel",
+                    minValues: 1,
+
+                  }),
+            ),
+            new ActionRowBuilder<RoleSelectMenuBuilder>({
+                components: [
+                  new RoleSelectMenuBuilder({
+                    custom_id: "roleselect",
+                    placeholder: "select role",
+                    minValues: 1,
+                  }),
+                ],
+              })
+        ]})
+    },
+});
+
+

bot/src/commands/roleselect.ts

@@ -0,0 +1,9 @@
+import { CommandType, commandModule } from "@sern/handler"
+
+export default commandModule( {
+    type: CommandType.RoleSelect,
+    execute: (s) => {
+        s.reply('selected role')
+    }
+
+})

bot/src/commands/sernoptions.ts

@@ -0,0 +1,12 @@
+import { CommandType, commandModule } from "@sern/handler";
+
+
+export default commandModule({
+    type: CommandType.Slash,
+    description: 'shid',
+    execute({ interaction }) {
+        interaction.reply('hello')
+    }
+
+
+})

bot/src/commands/subcommandoption.ts

@@ -0,0 +1,62 @@
+import { commandModule, CommandType } from '@sern/handler';
+import { ApplicationCommandOptionType } from 'discord.js';
+
+export default commandModule({
+	type: CommandType.Slash,
+	description: 'A ping command',
+	options: [
+        {
+		name: "art",
+		type: ApplicationCommandOptionType.Subcommand,
+		description: "Lists out information about an Animal Crossing artwork.",
+		options: [
+		    {
+			name: "name",
+			description: "The name of the artwork to lookup.",
+			type: ApplicationCommandOptionType.String,
+			autocomplete: true,
+			required: true,
+			command: {
+                            async execute(ctx) {
+                                await ctx.respond([{ name: 'art', value: 'first' }])
+                            },
+			},
+		    },
+		],
+	},
+	{
+		name: "villager",
+		type: ApplicationCommandOptionType.Subcommand,
+		description: "Lists out information about an Animal Crossing villager.",
+		options: [
+			{
+				name: "name",
+				description: "The name of the villager to lookup.",
+				type: ApplicationCommandOptionType.String,
+				autocomplete: true,
+				required: true,
+				command: {
+					onEvent: [],
+					async execute(ctx) {
+						await ctx.respond([{ name: 'villager', value: 'second' } ])
+                                                },
+				},
+			},
+		],
+	    },
+        ],
+	execute: async (ctx) => {
+	    const command = ctx.options.getSubcommand();
+	    switch (command) {
+		    case "art": {
+
+                        ctx.reply('art');
+			    break;
+		    }
+			case "villager": {
+                            ctx.reply('vil');
+				break;
+			}
+		}
+	},
+});

bot/src/commands/test-ctx.ts

@@ -0,0 +1,40 @@
+import { ApplicationCommandOptionType } from "discord.js";
+import { Service, commandModule, CommandType } from "@sern/handler";
+
+export const config = {
+    guildIds: ['941002690211766332']
+}
+
+
+export default commandModule({
+    type: CommandType.Both,
+    description: 'tests context',
+    options: [
+        {
+            type: ApplicationCommandOptionType.String,
+            name: "hello",
+            description: "wassup",
+            required: false,
+        }
+    ],
+    async execute(ctx) {
+        const logger = Service('@sern/logger');
+
+        if(ctx.isMessage()) {
+            logger?.info({ message : ctx.message.content  })
+            logger?.info({ message : ctx.prefix  })
+        } else {
+            logger?.info({ message : ctx.interaction.toString() })
+        }
+
+        logger?.info({ message: ctx.id })
+        logger?.info({ message: ctx.channel?.toString()! })
+        logger?.info({ message: ctx.user.toString()! })
+        logger?.info({ message: ctx.createdTimestamp.toString() })
+        logger?.info({ message: ctx.guild?.toString() })
+        logger?.info({ message: ctx.member?.toString() })
+        logger?.info({ message: ctx.client })
+        logger?.info({ message: ctx.inGuild })
+        await ctx.reply("guayin bodishivatta")
+    }
+})

bot/src/commands/testing-neo.ts

@@ -0,0 +1,33 @@
+import { CommandType, commandModule } from "@sern/handler";
+import { ActionRowBuilder, ModalActionRowComponentBuilder, ModalBuilder, TextInputBuilder, TextInputStyle } from "discord.js";
+
+const informationRequestModal = new ModalBuilder()
+  .setCustomId("information-request")
+  .setTitle("More Information")
+  .addComponents(
+    new ActionRowBuilder<ModalActionRowComponentBuilder>().addComponents(
+      new TextInputBuilder()
+        .setCustomId("command-name")
+        .setLabel("Command Name")
+        .setPlaceholder("The name of the command that this bug occurred on.")
+        .setStyle(TextInputStyle.Short)
+        .setMinLength(4)
+        .setMaxLength(20)
+        .setRequired(true)));
+
+export default commandModule({
+    type: CommandType.Slash,
+    plugins: [],
+    description: "A random test command.",
+    execute: async (ctx) => {
+        await ctx.interaction.showModal(informationRequestModal);
+
+        await ctx.interaction
+          .awaitModalSubmit({ time: 300_000 })
+          .then(async (modal) => {
+              modal.reply("thanks brody")
+          })
+          .catch(() => null);
+  },
+});
+

bot/src/commands/userselect.ts

@@ -0,0 +1,8 @@
+import { CommandType, commandModule } from "@sern/handler";
+
+export default commandModule( {
+    type: CommandType.UserSelect,
+    execute: (s) => {
+        s.reply('selected user')
+    }
+})

bot/src/constants.ts

@@ -0,0 +1 @@
+export const ADMIN = '983754333944434712'

bot/src/dependencies.d.ts

@@ -0,0 +1,18 @@
+import type { 
+    Logging,
+    ErrorHandling,
+    CoreDependencies  
+} from '@sern/handler'
+import type { Publisher } from '@sern/publisher';
+import type { Localizer } from '@sern/localizer';
+declare global {
+   interface Dependencies extends CoreDependencies {
+        localizer: Localizer;
+        publisher: Publisher
+   }
+}
+
+export {}
+
+
+

bot/src/events/error.ts

@@ -0,0 +1,10 @@
+import { EventType, eventModule } from "@sern/handler";
+
+
+export default eventModule({ 
+    name: 'error',
+    type: EventType.Sern,
+    execute: (e) => {
+        console.log(e)
+    }
+})

bot/src/events/messageCreate.ts

@@ -0,0 +1,10 @@
+import { discordEvent } from "@sern/handler";
+
+const execute = (...args: any[]) => {
+    console.log(args[0].content)
+}
+export default discordEvent({
+    name: 'messageCreate',
+    once: true,
+    execute
+})

bot/src/events/module.activate.ts

@@ -0,0 +1,10 @@
+import {eventModule, EventType} from "@sern/handler";
+
+
+export default eventModule({
+    type: EventType.Sern,
+    name: 'module.activate',
+    execute(args) {
+        
+    }
+})

bot/src/events/modulesLoaded.ts

@@ -0,0 +1,9 @@
+import { CommandType, EventType, Service, eventModule } from "@sern/handler";
+
+
+export default eventModule({
+    type: EventType.Sern,
+    execute: async () => {
+        console.log('eventmodule: all loaded');
+    }
+})

bot/src/events/threadCreate.ts

@@ -0,0 +1,8 @@
+import { discordEvent } from "@sern/handler";
+
+export default discordEvent({
+    name: 'threadCreate',
+    execute(thread)  {
+        console.log(thread)
+    }
+})

bot/src/index.ts

@@ -0,0 +1,41 @@
+import 'dotenv/config';
+import { makeDependencies, Sern, Service } from '@sern/handler'
+import { Client, GatewayIntentBits, Partials } from 'discord.js';
+import { Publisher } from '@sern/publisher'
+import { Localization } from '@sern/localizer'
+
+__DEV__: console.log(1);
+
+const intents = GatewayIntentBits.Guilds |
+                GatewayIntentBits.GuildMembers |
+                GatewayIntentBits.GuildMessageReactions |
+                GatewayIntentBits.GuildMessages |
+                GatewayIntentBits.DirectMessages |
+                GatewayIntentBits.MessageContent;
+
+const partials = [
+    Partials.Channel 
+];
+
+async function init() {
+    await makeDependencies(({ add }) => {
+        add('@sern/client', new Client({ intents, partials }));
+        add('localizer', Localization());
+        add('publisher', deps => {
+            return new Publisher(deps['@sern/modules'],
+                                 deps['@sern/emitter'],
+                                 deps['@sern/logger']!) 
+        })
+    })
+    Sern.init({
+        commands : "./dist/commands",
+        events: "./dist/events",
+        tasks: "./dist/tasks",
+        defaultPrefix: "!"
+    })
+}
+init().then(() => {
+    Service('@sern/client').login()
+})
+//View docs for all options
+

bot/src/plugins/args.ts

@@ -0,0 +1,156 @@
+/**
+ * @author HighArcs
+ * @version 1.0.0
+ * @description converts array of argument strings to an object (and maps them)
+ * @license null
+ * @example
+ * ```ts
+ * import { parsedCommandModule, args } from "../plugins/args";
+ * import { CommandType } from "@sern/handler";
+ *
+ * interface Arg {
+ * 	 value: number;
+ * }
+ *
+ * export default parsedCommandModule({
+ *  type : CommandType.Text
+ *  plugins: [args({ value: Number })],
+ * 	execute: (ctx, args) => {
+ * 		console.log(ctx.args.value);
+ * 	}
+ * })
+ */
+
+import {
+    commandModule,
+    CommandType,
+    Context, ControlPlugin,
+    Plugin, CommandControlPlugin, controller
+} from "@sern/handler";
+import type { Awaitable } from "discord.js";
+
+type Converter<T> = (value?: string) => Awaitable<T>;
+type Struct = Record<string, any>;
+type ConverterList<T extends Struct> = {
+    [K in keyof T]: Converter<T[K]>;
+};
+type Ctx<T> = Context & { _args: T };
+
+interface Err {
+    key: string;
+    error: string;
+    given: string;
+    index: number;
+}
+
+type OnError<T> = (context: Ctx<T>, error: Err) => any;
+
+type SpecialEvt<T> = {
+    readonly "@@plugin": symbol
+} & ControlPlugin<[Ctx<T>, ]>
+
+async function convert<T extends Struct>(
+    args: Array<string>,
+    struct: ConverterList<T>
+) {
+    const entries = Object.entries(struct);
+    const result = {} as T;
+    for (let i = 0; i < entries.length; i++) {
+        const value = args[i];
+        const [key, converter] = entries[i]!;
+        try {
+            result[key as keyof T] = await converter(value);
+        } catch (error) {
+            throw { key, error: String(error), given: value, index: i };
+        }
+    }
+
+    return result;
+}
+
+interface ParsedInputCommandModule<T extends Struct> {
+    name?: string;
+    description: string;
+    type: CommandType.Both | CommandType.Text | CommandType.Slash;
+    execute: (context: Ctx<T>, args: Array<string>) => any;
+    plugins: () =>
+        | [SpecialEvt<T>, ...Array<Plugin>]
+        | []
+        | undefined;
+}
+
+export const Structs = {
+    string: (value: string) => String(value),
+    number: (value: string) => Number(value),
+    boolean: (value: string) => value === "true" || value === "1",
+    date: (value: string) => new Date(value),
+    integer: (value: string) => Number.parseInt(value),
+};
+
+export function parsedCommandModule<T extends Struct>(
+    a: ParsedInputCommandModule<T>
+) {
+    const plugins = (a.plugins() ?? []);
+    return commandModule({ ...a, plugins } as never);
+}
+
+export namespace Checks {
+    export function choices<K extends string>(
+        choices: K[],
+        value?: string
+    ): asserts value is K {
+        if (!choices.includes(value as unknown as K)) {
+            throw "value is not in choices";
+        }
+    }
+
+    export function required(value?: string): asserts value is string {
+        if (value === undefined) {
+            throw "value is required";
+        }
+    }
+
+    export function limit(min: number, max: number, value?: string) {
+        required(value);
+        const val = Structs.number(value);
+        if (val < min) {
+            throw `value must be higher than ${min}`;
+        }
+
+        if (val > max) {
+            throw `value must be lower than ${max}`;
+        }
+
+        return val;
+    }
+}
+
+export function args<T extends Struct>(
+    struct: ConverterList<T>,
+    onError?: OnError<T>
+): SpecialEvt<T> {
+    const plugin =  CommandControlPlugin<CommandType.Both>(async (ctx, args) => {
+        switch(args.type) {
+            case "slash": {
+                let result: T;
+            } break;
+            case "text" : {
+                let result: T;
+                try {
+                    result = await convert(args, struct)
+                } catch (e) {
+                    if (onError) {
+                      onError(ctx as Ctx<T>, e as Err);
+                    }
+                    return controller.stop();
+                }
+                //@warn - mutable assignment!
+                (ctx as Ctx<T>)._args = result;
+                return controller.next();
+            }
+        }
+        return controller.next()
+    })
+    Object.defineProperty(plugin, "@@plugin", { value: Symbol("args") })
+    return plugin as SpecialEvt<T>;
+}

bot/src/plugins/assertFields.ts

@@ -0,0 +1,57 @@
+/**
+ * This plugin checks the fields of a ModalSubmitInteraction
+ * with regex or a custom callback
+ *
+ * @author @jacoobes [<@182326315813306368>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * export default commandModule({
+ *     type: CommandType.Modal,
+ *     plugins: [
+ *         assertFields({
+ *             fields: {
+ *             // check the modal field "mcUsernameInput" with the regex /a+b+c/
+ *                 mcUsernameInput: /a+b+c+/
+ *             },
+ *             failure: (errors, interaction) => {
+ *                 interaction.reply(errors.join("\n"))
+ *             }
+ *         }),
+ *     ],
+ *     execute: ctx => {
+ *         ctx.reply("nice!")
+ *     }
+ * })
+ * ```
+ */
+import { CommandControlPlugin, CommandType, controller } from "@sern/handler";
+import type { ModalSubmitInteraction } from "discord.js";
+
+type Assertion =
+    | RegExp
+    | ((value : string) => boolean);
+
+export function assertFields(config: {
+    fields:  Record<string, Assertion>,
+    failure: (errors: string[], interaction: ModalSubmitInteraction) => any
+}) {
+    return CommandControlPlugin<CommandType.Modal>(modal => {
+        const pairs = Object.entries(config.fields);
+        const errors = [];
+        for(const [ field, assertion ] of pairs) {
+            // Keep in mind this doesn't check for typos!
+            // feel free to add more checks.
+            const input = modal.fields.getTextInputValue(field)
+            const resolvedAssertion = assertion instanceof RegExp ? (value: string) => assertion.test(value) : assertion;
+            if(!resolvedAssertion(input)) {
+                errors.push(input + " failed to pass assertion " + resolvedAssertion.toString() )
+            }
+        }
+        if(errors.length > 0) {
+            config.failure(errors, modal);
+            return controller.stop();
+        }
+        return controller.next();
+    })
+}

bot/src/plugins/channelType.ts

@@ -0,0 +1,39 @@
+/**
+ * This plugin checks if a channel is the specified type
+ *
+ * @author @Benzo-Fury [<@762918086349029386>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { channelType } from "../plugins/channelType";
+ * import { ChannelType } from "discord.js"
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ channelType([ChannelType.GuildText], 'This cannot be used here') ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+import { ChannelType } from "discord.js";
+import {CommandControlPlugin, CommandType, controller } from "@sern/handler";
+export function channelType(
+    channelType: ChannelType[],
+    onFail?: string
+){
+    return CommandControlPlugin<CommandType.Both>(async (ctx) => {
+        let channel = ctx.channel?.type;
+        //for some reason the dm channel type was returning undefined at some points
+        if (channel === undefined) {
+            channel = ChannelType.DM;
+        }
+        if (channelType.includes(channel)) {
+            return controller.next();
+        }
+        if (onFail) {
+            await ctx.reply(onFail);
+        }
+        return controller.stop();
+    })
+}

bot/src/plugins/confirmation.ts

@@ -0,0 +1,106 @@
+/**
+ * This is buttonConfirmation plugin, it runs confirmation prompt in the form of buttons.
+ * Note that you need to use edit/editReply in the command itself because we are already replying in the plugin!
+ * Credits to original plugin of confirmation using reactions and its author!
+ *
+ * @author @EvolutionX-10 [<@697795666373640213>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { buttonConfirmation } from "../plugins/buttonConfirmation";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ buttonConfirmation() ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+
+import {CommandControlPlugin, CommandType, controller} from "@sern/handler";
+import {
+    ActionRowBuilder,
+    ButtonBuilder,
+    ButtonStyle,
+    ComponentType,
+} from "discord.js";
+
+export function confirmation(
+    options?: Partial<ConfirmationOptions>
+) {
+    return CommandControlPlugin<CommandType.Both>(async (ctx, args) => {
+            options = {
+                content: "Do you want to proceed?",
+                denialMessage: "Cancelled",
+                labels: ["No", "Yes"],
+                time: 60_000,
+                wrongUserResponse: "Not for you!",
+                ...options,
+            };
+
+        const buttons = options.labels!.map((l, i) => {
+            return new ButtonBuilder()
+                .setCustomId(l)
+                .setLabel(l)
+                .setStyle( i === 0 ? ButtonStyle.Danger : ButtonStyle.Success
+                );
+        });
+        const sent = await ctx.reply({
+            content: options.content,
+            components: [
+                new ActionRowBuilder<ButtonBuilder>().setComponents(
+                    buttons
+                ),
+            ],
+        });
+
+        const collector = sent.createMessageComponentCollector({
+            componentType: ComponentType.Button,
+            filter: (i) => i.user.id === ctx.user.id,
+            time: options.time,
+        });
+
+        return new Promise((resolve) => {
+            collector.on("collect", async (i) => {
+                await i.update({ components: [] });
+                collector.stop();
+                if (i.customId === options!.labels![1]) {
+                    resolve(controller.next());
+                    return;
+                }
+                await i.editReply({
+                    content: options?.denialMessage,
+                });
+                resolve(controller.stop());
+            });
+
+            collector.on("end", async (c) => {
+                if (c.size) return;
+                buttons.forEach((b) => b.setDisabled());
+                await sent.edit({
+                    components: [
+                        new ActionRowBuilder<ButtonBuilder>().setComponents(
+                            buttons
+                        ),
+                    ],
+                });
+            });
+
+            collector.on("ignore", async (i) => {
+                await i.reply({
+                    content: options?.wrongUserResponse,
+                    ephemeral: true,
+                });
+            });
+        });
+    });
+}
+
+interface ConfirmationOptions {
+    content: string;
+    denialMessage: string;
+    time: number;
+    labels: [string, string];
+    wrongUserResponse: string;
+}

bot/src/plugins/correctFile.ts

@@ -0,0 +1,6 @@
+import {CommandInitPlugin, controller} from "@sern/handler";
+
+
+export const correctFile = CommandInitPlugin(() => {
+    return controller.stop()
+})

bot/src/plugins/disable.ts

@@ -0,0 +1,38 @@
+// @ts-nocheck
+/**
+ * Disables a command entirely, for whatever reasons you may need.
+ *
+ * @author @jacoobes [<@182326315813306368>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { disable } from "../plugins/disable";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ disable() ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+import { CommandType, EventPlugin, PluginType } from "@sern/handler";
+import { InteractionReplyOptions, ReplyMessageOptions } from "discord.js";
+
+export function disable(
+	onFail?:
+		| string
+		| Omit<InteractionReplyOptions, "fetchReply">
+		| ReplyMessageOptions
+): EventPlugin<CommandType.Both> {
+	return {
+		type: PluginType.Event,
+		description: "Disables command from responding",
+		async execute([ctx], controller) {
+			if (onFail !== undefined) {
+				await ctx.reply(onFail);
+			}
+			return controller.stop();
+		},
+	};
+}

bot/src/plugins/dmOnly.ts

@@ -0,0 +1,29 @@
+/**
+ * This is dmOnly plugin, it allows commands to be run only in DMs.
+ * For discord.js you should have the Partials.Channel and DirectMessages intent enabled.
+ * @author @EvolutionX-10 [<@697795666373640213>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { dmOnly } from "../plugins/dmOnly";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [dmOnly()],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+import {CommandControlPlugin, CommandType, controller } from "@sern/handler";
+export function dmOnly(
+    content?: string,
+    ephemeral?: boolean
+) {
+   return CommandControlPlugin<CommandType.Both>(async (ctx, _) => {
+       if (ctx.channel?.isDMBased()) return controller.next();
+
+       if (content) await ctx.reply({ content, ephemeral }); // Change this if you want or remove it for silent deny
+       return controller.stop();
+    })
+}

bot/src/plugins/filter.ts

@@ -0,0 +1,637 @@
+import {
+  CommandControlPlugin,
+  type CommandType,
+  type Context,
+  controller,
+} from "@sern/handler";
+import {
+  GuildMember,
+  GuildMemberRoleManager,
+  PermissionResolvable,
+  PermissionsBitField,
+  User,
+} from "discord.js";
+
+
+export type Test = (context: Context) => boolean;
+
+export class Criteria {
+  public constructor(
+    public readonly name: string,
+    public readonly execute: Test,
+    public readonly children: Array<Criteria>
+  ) {}
+  toString() {
+    return this.name + ' ' + this.children.map(c => c.name).join(', ')
+  }
+}
+
+export const or = (...filters: Array<FilterImpl>): FilterImpl => {
+    function execute(context: Context): boolean {
+      let pass = false;
+      tests: for (const filter of filters) {
+        if (filter.test(context)) {
+          pass = true;
+          break tests;
+        }
+      }
+
+      return pass;
+    }
+
+    const children: Array<Criteria> = filters.map((x) => x.criteria);
+
+    return new FilterImpl(
+      new Criteria("or", execute, children),
+      `or(${filters.map((x) => x.message).join(", ")})`
+    );
+}
+
+
+export const and = (...filters: Array<FilterImpl>): FilterImpl => {
+    function execute(context: Context): boolean {
+      for (const filter of filters) {
+        if (!filter.test(context)) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    const children: Array<Criteria> = filters.map((x) => x.criteria);
+
+    return new FilterImpl(
+      new Criteria("and", execute, children),
+      `and(${filters.map((x) => x.message).join(", ")})`
+    );
+
+}
+
+
+export const not = (filter: FilterImpl): FilterImpl => {
+    function execute(context: Context): boolean {
+      return !filter.test(context);
+    }
+
+    return new FilterImpl(
+      new Criteria("not", execute, [filter.criteria]),
+      `not(${filter.criteria})`
+    );
+  }
+export const custom =(execute: Test, message?: string): FilterImpl => {
+    return new FilterImpl(new Criteria("custom", execute, []), message);
+}
+
+export const withCustomMessage = (
+    filter: FilterImpl,
+    message?: string
+): FilterImpl => {
+    return new FilterImpl(filter.criteria, message);
+}
+
+export const hasGuildPermission = (
+    permission: PermissionResolvable
+): FilterImpl => {
+    const b = PermissionsBitField.resolve(permission);
+    const field = Object.entries(PermissionsBitField.Flags).find(
+      ([, v]) => v === b
+    );
+
+    if (field === undefined) {
+      throw new Error(
+        `unknown permission \`${permission}\` in filter \`hasGuildPermission\``
+      );
+    }
+
+    const [name] = field;
+
+    function execute(context: Context): boolean {
+      if (context.member !== null) {
+        if (typeof context.member.permissions === "string") {
+          return new PermissionsBitField(BigInt(context.member.permissions)).has(b);
+        }
+        return context.member.permissions.has(b);
+      }
+
+      return true;
+    }
+
+    return new FilterImpl(
+      new Criteria("hasGuildPermission", execute, []),
+      `has guild permission: ${name}`
+    );
+}
+export const hasChannelPermission = (
+    permission: PermissionResolvable,
+    channelId?: string
+  ): FilterImpl => {
+    const b = PermissionsBitField.resolve(permission);
+    const field = Object.entries(PermissionsBitField.Flags).find(
+      ([, v]) => v === b
+    );
+
+    if (field === undefined) {
+      throw new Error(
+        `unknown permission \`${permission}\` in filter \`hasChannelPermission\``
+      );
+    }
+
+    const [name] = field;
+
+    function execute(context: Context): boolean {
+      if (context.member !== null) {
+        const channel =
+          channelId !== undefined
+            ? context.guild?.channels.cache.get(channelId)
+            : context.channel;
+
+        // ?
+        if (channel == undefined || channel === null) {
+          return false;
+        }
+
+        if (channel.isDMBased()) {
+          return true;
+        }
+
+        const field2 = channel.permissionsFor(context.user);
+
+        // assume we have no permission overrides
+        if (field2 === null) {
+          if (context.member !== null) {
+            if (typeof context.member.permissions === "string") {
+              return new PermissionsBitField(
+                BigInt(context.member.permissions)
+              ).has(b);
+            }
+
+            return context.member.permissions.has(b);
+          }
+
+          return false;
+        }
+
+        return field2.has(b);
+      }
+
+      return true;
+    }
+
+    return new FilterImpl(
+      new Criteria("hasChannelPermission", execute, []),
+      channelId !== undefined
+        ? `has channel permission ${name} in <#${channelId}>`
+        : `has channel permission ${name}`
+    );
+  }
+
+export const canAddReactions =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("AddReactions", channelId);
+}
+
+export const canAttachFiles =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("AttachFiles", channelId);
+}
+
+export const canBanMembers = (): FilterImpl => {
+    return hasGuildPermission("BanMembers");
+}
+
+export const canChangeNickname = (): FilterImpl => {
+    return hasGuildPermission("ChangeNickname");
+}
+
+export const canConnect = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("Connect", channelId);
+}
+
+export const canCreateInstantInvite =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("CreateInstantInvite", channelId);
+  }
+
+export const canDeafenMembers =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("DeafenMembers", channelId);
+  }
+
+export const canEmbedLinks =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("EmbedLinks", channelId);
+  }
+
+export const canKickMembers =(): FilterImpl => {
+    return hasGuildPermission("KickMembers");
+  }
+
+export const canManageChannelWebhooks =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("ManageWebhooks", channelId);
+  }
+
+export const canManageChannels =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("ManageChannels", channelId);
+}
+
+export const canManageEmojisAndStickers =(): FilterImpl => {
+    return hasGuildPermission("ManageEmojisAndStickers");
+}
+
+export const canManageGuild =(): FilterImpl => {
+    return hasGuildPermission("ManageGuild");
+}
+
+export const canManageGuildWebhooks =(): FilterImpl => {
+    return hasGuildPermission("ManageWebhooks");
+}
+
+export const canManageMessages =(channelId?: string): FilterImpl => {
+    return hasChannelPermission("ManageMessages", channelId);
+}
+
+export const canManageNicknames = (): FilterImpl => {
+    return hasGuildPermission("ManageNicknames");
+}
+
+export const canManageRoles = (): FilterImpl => {
+    return hasGuildPermission("ManageRoles");
+}
+
+export const canMentionEveryone = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("MentionEveryone", channelId);
+  }
+
+export const canMoveMembers = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("MoveMembers", channelId);
+  }
+
+export const canMuteMembers = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("MuteMembers", channelId);
+  }
+
+export const canPrioritySpeaker = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("PrioritySpeaker", channelId);
+  }
+
+export const canReadMessageHistory = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("ReadMessageHistory", channelId);
+  }
+
+export const canViewChannel = (channelId: string): FilterImpl => {
+    return hasChannelPermission("ViewChannel", channelId);
+  }
+
+export const canSendMessages = (channelId: string): FilterImpl => {
+    return hasChannelPermission("SendMessages", channelId);
+  }
+
+export const canSendTtsMessages = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("SendTTSMessages", channelId);
+  }
+
+export const canSpeak = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("Speak", channelId);
+  }
+
+export const canStream = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("Stream", channelId);
+  }
+
+export const canUseExternalEmojis = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("UseExternalEmojis", channelId);
+  }
+
+export const canUseVoiceActivity = (channelId?: string): FilterImpl => {
+    return hasChannelPermission("UseVAD", channelId);
+  }
+
+export const canViewAuditLog = (): FilterImpl => {
+    return hasGuildPermission("ViewAuditLog");
+  }
+
+export const canViewGuildInsights = (): FilterImpl => {
+    return hasGuildPermission("ViewGuildInsights");
+  }
+
+export const channelIdIn = (channelIds: Array<string>): FilterImpl => {
+    function execute(context: Context): boolean {
+      return channelIds.includes(
+        context.isMessage()
+          ? context.message.channelId
+          : context.interaction.channelId
+      );
+    }
+
+    return new FilterImpl(
+      new Criteria("channelIdIn", execute, []),
+      `channel is one of: ${channelIds.map((v) => `<#${v}>`).join(", ")}`
+    );
+  }
+
+export const hasEveryRole = (roles: Array<string>): FilterImpl => {
+    return withCustomMessage(
+      and(...roles.map((v) => hasRole(v))),
+      `has all of: ${roles.map((v) => `<@&${v}>`).join(", ")}`
+    );
+  }
+
+export const hasMentionableRole = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.member !== null) {
+        if (context.member.roles instanceof GuildMemberRoleManager) {
+          return (
+            context.member.roles.cache.filter((x) => x.mentionable === true)
+              .size > 0
+          );
+        }
+
+        if (context.guild === null) {
+          return false;
+        }
+
+        return context.member.roles
+          .map((roleId) => context.guild!.roles.cache.get(roleId))
+          .filter((x) => x !== undefined)
+          .some((x) => x!.mentionable);
+      }
+
+      return false;
+    }
+    return new FilterImpl(
+      new Criteria("hasMentionableRole", execute, []),
+      "has a mentionable role"
+    );
+  }
+
+export const hasNickname = (nickname?: string): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.member !== null) {
+        if (context.member instanceof GuildMember) {
+          if (nickname !== null) {
+            return context.member.nickname === nickname;
+          }
+
+          return context.member.nickname !== null;
+        }
+
+        if (nickname !== null) {
+          return context.member.nick === nickname;
+        }
+
+        return (
+          context.member.nick !== null && context.member.nick !== undefined
+        );
+      }
+
+      // dm members can technically have nicknames but they're per-user, so this should never be true.
+      return false;
+    }
+    return new FilterImpl(new Criteria("hasNickname", execute, []), "has a nickname");
+  }
+
+export const hasParentId = (parentId: string): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.channel !== null) {
+        if (context.channel.isDMBased()) {
+          return false;
+        }
+
+        return context.channel.parentId === parentId;
+      }
+
+      return false;
+    }
+
+    return new FilterImpl(
+      new Criteria("hasParentId", execute, []),
+      `has channel parent <#${parentId}>`
+    );
+  }
+
+export const hasRole = (roleId: string): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.member !== null) {
+        if (context.member.roles instanceof GuildMemberRoleManager) {
+          return context.member.roles.cache.has(roleId);
+        }
+
+        if (context.guild === null) {
+          return false;
+        }
+
+        return context.member.roles.includes(roleId);
+      }
+
+      // assume dm members have every role ever.
+      return true;
+    }
+
+    return new FilterImpl(
+      new Criteria("hasRole", execute, []),
+      `has role <@&${roleId}>`
+    );
+  }
+
+export const hasSomeRole = (roles: Array<string>): FilterImpl => {
+    return withCustomMessage(
+      or(...roles.map((role) => hasRole(role))),
+      `has any of: ${roles.map((v) => `<@&${v}>`).join(", ")}`
+    );
+  }
+
+export const isAdministator = (): FilterImpl => {
+    return hasGuildPermission("Administrator");
+  }
+
+export const isChannelId = (channelId: string): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.isMessage()) {
+        return context.message.channelId === channelId;
+      }
+
+      return context.interaction.channelId === channelId;
+    }
+
+    return new FilterImpl(
+      new Criteria("isChannelId", execute, []),
+      `is channel <#${channelId}>`
+    );
+  }
+
+export const isChannelNsfw = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.channel !== null) {
+        if (context.channel.isDMBased() || context.channel.isThread()) {
+          return false;
+        }
+
+        return context.channel.nsfw;
+      }
+
+      return false;
+    }
+    return new FilterImpl(
+      new Criteria("isChannelNsfw", execute, []),
+      "channel marked as nsfw"
+    );
+  }
+
+export const isGuildOwner = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.guild !== null) {
+        return context.guild.ownerId === context.user.id;
+      }
+
+      return true;
+    }
+    return new FilterImpl(
+      new Criteria("isGuildOwner", execute, []),
+      "is guild owner"
+    );
+  }
+
+export const isBotOwner = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      if (context.client.application !== null) {
+        if (context.client.application.owner !== null) {
+          if (context.client.application.owner instanceof User) {
+            return context.user.id === context.client.application.owner.id;
+          }
+
+          return context.client.application.owner.members.has(context.user.id);
+        }
+      }
+
+      // nope
+      return false;
+    }
+    return new FilterImpl(new Criteria("isBotOwner", execute, []), "is bot owner");
+  }
+
+export const isUserId = (userId: string): FilterImpl => {
+    function execute(context: Context): boolean {
+      return context.user.id === userId;
+    }
+    return new FilterImpl(
+      new Criteria("isUserId", execute, []),
+      `is user: <@${userId}>`
+    );
+  }
+
+export const parentIdIn = (parentIds: Array<string>): FilterImpl => {
+    return withCustomMessage(
+      or(...parentIds.map((v) => hasParentId(v))),
+      `channel parent is one of: ${parentIds.map((v) => `<#${v}>`).join(", ")}`
+    );
+  }
+
+export const userIdIn = (userIds: Array<string>): FilterImpl => {
+    return withCustomMessage(
+      or(...userIds.map((v) => isUserId(v))),
+      `user is one of: ${userIds.map((v) => `<@${v}>`).join(", ")}`
+    );
+  }
+
+export const isInGuild = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      return context.guildId !== null;
+    }
+
+    return new FilterImpl(new Criteria("isInGuild", execute, []), "is in guild");
+  }
+
+export const isInDm = (): FilterImpl => {
+    const notInGuild = compose(not, isInGuild);
+    return withCustomMessage(notInGuild(), "is in dm");
+}
+
+export const never = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      void context;
+      return false;
+    }
+    return new FilterImpl(new Criteria("never", execute, []), "never");
+}
+
+export const always = (): FilterImpl => {
+    function execute(context: Context): boolean {
+      void context;
+      return true;
+    }
+    return new FilterImpl(new Criteria("always", execute, []), "always");
+}
+type CtxMap<T> = (arg: T) => FilterImpl;
+
+/**
+  * Call FilterImpls in right to left order. 
+  * @example 
+  * import { compose, isUserId, not } from '../plugins/filter'
+  * const isNotUserId = compose(not, isUserId)
+  *
+  */
+export const compose = <T = void>(...funcs: CtxMap<any>[]): CtxMap<T> => {
+    return (arg: T): FilterImpl => 
+        //@ts-ignore
+        funcs.reduceRight((result, func) => func(result), arg);
+}
+
+
+export class FilterImpl {
+  public readonly test: Test;
+
+  public constructor(
+    public readonly criteria: Criteria,
+    public message?: string
+  ) {
+    this.test = this.criteria.execute;
+  }
+}
+
+
+export type FilterOptions = {
+  condition: Array<FilterImpl> | FilterImpl,
+  onFailed?: (context: Context, filters: Array<FilterImpl>) => unknown
+};
+/**
+ * Generalized `filter` plugin. revised by jacoobes, all credit to original author.
+ * Perform declarative conditionals as plugins.  
+ * @author @trueharuu [<@504698587221852172>]
+ * @version 2.0.0
+ * @example 
+ * import { filter, not, isGuildOwner, canMentionEveryone } from '../plugins/filter';
+ * import { commandModule } from '@sern/handler';
+ *
+ * export default commandModule({
+ *     plugins: filter({ condition: [not(isGuildOwner()), canMentionEveryone()] }),
+ *     async execute(context) {
+ *       // your code here
+ *     }
+ * });
+ */
+
+export const filter = 
+  (options: FilterOptions) => {
+    return CommandControlPlugin<CommandType.Both>(async (context) => {
+      const arrayifiedCondition = Array.isArray(options.condition) ? options.condition : [options.condition]
+      const value = and(...arrayifiedCondition).test(context);
+
+      if (value) {
+        return controller.next();
+      }
+
+      if (options.onFailed !== undefined) {
+        await options.onFailed(context, arrayifiedCondition);
+      } else {
+        await context.reply({
+          ephemeral: true,
+          content: `you do not match the criteria for this command:\n${arrayifiedCondition
+            .map((x) => x.message)
+            .filter((x) => x !== undefined)
+            .join("\n")}`,
+          allowedMentions: {
+            repliedUser: false,
+            parse: [],
+          },
+        });
+      }
+
+      return controller.stop();
+    });
+  };

bot/src/plugins/filterA.ts

@@ -0,0 +1,40 @@
+import { PluginType, makePlugin, controller, ControlPlugin } from "@sern/handler";
+import type { AutocompleteInteraction } from 'discord.js'
+
+/** 
+ * @plugin
+ * filters autocomplete interaction that pass the criteria
+ * @author @jacoobes [<@182326315813306368>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { CommandType, commandModule } from "@sern/handler";
+ * import { filterA } from '../plugins/filterA.js'
+ * export default commandModule({
+ *    type : CommandType.Slash,
+ *    options: [
+ *       {  
+ *          autocomplete: true,
+ *          command : {
+ *             //only accept autocomplete interactions that include 'poo' in the text
+ *             onEvent: [filterA(s => s.includes('poo'))],
+ *             execute: (autocomplete) => {
+ *                let data = [{ name: 'pooba', value: 'first' }, { name: 'pooga', value: 'second' }]
+ *                autocomplete.respond(data) 
+ *             }
+ *          }
+ *       }
+ *    ],
+ *    execute: (ctx, args) => {}
+ * })
+ * @end
+ */
+
+export const filterA = (pred: (value: string) => boolean) => {
+    return makePlugin(PluginType.Control, (a: AutocompleteInteraction) => {
+        if(pred(a.options.getFocused())) {
+            return controller.next();
+        }
+        return controller.stop();
+    }) as ControlPlugin;
+}

bot/src/plugins/fromCallback.ts

@@ -0,0 +1,36 @@
+//@ts-nocheck
+/**
+ * @plugin
+ * fromCallback turns a callback into a plugin result.
+ * if the callback returns truthy value, plugin continues.
+ * This control plugin works for every command type. The arguments of the callback
+ * mirror the execute method on the current module.
+ * @author @jacoobes [<@182326315813306368>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * const myServer = "941002690211766332";
+ * export default commandModule({
+ *     type: CommandType.Both,
+ *     plugins: [
+ *         fromCallback((ctx, args) => ctx.guildId == myServer)
+ *     ],
+ *     execute: ctx => {
+ *         ctx.reply("I only respond in myServer!");
+ *     }
+ * })
+ * ```
+ * @end
+ */
+
+
+import { PluginType, makePlugin, controller } from "@sern/handler";
+
+export const fromCallback = (cb: (...args: any[]) => boolean) => 
+    makePlugin(PluginType.Control, (...args) => {
+        console.log(args)
+        if(cb.apply(null, args)) {
+            return controller.next();
+        }
+        return controller.stop();
+    });

bot/src/plugins/json-params.ts

@@ -0,0 +1,5 @@
+import { CommandControlPlugin, CommandType, controller } from "@sern/handler";
+
+export const json = CommandControlPlugin<CommandType.Button>((ctx, args) => { 
+    return controller.next({ 'json/data': JSON.parse(args.params!) });
+})

bot/src/plugins/nsfwOnly.ts

@@ -0,0 +1,48 @@
+/**
+ * This plugin checks if the channel is nsfw and responds to user with a specified response if not nsfw
+ *
+ * @author @Benzo-Fury [<@762918086349029386>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { nsfwOnly } from "../plugins/nsfwOnly";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ nsfwOnly('response', true) ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+import {
+    ChannelType,
+    GuildTextBasedChannel,
+    TextBasedChannel,
+    TextChannel,
+} from "discord.js";
+import {CommandControlPlugin, CommandType, controller } from "@sern/handler";
+function isGuildText(channel: TextBasedChannel|null): channel is GuildTextBasedChannel {
+    return (channel?.type == ChannelType.GuildPublicThread ||
+            channel?.type == ChannelType.GuildPrivateThread);
+}
+export function nsfwOnly(onFail: string, ephemeral: boolean) {
+    return CommandControlPlugin<CommandType.Both>(async (ctx, _) => {
+        if (ctx.guild === null) {
+            await ctx.reply({ content: onFail, ephemeral });
+            return controller.stop();
+        }
+        //channel is thread (not supported by nsfw)
+        if (isGuildText(ctx.channel) == true) {
+            await ctx.reply({ content: onFail, ephemeral });
+            return controller.stop();
+        }
+        if (!(ctx.channel! as TextChannel).nsfw) {
+            //channel is not nsfw
+            await ctx.reply({ content: onFail, ephemeral });
+            return controller.stop();
+        }
+        //continues to command if nsfw
+        return controller.next();
+    });
+}

bot/src/plugins/ownerOnly.ts

@@ -0,0 +1,30 @@
+// @ts-nocheck
+/**
+ * This is OwnerOnly plugin, it allows only bot owners to run the command, like eval.
+ *
+ * @author @EvolutionX-10 [<@697795666373640213>]
+ * @version 1.2.0
+ * @example
+ * ```ts
+ * import { ownerOnly } from "../plugins/ownerOnly";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ ownerOnly() ], // can also pass array of IDs to override default owner IDs
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+
+import { CommandType, CommandControlPlugin, controller } from "@sern/handler";
+const ownerIDs = ["182326315813306368"]; //! Fill your ID
+export function ownerOnly(override?: string[]) {
+	return CommandControlPlugin<CommandType.Both>((ctx) => {
+		if ((override ?? ownerIDs).includes(ctx.user.id))
+			return controller.next();
+		//* If you want to reply when the command fails due to user not being owner, you can use following
+		// await ctx.reply("Only owner can run it!!!");
+		return controller.stop(); //! Important: It stops the execution of command!
+	});
+}

bot/src/plugins/permCheck.ts

@@ -0,0 +1,39 @@
+// @ts-nocheck
+/**
+ * @plugin
+ * This is perm check, it allows users to parse the permission you want and let the plugin do the rest. (check user for that perm).
+ *
+ * @author @Benzo-Fury [<@762918086349029386>]
+ * @version 1.0.1
+ * @example
+ * ```ts
+ * import { permCheck } from "../plugins/permCheck";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ permCheck('permission', 'No permission response') ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ * @end
+ */
+
+import type { GuildMember, PermissionResolvable } from "discord.js";
+import { CommandControlPlugin, CommandType, controller } from "@sern/handler";
+export function permCheck(perm: PermissionResolvable, response: string) {
+	return CommandControlPlugin<CommandType.Both>(async (ctx, args) => {
+		if (ctx.guild === null) {
+			await ctx.reply("This command cannot be used here");
+			console.warn(
+				"PermCheck > A command stopped because we couldn't check a users permissions (was used in dms)",
+			); //delete this line if you dont want to be notified when a command is used outside of a guild/server
+			return controller.stop();
+		}
+		if (!(ctx.member! as GuildMember).permissions.has(perm)) {
+			await ctx.reply(response);
+			return controller.stop();
+		}
+		return controller.next();
+	});
+}

bot/src/plugins/publish.ts

@@ -0,0 +1,215 @@
+// @ts-nocheck
+/**
+ * @plugin
+ * [DEPRECATED] It allows you to publish your application commands using the discord.js library with ease.
+ *
+ * @author @EvolutionX-10 [<@697795666373640213>]
+ * @version 2.0.0
+ * @example
+ * ```ts
+ * import { publish } from "../plugins/publish";
+ * import { commandModule } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ publish() ], // put an object containing permissions, ids for guild commands, boolean for dmPermission
+ *  // plugins: [ publish({ guildIds: ['guildId'], defaultMemberPermissions: 'Administrator'})]
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ * @end
+ */
+import {
+	CommandInitPlugin,
+	CommandType,
+	controller,
+	SernOptionsData,
+	SlashCommand,
+	Service,
+} from "@sern/handler";
+import {
+	ApplicationCommandData,
+	ApplicationCommandType,
+	ApplicationCommandOptionType,
+	PermissionResolvable,
+} from "discord.js";
+
+export const CommandTypeRaw = {
+	[CommandType.Both]: ApplicationCommandType.ChatInput,
+	[CommandType.CtxUser]: ApplicationCommandType.User,
+	[CommandType.CtxMsg]: ApplicationCommandType.Message,
+	[CommandType.Slash]: ApplicationCommandType.ChatInput,
+} as const;
+
+export function publish<
+	T extends
+		| CommandType.Both
+		| CommandType.Slash
+		| CommandType.CtxMsg
+		| CommandType.CtxUser,
+>(options?: PublishOptions) {
+	return CommandInitPlugin<T>(async ({ module }) => {
+		// Users need to provide their own useContainer function.
+		let client;
+		try {
+			client = (await import("@sern/handler")).Service("@sern/client");
+		} catch {
+			const { useContainer } = await import("../index.js");
+			client = useContainer("@sern/client")[0];
+		}
+		const defaultOptions = {
+			guildIds: [],
+			dmPermission: undefined,
+			defaultMemberPermissions: null,
+		};
+
+		options = { ...defaultOptions, ...options } as PublishOptions &
+			ValidPublishOptions;
+		let { defaultMemberPermissions, dmPermission, guildIds } =
+			options as unknown as ValidPublishOptions;
+
+		function c(e: unknown) {
+			console.error("publish command didnt work for", module.name);
+			console.error(e);
+		}
+
+		const log =
+			(...message: any[]) =>
+			() =>
+				console.log(...message);
+		const logged = (...message: any[]) => log(message);
+		/**
+		 * a local function that returns either one value or the other,
+		 * depending on {t}'s CommandType. If the commandtype of
+		 * this module is CommandType.Both or CommandType.Text or CommandType.Slash,
+		 * return 'is', else return 'els'
+		 * @param t
+		 * @returns S | T
+		 */
+		const appCmd = <V extends CommandType, S, T>(t: V) => {
+			return (is: S, els: T) => ((t & CommandType.Both) !== 0 ? is : els);
+		};
+		const curAppType = CommandTypeRaw[module.type];
+		const createCommandData = () => {
+			const cmd = appCmd(module.type);
+			return {
+				name: module.name,
+				type: curAppType,
+				description: cmd(module.description, ""),
+				options: cmd(
+					optionsTransformer((module as SlashCommand).options ?? []),
+					[],
+				),
+				defaultMemberPermissions,
+				dmPermission,
+			} as ApplicationCommandData;
+		};
+
+		try {
+			const commandData = createCommandData();
+
+			if (!guildIds.length) {
+				const cmd = (await client.application!.commands.fetch()).find(
+					(c) => c.name === module.name && c.type === curAppType,
+				);
+				if (cmd) {
+					if (!cmd.equals(commandData, true)) {
+						logged(
+							`Found differences in global command ${module.name}`,
+						);
+						cmd.edit(commandData).then(
+							log(
+								`${module.name} updated with new data successfully!`,
+							),
+						);
+					}
+					return controller.next();
+				}
+				client
+					.application!.commands.create(commandData)
+					.then(log("Command created", module.name))
+					.catch(c);
+				return controller.next();
+			}
+
+			for (const id of guildIds) {
+				const guild = await client.guilds.fetch(id).catch(c);
+				if (!guild) continue;
+				const guildCmd = (await guild.commands.fetch()).find(
+					(c) => c.name === module.name && c.type === curAppType,
+				);
+				if (guildCmd) {
+					if (!guildCmd.equals(commandData, true)) {
+						logged(`Found differences in command ${module.name}`);
+						guildCmd
+							.edit(commandData)
+							.then(
+								log(
+									`${module.name} updated with new data successfully!`,
+								),
+							)
+							.catch(c);
+						continue;
+					}
+					continue;
+				}
+				guild.commands
+					.create(commandData)
+					.then(log("Guild Command created", module.name, guild.name))
+					.catch(c);
+			}
+			return controller.next();
+		} catch (e) {
+			logged("Command did not register" + module.name);
+			logged(e);
+			return controller.stop();
+		}
+	});
+}
+
+export function optionsTransformer(ops: Array<SernOptionsData>) {
+	return ops.map((el) => {
+		switch (el.type) {
+			case ApplicationCommandOptionType.String:
+			case ApplicationCommandOptionType.Number:
+			case ApplicationCommandOptionType.Integer: {
+				return el.autocomplete && "command" in el
+					? (({ command, ...el }) => el)(el)
+					: el;
+			}
+			default:
+				return el;
+		}
+	});
+}
+
+export type NonEmptyArray<T extends `${number}` = `${number}`> = [T, ...T[]];
+
+export interface ValidPublishOptions {
+	guildIds: string[];
+	dmPermission: boolean;
+	defaultMemberPermissions: PermissionResolvable;
+}
+
+interface GuildPublishOptions {
+	guildIds?: NonEmptyArray;
+	defaultMemberPermissions?: PermissionResolvable;
+	dmPermission?: never;
+}
+
+interface GlobalPublishOptions {
+	defaultMemberPermissions?: PermissionResolvable;
+	dmPermission?: false;
+	guildIds?: never;
+}
+
+type BasePublishOptions = GuildPublishOptions | GlobalPublishOptions;
+
+export type PublishOptions = BasePublishOptions &
+	(
+		| Required<Pick<BasePublishOptions, "defaultMemberPermissions">>
+		| (
+				| Required<Pick<BasePublishOptions, "dmPermission">>
+				| Required<Pick<BasePublishOptions, "guildIds">>
+		  )
+	);

bot/src/plugins/requirePermission.ts

@@ -0,0 +1,95 @@
+/**
+ * This is perm check, it allows users to parse the permission you want and let the plugin do the rest. (check bot or user for that perm).
+ *
+ * @author @Benzo-Fury [<@762918086349029386>]
+ * @author @needhamgary [<@342314924804014081>]
+ * @version 1.2.0
+ * @example
+ * ```ts
+ * import { requirePermission } from "../plugins/myPermCheck";
+ * import { commandModule, CommandType } from "@sern/handler";
+ * export default commandModule({
+ *  plugins: [ requirePermission<CommandType>('target', 'permission', 'No response (optional)') ],
+ *  execute: (ctx) => {
+ * 		//your code here
+ *  }
+ * })
+ * ```
+ */
+
+import type { GuildMember, PermissionResolvable } from "discord.js";
+import {
+	CommandType, CommandControlPlugin, controller,
+} from "@sern/handler";
+
+function payload(resp?: string) {
+	return {
+		fetchReply: true,
+		content: resp,
+		allowedMentions: { repliedUser: false },
+	} as const;
+}
+
+export function requirePermission(
+	target: "user" | "bot" | "both",
+	perm: PermissionResolvable[],
+	response?: string
+) {
+	return CommandControlPlugin<CommandType.Both>(async (ctx, _) => {
+		if (ctx.guild === null) {
+			ctx.reply(payload("This command cannot be used here"));
+			console.warn(
+				"PermCheck > A command stopped because we couldn't check a users permissions (was used in dms)"
+			); //delete this line if you dont want to be notified when a command is used outside of a guild/server
+			return controller.stop();
+		}
+		const bot = (await ctx.guild.members.fetchMe({
+			cache: false,
+		})!) as GuildMember; const memm = ctx.member! as GuildMember;
+		switch (target) {
+			//*********************************************************************************************************************//
+			case "bot":
+				if (!bot.permissions.has(perm)) {
+					if (!response)
+						response = `I cannot use this command, please give me \`${perm.join(
+							", "
+						)}\` permission(s).`;
+					await ctx.reply(payload(response));
+					return controller.stop();
+				}
+				return controller.next();
+			//*********************************************************************************************************************//
+			case "user":
+				if (!memm.permissions.has(perm)) {
+					if (!response)
+						response = `You cannot use this command because you are missing \`${perm.join(
+							", "
+						)}\` permission(s).`;
+					await ctx.reply(payload(response));
+					return controller.stop();
+				}
+				return controller.next();
+			//*********************************************************************************************************************//
+			case "both":
+				if (
+					!bot.permissions.has(perm) ||
+					!memm.permissions.has(perm)
+				) {
+					if (!response)
+						response = `Please ensure <@${bot.user.id}> and <@${
+							memm.user.id
+						}> both have \`${perm.join(", ")}\` permission(s).`;
+					await ctx.reply(payload(response));
+					return controller.stop();
+				}
+				return controller.next();
+			//*********************************************************************************************************************//
+			default:
+				console.warn(
+					"Perm Check >>> You didn't specify user or bot."
+				);
+				ctx.reply(payload("User or Bot was not specified."));
+				return controller.stop();
+		}
+	});
+}

bot/src/plugins/serverOnly.ts

@@ -0,0 +1,38 @@
+/**
+ * Checks if a command is available in a specific server.
+ *
+ * @author @Peter-MJ-Parker [<@1017182455926624316>]
+ * @version 1.0.0
+ * @example
+ * ```ts
+ * import { commandModule, CommandType } from "@sern/handler";
+ * import { serverOnly } from "../plugins/serverOnly";
+ * export default commandModule({
+ *   type: CommandType.Both,
+ *   plugins: [serverOnly(["guildId"], failMessage)], // fail message is the message you will see when the command is ran in the wrong server.
+ *   description: "command description",
+ *   execute: async (ctx, args) => {
+ *     // your code here
+ *   },
+ * });
+ * ```
+ */
+
+import { CommandType, controller, CommandControlPlugin } from "@sern/handler";
+
+export function serverOnly(
+    guildId: string[],
+    failMessage = "This command is not available in this guild. \nFor permission to use in your server, please contact my developer."
+) {
+    return CommandControlPlugin<CommandType.Both>(async (ctx, _) => {
+        if (!guildId.includes(ctx.guildId!)) {
+            ctx.reply(failMessage).then(async (m) => {
+                setTimeout(async () => {
+                    await m.delete();
+                }, 3000);
+            });
+            return controller.stop();
+        }
+        return controller.next();
+    })
+}

bot/src/presence.ts

@@ -0,0 +1,34 @@
+import { Presence } from '@sern/handler'
+import { ActivityType, ClientPresenceStatus } from 'discord.js';
+
+function shuffleArray<T>(array: T[]) {
+    for (let i = array.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [array[i], array[j]] = [array[j], array[i]];
+    }
+    return [...array];
+}
+
+const statuses = [[ActivityType.Watching, "the sern community", "online"],
+                 [ActivityType.Listening, "Evo", "dnd"],
+                 [ActivityType.Playing, "with @sern/cli", "idle"],
+                 [ActivityType.Watching, "sern bots", "dnd"],
+                 [ActivityType.Watching, "github stars go brrr", "online"],
+                 [ActivityType.Listening, "Spotify", "dnd"],
+                 [ActivityType.Listening, "what's bofa", "idle"]] satisfies 
+                 [ActivityType, string, ClientPresenceStatus][];
+
+export default Presence.module({ 
+    execute: () => {
+        const [type, name, status] = statuses.at(0)!;
+        return Presence
+            .of({ activities: [ { type, name } ], status }) //start your presence with this.
+            .repeated(() => {
+                const [type, name, status] = [...shuffleArray(statuses)].shift()!;
+                return {
+                    status,
+                    activities: [{ type, name }]
+                };
+            }, 60_000); //repeat and setPresence with returned result every minute
+    }
+})

bot/src/tasks/dbbackup.ts

@@ -0,0 +1,9 @@
+import { scheduledTask } from "@sern/handler";
+
+
+export default scheduledTask({
+    trigger: "* * * * *",
+    execute: (args, { deps }) => {
+        console.log("hello")
+    }
+})

bot/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "./.sern/tsconfig.json"
+}

fortnite

@@ -0,0 +1 @@
+

package.json

@@ -1,25 +1,28 @@
 {
     "name": "@sern/handler",
-    "packageManager": "pnpm@7.27.0",
-    "version": "2.5.1",
-    "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.4",
+    "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",
-        "pretty": "prettier --write ."
+        "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",
@@ -33,23 +36,62 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
-        "iti": "^0.6.0",
-        "rxjs": "^7.5.6",
-        "ts-pattern": "^4.0.6",
-        "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.51.0",
-        "@typescript-eslint/parser": "5.48.0",
-        "discord.js": ">= ^14.7.x",
-        "eslint": "8.30.0",
-        "prettier": "2.8.4",
-        "tsup": "^6.1.3",
-        "typescript": "4.9.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.14.1",
+        "eslint": "8.39.0",
+        "typescript": "5.0.2",
+        "vitest": "^1.6.0"
+    },
+    "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.dev"
+    "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/cleanup.ts

@@ -0,0 +1,111 @@
+// It's this package but without default console log / error https://github.com/trevorr/async-cleanup
+
+/** A possibly asynchronous function invoked with the process is about to exit. */
+export type CleanupListener = () => void | Promise<void>;
+
+let cleanupListeners: Set<CleanupListener> | undefined;
+
+/** Registers a new cleanup listener. Adding the same listener more than once has no effect. */
+export function addCleanupListener(listener: CleanupListener): void {
+  // Install exit listeners on initial cleanup listener
+  if (!cleanupListeners) {
+    installExitListeners();
+    cleanupListeners = new Set();
+  }
+
+  cleanupListeners.add(listener);
+}
+
+/** Removes an existing cleanup listener, and returns whether the listener was registered. */
+export function removeCleanupListener(listener: CleanupListener): boolean {
+  return cleanupListeners != null && cleanupListeners.delete(listener);
+}
+
+/** Executes all cleanup listeners and then exits the process. Call this instead of `process.exit` to ensure all listeners are fully executed. */
+export async function exitAfterCleanup(code = 0): Promise<never> {
+  await executeCleanupListeners();
+  process.exit(code);
+}
+
+/** Executes all cleanup listeners and then kills the process with the given signal. */
+export async function killAfterCleanup(signal: ExitSignal): Promise<void> {
+  await executeCleanupListeners();
+  process.kill(process.pid, signal);
+}
+
+async function executeCleanupListeners(): Promise<void> {
+  if (cleanupListeners) {
+    // Remove exit listeners to restore normal event handling
+    uninstallExitListeners();
+
+    // Clear cleanup listeners to reset state for testing
+    const listeners = cleanupListeners;
+    cleanupListeners = undefined;
+
+    // Call listeners in order added with async listeners running concurrently
+    const promises: Promise<void>[] = [];
+    for (const listener of listeners) {
+      try {
+        const promise = listener();
+        if (promise) promises.push(promise);
+      } catch (err) {
+        // console.error("Uncaught exception during cleanup", err);
+      }
+    }
+
+    // Wait for all listeners to complete and log any rejections
+    const results = await Promise.allSettled(promises);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        console.error("Unhandled rejection during cleanup", result.reason);
+      }
+    }
+  }
+}
+
+function beforeExitListener(code: number): void {
+  // console.log(`Exiting with code ${code} due to empty event loop`);
+  void exitAfterCleanup(code);
+}
+
+function uncaughtExceptionListener(error: Error): void {
+  // console.error("Exiting with code 1 due to uncaught exception", error);
+  void exitAfterCleanup(1);
+}
+
+function signalListener(signal: ExitSignal): void {
+  // console.log(`Exiting due to signal ${signal}`);
+  void killAfterCleanup(signal);
+}
+
+// Listenable signals that terminate the process by default
+// (except SIGQUIT, which generates a core dump and should not trigger cleanup)
+// See https://nodejs.org/api/process.html#signal-events
+const listenedSignals = [
+  "SIGBREAK", // Ctrl-Break on Windows
+  "SIGHUP", // Parent terminal closed
+  "SIGINT", // Terminal interrupt, usually by Ctrl-C
+  "SIGTERM", // Graceful termination
+  "SIGUSR2", // Used by Nodemon
+] as const;
+
+/** Signals that can terminate the process. */
+export type ExitSignal =
+  | typeof listenedSignals[number]
+  | "SIGKILL"
+  | "SIGQUIT"
+  | "SIGSTOP";
+
+function installExitListeners(): void {
+  process.on("beforeExit", beforeExitListener);
+  process.on("uncaughtException", uncaughtExceptionListener);
+  listenedSignals.forEach((signal) => process.on(signal, signalListener));
+}
+
+function uninstallExitListeners(): void {
+  process.removeListener("beforeExit", beforeExitListener);
+  process.removeListener("uncaughtException", uncaughtExceptionListener);
+  listenedSignals.forEach((signal) =>
+    process.removeListener(signal, signalListener)
+  );
+}

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

@@ -1,4 +1,5 @@
 /**
+ * @since 1.0.0
  * A bitfield that discriminates command modules
  * @enum { number }
  * @example
@@ -14,45 +15,18 @@
  * ```
  */
 export enum CommandType {
-    /**
-     * The CommandType for text commands
-     */
-    Text = 1,
-    /**
-     * The CommandType for slash commands
-     */
-    Slash = 2,
-    /**
-     * The CommandType for hybrid commands, text and slash
-     */
+    Text = 1 << 0,
+    Slash = 1 << 1,
     Both = 3,
-    /**
-     * The CommandType for UserContextMenuInteraction commands
-     */
-    CtxUser = 4,
-    /**
-     * The CommandType for MessageContextMenuInteraction commands
-     */
-    CtxMsg = 8,
-    /**
-     * The CommandType for ButtonInteraction commands
-     */
-    Button = 16,
-    /**
-     * The CommandType for StringSelectMenuInteraction commands
-     */
-    StringSelect = 32,
-    /**
-     * The CommandType for ModalSubmitInteraction commands
-     */
-    Modal = 64,
-    /**
-     * The CommandType for the other SelectMenuInteractions
-     */
-    ChannelSelect = 256,
-    MentionableSelect = 512,
-    RoleSelect = 1024,
-    UserSelect = 2048,
+    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,
 }
 
 /**
@@ -74,16 +48,16 @@ export enum EventType {
     /**
      * The EventType for handling discord events
      */
-    Discord = 1,
+    Discord,
     /**
      * The EventType for handling sern events
      */
-    Sern = 2,
+    Sern,
     /**
      * The EventType for handling external events.
      * Could be for example, `process` events, database events
      */
-    External = 3,
+    External,
 }
 
 /**
@@ -105,35 +79,56 @@ export enum PluginType {
      * The PluginType for InitPlugins
      */
     Init = 1,
-    /**
-     * @deprecated
-     * Use PluginType.Init instead
-     */
-    Command = 1,
-    /**
-     * @deprecated
-     * Use PluginType.Control instead
-     */
-    Event = 2,
     /**
      * The PluginType for EventPlugins
      */
     Control = 2,
 }
 /**
+ * @deprecated - Use strings 'success' | 'failure' | 'warning'
  * @enum { string }
  */
 export enum PayloadType {
-    /**
-     * The PayloadType for a SernEmitter success event
-     */
     Success = 'success',
-    /**
-     * The PayloadType for a SernEmitter failure event
-     */
     Failure = 'failure',
-    /**
-     * The PayloadType for a SernEmitter warning event
-     */
     Warning = 'warning',
 }
+
+/**
+ * @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/contracts/errorHandling.ts

@@ -1,45 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { Logging } from './logging';
-import util from 'util';
-export interface ErrorHandling {
-    /**
-     * Number of times the process should throw an error until crashing and exiting
-     */
-    keepAlive: number;
-
-    /**
-     * Utility function to crash
-     * @param error
-     */
-    crash(error: Error): never;
-
-    /**
-     * A function that is called on every crash. Updates keepAlive
-     * @param error
-     */
-    updateAlive(error: Error): void;
-}
-
-export class DefaultErrorHandling implements ErrorHandling {
-    keepAlive = 5;
-    crash(error: Error): never {
-        throw error;
-    }
-    updateAlive(e: Error) {
-        this.keepAlive--;
-    }
-}
-
-export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
-    return (pload: unknown, caught: Observable<C>) => {
-        // This is done to fit the ErrorHandling contract
-        const err = pload instanceof Error ? pload : Error(util.format(pload));
-        if (crashHandler.keepAlive == 0) {
-            crashHandler.crash(err);
-        }
-        //formatted payload
-        logging?.error({ message: util.format(pload) });
-        crashHandler.updateAlive(err);
-        return caught;
-    };
-}

src/handler/contracts/index.ts

@@ -1,3 +0,0 @@
-export { ErrorHandling, DefaultErrorHandling } from './errorHandling';
-export { Logging, DefaultLogging } from './logging';
-export { ModuleManager, DefaultModuleManager } from './moduleManager';

src/handler/contracts/logging.ts

@@ -1,27 +0,0 @@
-import type { LogPayload } from '../../types/handler';
-
-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 class DefaultLogging implements Logging {
-    private date = () => new Date();
-    debug(payload: LogPayload): void {
-        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    error(payload: LogPayload): void {
-        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    info(payload: LogPayload): void {
-        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    warning(payload: LogPayload): void {
-        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-}

src/handler/contracts/moduleManager.ts

@@ -1,23 +0,0 @@
-import type { CommandModuleDefs } from '../../types/module';
-import type { CommandType, ModuleStore } from '../structures';
-import type { Processed } from '../../types/handler';
-
-export interface ModuleManager {
-    get<T extends CommandType>(
-        strat: (ms: ModuleStore) => Processed<CommandModuleDefs[T]> | undefined,
-    ): CommandModuleDefs[T] | undefined;
-    set(strat: (ms: ModuleStore) => void): void;
-}
-
-export class DefaultModuleManager implements ModuleManager {
-    constructor(private moduleStore: ModuleStore) {}
-    get<T extends CommandType>(
-        strat: (ms: ModuleStore) => Processed<CommandModuleDefs[T]> | undefined,
-    ) {
-        return strat(this.moduleStore);
-    }
-
-    set(strat: (ms: ModuleStore) => void): void {
-        strat(this.moduleStore);
-    }
-}

src/handler/dependencies/index.ts

@@ -1,2 +0,0 @@
-export { single, transient, many } from './lifetimeFunctions';
-export { useContainerRaw } from './provider';

src/handler/dependencies/lifetimeFunctions.ts

@@ -1,57 +0,0 @@
-import { _const } from '../utilities/functions';
-
-type NotFunction =
-    | string
-    | number
-    | boolean
-    | null
-    | undefined
-    | bigint
-    | readonly any[]
-    | { apply?: never; [k: string]: any }
-    | { call?: never; [k: string]: any };
-
-/**
- * @deprecated
- * @param cb
- */
-export function single<T extends NotFunction>(cb: T): () => T;
-/**
- * New signature
- * @param cb
- */
-export function single<T extends () => unknown>(cb: T): T;
-/**
- * Please note that on intellij, the deprecation is for all signatures, which is unintended behavior (and
- * very annoying).
- * For future versions, ensure that single is being passed as a **callback!!**
- * @param cb
- */
-export function single<T>(cb: T) {
-    if (typeof cb === 'function') return cb;
-    return () => cb;
-}
-/**
- * @deprecated
- * @param cb
- * Deprecated signature
- */
-export function transient<T extends NotFunction>(cb: T): () => () => T;
-export function transient<T extends () => () => unknown>(cb: T): T;
-/**
- * Following iti's singleton and transient implementation,
- * use transient if you want a new dependency every time your container getter is called
- * @param cb
- */
-export function transient<T>(cb: (() => () => T) | T) {
-    if (typeof cb !== 'function') return () => () => cb;
-    return cb;
-}
-
-/**
- * @deprecated
- * @param value
- * Please use the transient function instead
- */
-// prettier-ignore
-export const many = <T>(value: T) => () => _const(value);

src/handler/dependencies/provider.ts

@@ -1,73 +0,0 @@
-import type { Container } from 'iti';
-import { SernError } from '../structures/errors';
-import type { Dependencies, DependencyConfiguration, MapDeps } from '../../types/handler';
-import SernEmitter from '../sernEmitter';
-import { DefaultErrorHandling, DefaultLogging, DefaultModuleManager } from '../contracts';
-import { ModuleStore } from '../structures/moduleStore';
-import { Result } from 'ts-results-es';
-import { BehaviorSubject } from 'rxjs';
-import { createContainer } from 'iti';
-
-export const containerSubject = new BehaviorSubject(defaultContainer());
-
-/**
- * Given the user's conf, check for any excluded dependency keys.
- * Then, call conf.build to get the rest of the users' dependencies.
- * Finally, update the containerSubject with the new container state
- * @param conf
- */
-export function composeRoot<T extends Dependencies>(conf: DependencyConfiguration<T>) {
-    //Get the current container. This should have no client or possible logger yet.
-    const currentContainer = containerSubject.getValue();
-    const excludeLogger = conf.exclude?.has('@sern/logger');
-    if (!excludeLogger) {
-        currentContainer.add({
-            '@sern/logger': () => new DefaultLogging(),
-        });
-    }
-    //Build the container based on the callback provided by the user
-    const container = conf.build(currentContainer);
-    //Check if the built container contains @sern/client or throw
-    // a runtime exception
-    Result.wrap(() => container.get('@sern/client')).expect(SernError.MissingRequired);
-
-    if (!excludeLogger) {
-        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
-    }
-    //I'm sorry little one
-    containerSubject.next(container as any);
-}
-
-export function useContainer<T extends Dependencies>() {
-    const container = containerSubject.getValue() as Container<T, {}>;
-    return <V extends (keyof T)[]>(...keys: [...V]) =>
-        keys.map(key => Result.wrap(() => container.get(key)).unwrapOr(undefined)) as MapDeps<T, V>;
-}
-
-/**
- * Returns the underlying data structure holding all dependencies.
- * Please be careful as this only gets the client's current state.
- * Exposes some methods from iti
- */
-export function useContainerRaw<T extends Dependencies>() {
-    return containerSubject.getValue() as Container<T, {}>;
-}
-
-/**
- * Provides all the defaults for sern to function properly.
- * The only user provided dependency needs to be @sern/client
- */
-function defaultContainer() {
-    return createContainer()
-        .add({ '@sern/errors': () => new DefaultErrorHandling() })
-        .add({ '@sern/store': () => new ModuleStore() })
-        .add(ctx => {
-            return {
-                '@sern/modules': () => new DefaultModuleManager(ctx['@sern/store']),
-            };
-        })
-        .add({ '@sern/emitter': () => new SernEmitter() }) as Container<
-        Omit<Dependencies, '@sern/client' | '@sern/logger'>,
-        {}
-    >;
-}

src/handler/events/dispatchers/dispatchers.ts

@@ -1,64 +0,0 @@
-import type { Processed } from '../../../types/handler';
-import type { AutocompleteInteraction } from 'discord.js';
-import { SernError } from '../../structures';
-import treeSearch from '../../utilities/treeSearch';
-import type { BothCommand, CommandModule, Module, SlashCommand } from '../../../types/module';
-import { EventEmitter } from 'events';
-import * as assert from 'assert';
-import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
-import { callPlugin } from '../operators';
-import { createResultResolver } from '../observableHandling';
-
-export function dispatchCommand(module: Processed<CommandModule>, createArgs: () => unknown[]) {
-    const args = createArgs();
-    return {
-        module,
-        args,
-    };
-}
-
-/**
- * Creates an observable from { source }
- * @param module
- * @param source
- */
-export function eventDispatcher(module: Processed<Module>, source: unknown) {
-    assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
-    /**
-     * Sometimes fromEvent emits a single parameter, which is not an Array. This
-     * operator function flattens events into an array
-     * @param src
-     */
-    const arrayify = pipe(
-        map(event => (Array.isArray(event) ? (event as unknown[]) : [event])),
-        map(args => ({ module, args })),
-    );
-    const createResult = createResultResolver<
-        Processed<Module>,
-        { module: Processed<Module>; args: unknown[] },
-        unknown[]
-    >({
-        createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
-        onSuccess: ({ args }) => args,
-    });
-    const execute: OperatorFunction<unknown[], unknown> = pipe(
-        concatMap(async args => module.execute(...args)),
-    );
-    return fromEvent(source, module.name).pipe(arrayify, concatMap(createResult), execute);
-}
-
-export function dispatchAutocomplete(
-    module: Processed<BothCommand | SlashCommand>,
-    interaction: AutocompleteInteraction,
-) {
-    const option = treeSearch(interaction, module.options);
-    if (option !== undefined) {
-        return {
-            module: option.command as Processed<Module>, //autocomplete is not a true "module" warning cast!
-            args: [interaction],
-        };
-    }
-    throw Error(
-        SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
-    );
-}