change task signature

Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>

.npmignore

@@ -113,3 +113,4 @@ tsconfig-cjs.json
 tsconfig-esm.json
 
 renovate.json
+fortnite

package.json

@@ -1,25 +1,23 @@
 {
     "name": "@sern/handler",
     "packageManager": "yarn@3.5.0",
-    "version": "3.3.4",
+    "version": "4.0.0",
     "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
     "main": "./dist/index.js",
-    "module": "./dist/index.mjs",
+    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
     "exports": {
         ".": {
-            "import": "./dist/index.mjs",
+            "import": "./dist/index.js",
-            "require": "./dist/index.js",
+            "require": "./dist/index.js"
-            "types": "./dist/index.d.ts"
         }
     },
     "scripts": {
-        "watch": "tsup --watch",
+        "watch": "tsc --watch",
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
-        "build:dev": "tsup --metafile",
+        "build:dev": "tsc",
-        "build:prod": "tsup ",
+        "build:prod": "tsc",
-        "prepare": "npm run build:prod",
+        "prepare": "tsc",
         "pretty": "prettier --write .",
         "tdd": "vitest",
         "test": "vitest --run",
@@ -37,30 +35,23 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
+        "@sern/ioc": "^1.1.0",
         "callsites": "^3.1.0",
-        "iti": "^0.6.0",
+        "cron": "^3.1.7",
+        "deepmerge": "^4.3.1",
         "rxjs": "^7.8.0",
-        "ts-results-es": "^4.0.0"
+        "ts-results-es": "^4.1.0"
     },
     "devDependencies": {
         "@faker-js/faker": "^8.0.1",
-        "@types/node": "^18.15.11",
+        "@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.11.0",
+        "discord.js": "^14.15.3",
         "eslint": "8.39.0",
-        "prettier": "2.8.8",
-        "tsup": "^6.7.0",
         "typescript": "5.0.2",
-        "vitest": "latest"
+        "vitest": "^1.6.0"
-    },
-    "prettier": {
-        "semi": true,
-        "trailingComma": "all",
-        "singleQuote": true,
-        "printWidth": 100,
-        "tabWidth": 4,
-        "arrowParens": "avoid"
     },
     "eslintConfig": {
         "parser": "@typescript-eslint/parser",
@@ -95,7 +86,13 @@
         "url": "git+https://github.com/sern-handler/handler.git"
     },
     "engines": {
-        "node": ">= 18.16.x"
+        "node": ">= 20.0.x"
     },
-    "homepage": "https://sern.dev"
+    "homepage": "https://sern.dev",
+    "overrides": {
+        "ws": "8.17.1"
+    },
+    "resolutions": {
+        "ws": "8.17.1"
+    }
 }

src/core/_internal.ts

@@ -1,10 +0,0 @@
-export * as Id from './id';
-export * from './operators';
-export * as Files from './module-loading';
-export * from './functions';
-export type { VoidResult } from '../types/core-plugin';
-export { SernError } from './structures/enums';
-export { ModuleStore } from './structures/module-store';
-export * as __Services from './structures/services';
-export { useContainerRaw } from './ioc/base';
-

src/core/contracts/emitter.ts

@@ -1,9 +0,0 @@
-//i deleted it, hmm so how should we allow users to enable localization?
-// a
-import type { AnyFunction } from '../../types/utility';
-
-export interface Emitter {
-    addListener(eventName: string | symbol, listener: AnyFunction): this;
-    removeListener(eventName: string | symbol, listener: AnyFunction): this;
-    emit(eventName: string | symbol, ...payload: any[]): boolean;
-}

src/core/contracts/error-handling.ts

@@ -1,16 +0,0 @@
-/**
- * @since 2.0.0
- */
-export interface ErrorHandling {
-    /**
-     * @deprecated
-     * Version 4 will remove this method
-     */
-    crash(err: Error): never;
-    /**
-     * A function that is called on every throw.
-     * @param error
-     */
-    updateAlive(error: Error): void;
-
-}

src/core/contracts/hooks.ts

@@ -1,16 +0,0 @@
-
-/**
- * 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;
-}

src/core/contracts/index.ts

@@ -1,6 +0,0 @@
-export * from './error-handling';
-export * from './logging';
-export * from './module-manager';
-export * from './module-store';
-export * from './hooks';
-export * from './emitter';

src/core/contracts/logging.ts

@@ -1,11 +0,0 @@
-/**
- * @since 2.0.0
- */
-export interface Logging<T = unknown> {
-    error(payload: LogPayload<T>): void;
-    warning(payload: LogPayload<T>): void;
-    info(payload: LogPayload<T>): void;
-    debug(payload: LogPayload<T>): void;
-}
-
-export type LogPayload<T = unknown> = { message: T };

src/core/contracts/module-manager.ts

@@ -1,34 +0,0 @@
-import type {
-    CommandMeta,
-    CommandModule,
-    CommandModuleDefs,
-    Module,
-} from '../../types/core-modules';
-import { CommandType } from '../structures';
-
-interface MetadataAccess {
-    getMetadata(m: Module): CommandMeta | undefined;
-    setMetadata(m: Module, c: CommandMeta): void;
-}
-
-/**
- * @since 2.0.0
- * @internal - direct access to the module manager will be removed in version 4
- */
-export interface ModuleManager extends MetadataAccess {
-    get(id: string): Module | undefined;
-
-    set(id: string, path: Module): void;
-    /**
-     * @deprecated
-     */
-    getPublishableCommands(): CommandModule[];
-
-    /*
-     * @deprecated
-     */
-    getByNameCommandType<T extends CommandType>(
-        name: string,
-        commandType: T,
-    ): CommandModuleDefs[T] | undefined;
-}

src/core/contracts/module-store.ts

@@ -1,9 +0,0 @@
-import type { CommandMeta, Module } from '../../types/core-modules';
-
-/**
- * Represents a core module store that stores IDs mapped to file paths.
- */
-export interface CoreModuleStore {
-    commands: Map<string, Module>;
-    metadata: WeakMap<Module, CommandMeta>;
-}

src/core/create-plugins.ts

@@ -1,72 +0,0 @@
-import { CommandType, EventType, PluginType } from './structures';
-import type { Plugin, PluginResult, EventArgs, CommandArgs } from '../types/core-plugin';
-import type { ClientEvents } from 'discord.js';
-import { err, ok } from './functions';
-
-export function makePlugin<V extends unknown[]>(
-    type: PluginType,
-    execute: (...args: any[]) => any,
-): Plugin<V> {
-    return {
-        type,
-        execute,
-    } as Plugin<V>;
-}
-/**
- * @since 2.5.0
- * @__PURE__
- */
-export function EventInitPlugin<I extends EventType>(
-    execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
-) {
-    return makePlugin(PluginType.Init, execute);
-}
-/**
- * @since 2.5.0
- * @__PURE__
- */
-export function CommandInitPlugin<I extends CommandType>(
-    execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
-) {
-    return makePlugin(PluginType.Init, execute);
-}
-/**
- * @since 2.5.0
- * @__PURE__
- */
-export function CommandControlPlugin<I extends CommandType>(
-    execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
-) {
-    return makePlugin(PluginType.Control, execute);
-}
-/**
- * @since 2.5.0
- * @__PURE__
- */
-export function EventControlPlugin<I extends EventType>(
-    execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,
-) {
-    return makePlugin(PluginType.Control, execute);
-}
-
-/**
- * @since 2.5.0
- * @Experimental
- * A specialized function for creating control plugins with discord.js ClientEvents.
- * Will probably be moved one day!
- */
-export function DiscordEventControlPlugin<T extends keyof ClientEvents>(
-    name: T,
-    execute: (...args: ClientEvents[T]) => PluginResult,
-) {
-    return makePlugin(PluginType.Control, execute);
-}
-
-/**
- * @since 1.0.0
- * The object passed into every plugin to control a command's behavior
- */
-export const controller = {
-    next: ok,
-    stop: err,
-};

src/core/functions.ts

@@ -1,6 +1,4 @@
-import { Err, Ok } from 'ts-results-es';
 import type { Module, SernAutocompleteData, SernOptionsData } from '../types/core-modules';
-import type { AnyCommandPlugin, AnyEventPlugin, Plugin } from '../types/core-plugin';
 import type {
     AnySelectMenuInteraction,
     ButtonInteraction,
@@ -11,31 +9,37 @@ import type {
     AutocompleteInteraction
 } from 'discord.js';
 import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
-import { PayloadType, PluginType } from './structures';
+import { PluginType } from './structures/enums';
 import assert from 'assert';
 import type { Payload } from '../types/utility';
 
-//function wrappers for empty ok / err
+/**
-export const ok = /* @__PURE__*/ () => Ok.EMPTY;
+ * Removes the first character(s) _[depending on prefix length]_ of the message
-export const err = /* @__PURE__*/ () => Err.EMPTY;
+ * @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(
+
-    arr: (AnyEventPlugin | AnyCommandPlugin)[] = [],
+export function partitionPlugins<T,V>
-): [Plugin[], Plugin[]] {
+(arr: Array<{ type: PluginType }> = []): [T[], V[]] {
     const controlPlugins = [];
     const initPlugins = [];
-
     for (const el of arr) {
         switch (el.type) {
-            case PluginType.Control:
+            case PluginType.Control: controlPlugins.push(el); break;
-                controlPlugins.push(el);
+            case PluginType.Init: initPlugins.push(el); break;
-                break;
-            case PluginType.Init:
-                initPlugins.push(el);
-                break;
         }
     }
-    return [controlPlugins, initPlugins];
+    return [controlPlugins, initPlugins] as [T[], V[]];
 }
 
 /**
@@ -54,40 +58,31 @@ export function treeSearch(
     while (_options.length > 0) {
         const cur = _options.pop()!;
         switch (cur.type) {
-            case ApplicationCommandOptionType.Subcommand:
+            case ApplicationCommandOptionType.Subcommand: {
-                {
                     subcommands.add(cur.name);
                     for (const option of cur.options ?? []) _options.push(option);
-                }
+                } break;
-                break;
+            case ApplicationCommandOptionType.SubcommandGroup: {
-            case ApplicationCommandOptionType.SubcommandGroup:
-                {
                     for (const command of cur.options ?? []) _options.push(command);
-                }
+                } break;
-                break;
+            default: {
-            default:
+                if ('autocomplete' in cur && cur.autocomplete) {
-                {
+                    const choice = iAutocomplete.options.getFocused(true);
-                    if ('autocomplete' in cur && cur.autocomplete) {
+                    assert( 'command' in cur, 'No `command` property found for option ' + cur.name);
-                        const choice = iAutocomplete.options.getFocused(true);
+                    if (subcommands.size > 0) {
-                        assert(
+                        const parent = iAutocomplete.options.getSubcommand();
-                            'command' in cur,
+                        const parentAndOptionMatches =
-                            'No `command` property found for autocomplete option',
+                            subcommands.has(parent) && cur.name === choice.name;
-                        );
+                        if (parentAndOptionMatches) {
-                        if (subcommands.size > 0) {
+                            return { ...cur, parent };
-                            const parent = iAutocomplete.options.getSubcommand();
+                        }
-                            const parentAndOptionMatches =
+                    } else {
-                                subcommands.has(parent) && cur.name === choice.name;
+                        if (cur.name === choice.name) {
-                            if (parentAndOptionMatches) {
+                            return { ...cur, parent: undefined };
-                                return { ...cur, parent };
-                            }
-                        } else {
-                            if (cur.name === choice.name) {
-                                return { ...cur, parent: undefined };
-                            }
                         }
                     }
                 }
-                break;
+            } break;
         }
     }
 }
@@ -117,7 +112,15 @@ export function isModal(i: InteractionTypable): i is ModalSubmitInteraction {
     return i.type === InteractionType.ModalSubmit;
 }
 
-export function resultPayload<T extends PayloadType>
+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

@@ -1,6 +1,15 @@
-import { ApplicationCommandType, ComponentType, Interaction, InteractionType } from 'discord.js';
+import { ApplicationCommandType, ComponentType, type Interaction, InteractionType } from 'discord.js';
-import { CommandType, EventType } from './structures';
+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.
@@ -9,15 +18,16 @@ import { CommandType, EventType } from './structures';
 export function reconstruct<T extends Interaction>(event: T) {
     switch (event.type) {
         case InteractionType.MessageComponent: {
-            return [`${event.customId}_C${event.componentType}`];
+            const data = parseParams(event, `_C${event.componentType}`)
+            return [data];
         }
         case InteractionType.ApplicationCommand:
-        case InteractionType.ApplicationCommandAutocomplete: {
+        case InteractionType.ApplicationCommandAutocomplete: 
-            return [`${event.commandName}_A${event.commandType}`, `${event.commandName}_B`];
+            return [{ id: `${event.commandName}_A${event.commandType}` }, { id: `${event.commandName}_B` }];
-        }
         //Modal interactions are classified as components for sern
         case InteractionType.ModalSubmit: {
-            return [`${event.customId}_M`];
+            const data = parseParams(event, '_M');
+            return [data];
         }
     }
 }
@@ -25,22 +35,21 @@ export function reconstruct<T extends Interaction>(event: T) {
  *
  * A magic number to represent any commandtype that is an ApplicationCommand.
  */
-const appBitField = 0b000000001111;
+const PUBLISHABLE = 0b000000001111;
 
 
-const TypeMap = new Map<number, number>([
+const TypeMap = new Map<number, number>([[CommandType.Text, 0],
-    [CommandType.Text, 0],
+                                        [CommandType.Both, 0],
-    [CommandType.Both, 0],
+                                        [CommandType.Slash, ApplicationCommandType.ChatInput],
-    [CommandType.Slash, ApplicationCommandType.ChatInput],
+                                        [CommandType.CtxUser, ApplicationCommandType.User],
-    [CommandType.CtxUser, ApplicationCommandType.User],
+                                        [CommandType.CtxMsg, ApplicationCommandType.Message],
-    [CommandType.CtxMsg, ApplicationCommandType.Message],
+                                        [CommandType.Button, ComponentType.Button],
-    [CommandType.Button, ComponentType.Button],
+                                        [CommandType.StringSelect, ComponentType.StringSelect],
-    [CommandType.Modal, InteractionType.ModalSubmit],
+                                        [CommandType.Modal, InteractionType.ModalSubmit],
-    [CommandType.StringSelect, ComponentType.StringSelect],
+                                        [CommandType.UserSelect, ComponentType.UserSelect],
-    [CommandType.UserSelect, ComponentType.UserSelect],
+                                        [CommandType.MentionableSelect, ComponentType.MentionableSelect],
-    [CommandType.MentionableSelect, ComponentType.MentionableSelect],
+                                        [CommandType.RoleSelect, ComponentType.RoleSelect],
-    [CommandType.RoleSelect, ComponentType.RoleSelect],
+                                        [CommandType.ChannelSelect, ComponentType.ChannelSelect]]);
-    [CommandType.ChannelSelect, ComponentType.ChannelSelect]]);
 
 /*
  * Generates an id based on name and CommandType.
@@ -57,7 +66,7 @@ export function create(name: string, type: CommandType | EventType) {
     if(type == CommandType.Modal) {
         return `${name}_M`;
     }
-    const am = (appBitField & type) !== 0 ? 'A' : 'C';
+    const am = (PUBLISHABLE & type) !== 0 ? 'A' : 'C';
     return `${name}_${am}${TypeMap.get(type)!}`
 }
 

src/core/index.ts

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

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)
+    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/ioc/base.ts

@@ -1,166 +0,0 @@
-import * as assert from 'assert';
-import { useContainer } from './dependency-injection';
-import type { CoreDependencies, DependencyConfiguration } from '../../types/ioc';
-import { CoreContainer } from './container';
-import { Result } from 'ts-results-es';
-import { __Services } from '../_internal';
-import { AnyFunction } from '../../types/utility';
-import type { Logging } from '../contracts/logging';
-import type { UnpackFunction } from 'iti';
-//SIDE EFFECT: GLOBAL DI
-let containerSubject: CoreContainer<Partial<Dependencies>>;
-
-/**
-  * @internal
-  * Don't use this unless you know what you're doing. Destroys old containerSubject if it exists and disposes everything
-  * then it will swap
-  */
-export async function __swap_container(c: CoreContainer<Partial<Dependencies>>) {
-    if(containerSubject) {
-       await containerSubject.disposeAll() 
-    }
-    containerSubject = c;
-}
-
-/**
-  * @internal
-  * Don't use this unless you know what you're doing. Destroys old containerSubject if it exists and disposes everything
-  * then it will swap
-  */
-export function __add_container(key: string,v : Insertable) {
-    containerSubject.add({ [key]: v });
-}
-
-/**
- * Returns the underlying data structure holding all dependencies.
- * Exposes methods from iti
- * Use the Service API. The container should be readonly from the consumer side
- */
-export function useContainerRaw() {
-    assert.ok(
-        containerSubject && containerSubject.isReady(),
-        "Could not find container or container wasn't ready. Did you call makeDependencies?",
-    );
-    return containerSubject;
-}
-
-export function disposeAll(logger: Logging|undefined) {
-    containerSubject
-        ?.disposeAll()
-        .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
-}
-type UnpackedDependencies = {
-    [K in keyof Dependencies]: UnpackFunction<Dependencies[K]>
-}
-type Insertable = 
-        | ((container: UnpackedDependencies) => unknown)
-        | object
-const dependencyBuilder = (container: any, excluded: string[] ) => {
-    return {
-        /**
-          * Insert a dependency into your container.
-          * Supply the correct key and dependency
-          */
-        add(key: keyof Dependencies, v: Insertable) {
-            if(typeof v !== 'function') {
-                Result.wrap(() => container.add({ [key]: v}))
-                      .expect("Failed to add " + key);
-            } else {
-                Result.wrap(() => 
-                       container.add((cntr: UnpackedDependencies) => ({ [key]: v(cntr)} )))
-                      .expect("Failed to add " + key);
-            }
-        },
-        /**
-          * Exclude any dependencies from being added.
-          * Warning: this could lead to bad errors if not used correctly
-          */
-        exclude(...keys: (keyof Dependencies)[]) {
-            keys.forEach(key => excluded.push(key));
-        },
-        
-        /**
-          * @param key the key of the dependency
-          * @param v The dependency to swap out.
-          * Swap out a preexisting dependency.
-          */
-        swap(key: keyof Dependencies, v: Insertable) {
-            if(typeof v !== 'function') {
-                Result.wrap(() => container.upsert({ [key]: v}))
-                      .expect("Failed to update " + key);
-            } else {
-                Result.wrap(() => 
-                       container.upsert((cntr: UnpackedDependencies) => ({ [key]: v(cntr)})))
-                      .expect("Failed to update " + key);
-            }
-        },
-        /**
-          * @param key the key of the dependency
-          * @param cleanup Provide cleanup for the dependency at key. First parameter is the dependency itself 
-          * @example
-          * ```ts 
-          * addDisposer('dbConnection', (dbConnection) => dbConnection.end())
-          * ```
-          * Swap out a preexisting dependency.
-          */
-        addDisposer(key: keyof Dependencies, cleanup: AnyFunction) {
-            Result.wrap(() => container.addDisposer({ [key] : cleanup }))
-                  .expect("Failed to addDisposer for" + key);
-        }
-   };
-};
-
-
-type ValidDependencyConfig =
-    | ((c: ReturnType<typeof dependencyBuilder>) => any)
-    | DependencyConfiguration;
-    
-
-/**
- * Given the user's conf, check for any excluded/included 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
- */
-function composeRoot(
-    container: CoreContainer<Partial<Dependencies>>,
-    conf: DependencyConfiguration,
-) {
-    //container should have no client or logger yet.
-    const hasLogger = conf.exclude?.has('@sern/logger');
-    if (!hasLogger) {
-        __add_container('@sern/logger', new __Services.DefaultLogging);
-    }
-    //Build the container based on the callback provided by the user
-    conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
-    
-    if (!hasLogger) {
-        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
-    }
-
-    container.ready();
-}
-
-export async function makeDependencies<const T extends Dependencies>
-(conf: ValidDependencyConfig) {
-    containerSubject = new CoreContainer();
-    if(typeof conf === 'function') {
-        const excluded: string[] = [];
-        conf(dependencyBuilder(containerSubject, excluded));
-        //We only include logger if it does not exist 
-        const includeLogger = 
-            !excluded.includes('@sern/logger') 
-            && !containerSubject.hasKey('@sern/logger');
-
-        if(includeLogger) {
-            __add_container('@sern/logger', new __Services.DefaultLogging);
-        }
-
-        containerSubject.ready();
-    } else {
-        composeRoot(containerSubject, conf);
-    }
-
-    return useContainer<T>();
-}
-

src/core/ioc/container.ts

@@ -1,58 +0,0 @@
-import { Container } from 'iti';
-import { Disposable } from '../';
-import * as assert from 'node:assert';
-import { Subject } from 'rxjs';
-import { __Services, ModuleStore } from '../_internal';
-import * as Hooks from './hooks';
-import { EventEmitter } from 'node:events';
-
-
-/**
- * A semi-generic container that provides error handling, emitter, and module store. 
- * For the handler to operate correctly, The only user provided dependency needs to be @sern/client
- */
-export class CoreContainer<T extends Partial<Dependencies>> extends Container<T, {}> {
-    private ready$ = new Subject<void>();
-    constructor() {
-        super();
-        assert.ok(!this.isReady(), 'Listening for dispose & init should occur prior to sern being ready.');
-
-        const { unsubscribe } = Hooks.createInitListener(this);
-
-        this.ready$
-            .subscribe({ complete: unsubscribe });
-
-        (this as Container<{}, {}>)
-            .add({ '@sern/errors': () => new __Services.DefaultErrorHandling,
-                   '@sern/emitter': () => new EventEmitter({ captureRejections: true }),
-                   '@sern/store': () => new ModuleStore })
-            .add(ctx => {
-                return { '@sern/modules': new __Services.DefaultModuleManager(ctx['@sern/store'])};
-            });
-    }
-
-    isReady() {
-        return this.ready$.closed;
-    }
-    
-    hasKey(key: string): boolean {
-        return Boolean((this as Container<any,any>)._context[key]);
-    }
-
-    override async disposeAll() {
-        const otherDisposables = Object
-            .entries(this._context)
-            .flatMap(([key, value]) => 
-                'dispose' in value ? [key] : []);
-        otherDisposables.forEach(key => { 
-            //possible source of bug: dispose is a property.
-            this.addDisposer({ [key]: (dep: Disposable) => dep.dispose() } as never);
-        })
-        await super.disposeAll();
-    }
-    
-    ready() {
-        this.ready$.complete();
-        this.ready$.unsubscribe();
-    }
-}

src/core/ioc/dependency-injection.ts

@@ -1,57 +0,0 @@
-import assert from 'node:assert';
-import type { IntoDependencies } from '../../types/ioc';
-import { useContainerRaw } from './base';
-
-/**
- * @__PURE__
- * @since 2.0.0.
- * Creates a singleton object.
- * @param cb
- */
-export function single<T>(cb: () => T) {
-    return cb;
-}
-
-/**
- * @__PURE__
- * @since 2.0.0
- * Creates a transient object
- * @param cb
- */
-export function transient<T>(cb: () => () => T) {
-    return cb;
-}
-/**
- * The new Service api, a cleaner alternative to useContainer
- * To obtain intellisense, ensure a .d.ts file exists in the root of compilation.
- * Usually our scaffolding tool takes care of this.
- * 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.
- *
- */
-export function Service<const T extends keyof Dependencies>(key: T) {
-    const dep = useContainerRaw().get(key)!;
-    assert(dep, "Requested key " + key + " returned undefined");
-    return dep;
-}
-/**
- * @since 3.0.0
- * The plural version of {@link Service}
- * @returns array of dependencies, in the same order of keys provided
- */
-export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]) {
-    const container = useContainerRaw();
-    return keys.map(k => container.get(k)!) as IntoDependencies<T>;
-}
-
-
-export function useContainer<const T extends Dependencies>() {
-    return <V extends (keyof T)[]>(...keys: [...V]) =>
-        keys.map(key => useContainerRaw().get(key as keyof Dependencies)) as IntoDependencies<V>;
-}
-

src/core/ioc/hooks.ts

@@ -1,41 +0,0 @@
-import type { CoreContainer } from "./container"
-
-interface HookEvent { 
-    key : PropertyKey
-    newContainer: any
-}
-type HookName = 'init';
-
-export const createInitListener = (coreContainer : CoreContainer<any>) => {
-    const initCalled = new Set<PropertyKey>();
-    const hasCallableMethod = createPredicate(initCalled);
-    const unsubscribe = coreContainer.on('containerUpserted', async event => {
-       
-        if(isNotHookable(event)) {
-            return;
-        }
-
-        if(hasCallableMethod('init', event)) {
-            await event.newContainer?.init();
-            initCalled.add(event.key);
-        }
-
-    });
-
-    return { unsubscribe };
-}
-
-const isNotHookable = (hk: HookEvent) => {
-    return typeof hk.newContainer !== 'object' 
-        || Array.isArray(hk.newContainer) 
-        || hk.newContainer === null;
-}
-
-const createPredicate = <T extends HookEvent>(called: Set<PropertyKey>) => {
-    return (hookName: HookName, event: T) => {
-        const hasMethod = Reflect.has(event.newContainer!, hookName);
-        const beenCalledOnce = !called.has(event.key)
-
-        return hasMethod && beenCalledOnce
-    }
-}

src/core/ioc/index.ts

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

src/core/module-loading.ts

@@ -1,23 +1,26 @@
-import { type Observable, from, mergeMap, ObservableInput } from 'rxjs';
+import path from 'node:path';
-import { readdir, stat } from 'fs/promises';
+import { existsSync } from 'node:fs';
-import { basename, extname, join, resolve, parse, dirname } from 'path';
+import { readdir } from 'fs/promises';
-import assert from 'assert';
+import assert from 'node:assert';
-import { createRequire } from 'node:module';
+import * as Id from './id'
-import type { ImportPayload, Wrapper } from '../types/core';
+import { Module } from '../types/core-modules';
-import type { Module } from '../types/core-modules';
-import { existsSync } from 'fs';
-import type { Logging } from './contracts/logging';
 
-export const shouldHandle = (path: string, fpath: string) => {
+export const parseCallsite = (site: string) => {
-    const file_name = fpath+extname(path);
+    const pathobj = path.posix.parse(site.replace(/file:\\?/, "")
-    let newPath = join(dirname(path), file_name)
+                                   .split(path.sep)
-                    .replace(/file:\\?/, "");
+                                   .join(path.posix.sep))
-    return { exists: existsSync(newPath),
+    return { name: pathobj.name,
-             path: 'file:///'+newPath };
+             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 };
+}
 
-export type ModuleResult<T> = Promise<ImportPayload<T>>;
 
 /**
  * Import any module based on the absolute path.
@@ -25,7 +28,6 @@ export type ModuleResult<T> = Promise<ImportPayload<T>>;
  * commonjs, javascript :
  * ```js
  * exports = commandModule({ })
- *
  * //or
  * exports.default = commandModule({ })
  * ```
@@ -35,100 +37,34 @@ export type ModuleResult<T> = Promise<ImportPayload<T>>;
 export async function importModule<T>(absPath: string) {
     let fileModule = await import(absPath);
 
-    let commandModule = fileModule.default;
+    let commandModule: Module = fileModule.default;
 
-    assert(commandModule , `Found no export @ ${absPath}. Forgot to ignore with "!"? (!${basename(absPath)})?`);
+    assert(commandModule , `No default export @ ${absPath}`);
-    if ('default' in commandModule ) {
+    if ('default' in commandModule) {
-        commandModule = commandModule.default;
+        commandModule = commandModule.default as Module;
     }
-    return { module: commandModule } as T;
+    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 defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
-    let { module } = await importModule<{ module: T }>(absPath);
-    assert(module, `Found an undefined module: ${absPath}`);
-    return { module, absPath };
-}
 
-export const fmtFileName = (fileName: string) => parse(fileName).name;
+export async function* readRecursive(dir: string): AsyncGenerator<string> {
-
+    const files = await readdir(dir, { withFileTypes: true });
-/**
+    for (const file of files) {
- * a directory string is converted into a stream of modules.
+        const fullPath = path.posix.join(dir, file.name);
- * starts the stream of modules that sern needs to process on init
+        if (file.isDirectory()) {
- * @returns {Observable<{ mod: Module; absPath: string; }[]>} data from command files
+            if (!file.name.startsWith('!')) {
- * @param commandDir
+                yield* readRecursive(fullPath);
- */
-export function buildModuleStream<T extends Module>(
-    input: ObservableInput<string>,
-): Observable<ImportPayload<T>> {
-    return from(input)
-        .pipe(mergeMap(defaultModuleLoader<T>));
-}
-
-export const getFullPathTree = (dir: string) => readPaths(resolve(dir));
-
-export const filename = (path: string) => fmtFileName(basename(path));
-
-const isSkippable = (filename: string) => {
-    //empty string is for non extension files (directories)
-    const validExtensions = ['.js', '.cjs', '.mts', '.mjs', '.cts', '.ts', ''];
-    return filename[0] === '!' || !validExtensions.includes(extname(filename));
-};
-
-async function deriveFileInfo(dir: string, file: string) {
-    const fullPath = join(dir, file);
-    return { fullPath,
-             fileStats: await stat(fullPath),
-             base: basename(file) };
-}
-
-async function* readPaths(dir: string): AsyncGenerator<string> {
-    try {
-        const files = await readdir(dir);
-        for (const file of files) {
-            const { fullPath, fileStats, base } = await deriveFileInfo(dir, file);
-            if (fileStats.isDirectory()) {
-                //Todo: refactor so that i dont repeat myself for files (line 71)
-                if (!isSkippable(base)) {
-                    yield* readPaths(fullPath);
-                }
-            } else {
-                if (!isSkippable(base)) {
-                    yield 'file:///' + fullPath;
-                }
             }
+        } else if (!file.name.startsWith('!')) {
+            yield "file:///"+path.resolve(fullPath);
         }
-    } catch (err) {
-        throw err;
     }
 }
 
-const requir = createRequire(import.meta.url);
 
-export function loadConfig(wrapper: Wrapper | 'file', log: Logging | undefined): Wrapper {
-    if (wrapper !== 'file') {
-        return wrapper;
-    }
-    log?.info({ message: 'Experimental loading of sern.config.json'});
-    const config = requir(resolve('sern.config.json')); 
-
-    const makePath = (dir: PropertyKey) =>
-        config.language === 'typescript'
-            ? join('dist', config.paths[dir]!)
-            : join(config.paths[dir]!);
- 
-    log?.info({ message: 'Loading config: ' + JSON.stringify(config, null, 4) });
-    const commandsPath = makePath('commands');
- 
-    log?.info({ message: `Commands path is set to ${commandsPath}` });
-    let eventsPath: string | undefined;
-    if (config.paths.events) {
-        eventsPath = makePath('events');
-        log?.info({ message: `Events path is set to ${eventsPath} `});
-    }
-
-    return { defaultPrefix: config.defaultPrefix,
-             commands: commandsPath,
-             events: eventsPath };
-    
-}

src/core/modules.ts

@@ -1,57 +1,51 @@
-import { ClientEvents } from 'discord.js';
+import type { ClientEvents } from 'discord.js';
-import { EventType } from '../core/structures';
+import { EventType } from '../core/structures/enums';
 import type {
-    AnyEventPlugin,
-} from '../types/core-plugin';
-import type {
-    CommandModule,
-    EventModule,
     InputCommand,
     InputEvent,
+    Module,
+    ScheduledTask,
 } from '../types/core-modules';
-import { partitionPlugins } from './_internal';
+import { partitionPlugins } from './functions'
 import type { Awaitable } from '../types/utility';
 
 /**
  * @since 1.0.0 The wrapper function to define command modules for sern
  * @param mod
  */
-export function commandModule(mod: InputCommand): CommandModule {
+export function commandModule(mod: InputCommand): Module {
     const [onEvent, plugins] = partitionPlugins(mod.plugins);
-    return {
+    return { ...mod,
-        ...mod,
+             onEvent,
-        onEvent,
+             plugins,
-        plugins,
+             locals: {} } as Module;
-    } as CommandModule;
 }
+
 /**
  * @since 1.0.0
  * The wrapper function to define event modules for sern
  * @param mod
  */
-export function eventModule(mod: InputEvent): EventModule {
+export function eventModule(mod: InputEvent): Module {
     const [onEvent, plugins] = partitionPlugins(mod.plugins);
-    return {
+    if(onEvent.length !== 0) throw Error("Event modules cannot have ControlPlugins");
-        ...mod,
+    return { ...mod,
-        plugins,
+             plugins,
-        onEvent,
+             locals: {} } as Module;
-    } as EventModule;
 }
 
 /** Create event modules from discord.js client events,
  * This is an {@link eventModule} for discord events,
  * where typings can be very bad.
- * @Experimental
  * @param mod
  */
 export function discordEvent<T extends keyof ClientEvents>(mod: {
     name: T;
-    plugins?: AnyEventPlugin[];
+    once?: boolean;
     execute: (...args: ClientEvents[T]) => Awaitable<unknown>;
 }) {
-    return eventModule({
+    return eventModule({ type: EventType.Discord, ...mod, });
-        type: EventType.Discord,
-        ...mod,
-    });
 }
 
+export function scheduledTask(ism: ScheduledTask) { return ism }
+

src/core/operators.ts

@@ -1,83 +0,0 @@
-/**
- * This file holds sern's rxjs operators used for processing data.
- * Each function should be modular and testable, not bound to discord / sern
- * and independent of each other.
- */
-import {
-    concatMap,
-    defaultIfEmpty,
-    EMPTY,
-    every,
-    fromEvent,
-    map,
-    Observable,
-    of,
-    OperatorFunction,
-    pipe,
-    share,
-} from 'rxjs';
-import { Emitter, ErrorHandling, Logging } from './contracts';
-import util from 'node:util';
-import type { PluginResult, VoidResult } from '../types/core-plugin';
-import type { Result } from 'ts-results-es'
-/**
- * if {src} is true, mapTo V, else ignore
- * @param item
- */
-export function filterMapTo<V>(item: () => V): OperatorFunction<boolean, V> {
-    return concatMap(shouldKeep => (shouldKeep ? of(item()) : EMPTY));
-}
-
-interface PluginExecutable {
-    execute: (...args: unknown[]) => PluginResult;
-};
-/**
- * Calls any plugin with {args}.
- * @param args if an array, its spread and plugin called.
- */
-export function callPlugin(args: unknown): OperatorFunction<PluginExecutable, VoidResult> 
-{
-    return concatMap(async plugin => {
-        if (Array.isArray(args)) {
-            return plugin.execute(...args);
-        }
-        return plugin.execute(args);
-    });
-}
-
-export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]) : [src]));
-
-/**
- * Checks if the stream of results is all ok.
- */
-export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
-    every(result => result.isOk()),
-    defaultIfEmpty(true),
-);
-
-export const sharedEventStream = <T>(e: Emitter, eventName: string) => {
-    return (fromEvent(e, eventName) as Observable<T>).pipe(share());
-};
-
-export function handleError<C>(crashHandler: ErrorHandling, emitter: Emitter, logging?: Logging) {
-    return (pload: unknown, caught: Observable<C>) => {
-        // This is done to fit the ErrorHandling contract
-        if(!emitter.emit('error', pload)) {
-            const err = pload instanceof Error ? pload : Error(util.inspect(pload, { colors: true }));
-            logging?.error({ message: util.inspect(pload) });
-            crashHandler.updateAlive(err);
-        }
-        return caught;
-    };
-}
-// Temporary until i get rxjs operators working on ts-results-es
-export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
-    pipe(concatMap(result => {
-            if(result.isOk()) {
-                return of(result.value)
-            }
-            onErr(result.error);
-            return EMPTY
-        }))
-
-

src/core/plugin.ts

@@ -0,0 +1,45 @@
+import { CommandType, PluginType } from './structures/enums';
+import type { Plugin, PluginResult, CommandArgs, InitArgs } from '../types/core-plugin';
+import { Err, Ok } from 'ts-results-es';
+
+export function makePlugin<V extends unknown[]>(
+    type: PluginType,
+    execute: (...args: any[]) => any,
+): Plugin<V> {
+    return { type, execute } as Plugin<V>;
+}
+/**
+ * @since 2.5.0
+ */
+export function EventInitPlugin(execute: (args: InitArgs) => PluginResult) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ */
+export function CommandInitPlugin<I extends CommandType>(
+    execute: (args: InitArgs) => PluginResult
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ */
+export function CommandControlPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+
+
+/**
+ * @since 1.0.0
+ * The object passed into every plugin to control a command's behavior
+ */
+export const controller = {
+    next: (val?: Record<string,unknown>) => Ok(val),
+    stop: (val?: string) => Err(val),
+};
+
+
+export type Controller = typeof controller;

src/core/presences.ts

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

src/core/structures/context.ts

@@ -11,7 +11,9 @@ import type {
 import { CoreContext } from '../structures/core-context';
 import { Result, Ok, Err } from 'ts-results-es';
 import * as assert from 'assert';
-import { ReplyOptions } from '../../types/utility';
+import type { ReplyOptions } from '../../types/utility';
+import { fmt } from '../functions'
+import { SernError } from './enums';
 
 
 /**
@@ -20,16 +22,24 @@ import { ReplyOptions } from '../../types/utility';
  * Message and ChatInputCommandInteraction
  */
 export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
-    /*
+    
-     * @Experimental
-     */
     get options() {
-        return this.interaction.options;
+        if(this.isMessage()) {
+            const [, ...rest] = fmt(this.message.content, this.prefix);
+            return rest;
+        } else {
+            return this.interaction.options;
+        }
     }
-    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
+    
+
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>,
+                          private __prefix?: string) {
         super(ctx);
     }
-
+    public get prefix() {
+        return this.__prefix;
+    }
     public get id(): Snowflake {
         return safeUnwrap(this.ctx
                             .map(m => m.id)
@@ -37,9 +47,7 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
     }
 
     public get channel() {
-        return safeUnwrap(this.ctx
+        return safeUnwrap(this.ctx.map(m => m.channel).mapErr(i => i.channel));
-                            .map(m => m.channel)
-                            .mapErr(i => i.channel));
     }
 
     public get channelId(): Snowflake {
@@ -88,6 +96,15 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
                             .mapErr(i => i.member));
     }
 
+    get message(): Message {
+        return this.ctx.expect(SernError.MismatchEvent);
+    }
+
+    get interaction(): ChatInputCommandInteraction {
+        return this.ctx.expectErr(SernError.MismatchEvent);
+    }
+
+
     public get client(): Client {
         return safeUnwrap(this.ctx
                             .map(m => m.client)
@@ -105,17 +122,16 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
             this.ctx
                 .map(m => m.reply(content as MessageReplyOptions))
                 .mapErr(i =>
-                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply()),
+                    i.reply(content as InteractionReplyOptions).then(() => i.fetchReply())),
-                ),
         );
     }
 
-    static override wrap(wrappable: BaseInteraction | Message): Context {
+    static wrap(wrappable: BaseInteraction | Message, prefix?: string): Context {
         if ('interaction' in wrappable) {
-            return new Context(Ok(wrappable));
+            return new Context(Ok(wrappable), prefix);
         }
         assert.ok(wrappable.isChatInputCommand(), "Context created with bad interaction.");
-        return new Context(Err(wrappable));
+        return new Context(Err(wrappable), prefix);
     }
 }
 

src/core/structures/core-context.ts

@@ -1,5 +1,4 @@
 import { Result as Either } from 'ts-results-es';
-import { SernError } from '../_internal';
 import * as assert from 'node:assert';
 
 /**
@@ -9,13 +8,6 @@ export abstract class CoreContext<M, I> {
     protected constructor(protected ctx: Either<M, I>) {
         assert.ok(typeof ctx === 'object' && ctx != null, "Context was nonobject or null");
     }
-    get message(): M {
-        return this.ctx.expect(SernError.MismatchEvent);
-    }
-    get interaction(): I {
-        return this.ctx.expectErr(SernError.MismatchEvent);
-    }
-
     public isMessage(): this is CoreContext<M, never> {
         return this.ctx.isOk();
     }
@@ -23,10 +15,4 @@ export abstract class CoreContext<M, I> {
     public isSlash(): this is CoreContext<never, I> {
         return !this.isMessage();
     }
-    //todo: add agnostic options resolver for Context
-    abstract get options(): unknown;
-
-    static wrap(_: unknown): unknown {
-        throw Error('You need to override this method; cannot wrap an abstract class');
-    }
 }

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

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

src/core/structures/index.ts

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

src/core/structures/module-store.ts

@@ -1,11 +0,0 @@
-import { CommandMeta, Module } from '../../types/core-modules';
-
-/*
- * @deprecated
- * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
- * For interacting with modules, use the ModuleManager instead.
- */
-export class ModuleStore {
-    metadata = new WeakMap<Module, CommandMeta>();
-    commands = new Map<string, Module>();
-}

src/core/structures/services/error-handling.ts

@@ -1,21 +0,0 @@
-import { ErrorHandling } from '../../contracts';
-
-/**
- * @internal
- * @since 2.0.0
- * Version 4.0.0 will internalize this api. Please refrain from using the defaults!
- */
-export class DefaultErrorHandling implements ErrorHandling {
-    crash(err: Error): never {
-        throw err;
-    }
-
-    #keepAlive = 1;
-
-    updateAlive(err: Error) {
-        this.#keepAlive--;
-        if (this.#keepAlive === 0) {
-            throw err;
-        }
-    }
-}

src/core/structures/services/index.ts

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

src/core/structures/services/logger.ts

@@ -1,25 +0,0 @@
-import { LogPayload, Logging } from '../../contracts';
-
-/**
- * @internal
- * @since 2.0.0
- * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
- */
-export class DefaultLogging implements Logging {
-    private date = () => new Date();
-    debug(payload: LogPayload): void {
-        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    error(payload: LogPayload): void {
-        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    info(payload: LogPayload): void {
-        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-
-    warning(payload: LogPayload): void {
-        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
-    }
-}

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

@@ -1,51 +0,0 @@
-import * as Id from '../../../core/id';
-import { CoreModuleStore, ModuleManager } from '../../contracts';
-import { CommandMeta, CommandModule, CommandModuleDefs, Module } from '../../../types/core-modules';
-import { CommandType } from '../enums';
-/**
- * @internal
- * @since 2.0.0
- * Version 4.0.0 will internalize this api. Please refrain from using DefaultModuleManager!
- */
-export class DefaultModuleManager implements ModuleManager {
-    constructor(private moduleStore: CoreModuleStore) {}
-
-
-    getByNameCommandType<T extends CommandType>(name: string, commandType: T) {
-        const module = this.get(Id.create(name, commandType));
-        if (!module) {
-            return undefined;
-        }
-        return module as CommandModuleDefs[T];
-    }
-
-    setMetadata(m: Module, c: CommandMeta): void {
-        this.moduleStore.metadata.set(m, c);
-    }
-
-    getMetadata(m: Module): CommandMeta {
-        const maybeModule = this.moduleStore.metadata.get(m);
-        if (!maybeModule) {
-            throw Error('Could not find metadata in store for ' + m);
-        }
-        return maybeModule;
-    }
-
-    get(id: string) {
-        return this.moduleStore.commands.get(id);
-    }
-    set(id: string, path: CommandModule): void {
-        this.moduleStore.commands.set(id, path);
-    }
-    //not tested
-    getPublishableCommands(): CommandModule[] {
-        const entries = this.moduleStore.commands.entries();
-        const publishable = 0b000000110;
-        return Array.from(entries)
-                .filter(([id]) => {
-                    const last_entry = id.at(-1);
-                    return last_entry == 'B' ||  !(publishable & Number.parseInt(last_entry!));
-                })
-                .map(([, path]) => path as CommandModule);
-    }
-}

src/handlers/_internal.ts

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

src/handlers/dispatchers.ts

@@ -1,89 +0,0 @@
-import { EventEmitter } from 'node:events';
-import * as assert from 'node:assert';
-import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
-import {
-    arrayifySource,
-    callPlugin,
-    isAutocomplete,
-    treeSearch,
-    SernError,
-} from '../core/_internal';
-import { createResultResolver } from './event-utils';
-import { BaseInteraction, Message } from 'discord.js';
-import { CommandType, Context } from '../core';
-import type { Args } from '../types/utility';
-import { inspect } from 'node:util'
-import type { CommandModule, Module, Processed } from '../types/core-modules';
-
-//TODO: refactor dispatchers so that it implements a strategy for each different type of payload?
-export function dispatchMessage(module: Processed<CommandModule>, args: [Context, Args]) {
-    return { module, args };
-}
-
-export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?: string[]) {
-    const ctx = Context.wrap(wrappable);
-    const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.options];
-    return [ctx, args] as [Context, Args];
-}
-
-
-function intoPayload(module: Processed<Module>, ) {
-    return pipe(
-        arrayifySource,
-        map(args => ({ module, args, })),
-    );
-}
-
-const createResult = createResultResolver<
-    Processed<Module>,
-    { module: Processed<Module>; args: unknown[]  },
-    unknown[]
->({
-    createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
-    onNext: ({ args }) => args,
-});
-/**
- * Creates an observable from { source }
- * @param module
- * @param source
- */
-export function eventDispatcher(module: Processed<Module>,  source: unknown) {
-    assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
-
-    const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
-        module.execute(...args),
-    );
-    return fromEvent(source, module.name).pipe(
-        intoPayload(module),
-        concatMap(createResult),
-        execute,
-    );
-}
-
-export function createDispatcher(payload: {
-    module: Processed<CommandModule>;
-    event: BaseInteraction;
-}) {
-    assert.ok(
-        CommandType.Text !== payload.module.type,
-        SernError.MismatchEvent + 'Found text command in interaction stream',
-    );
-    switch (payload.module.type) {
-        case CommandType.Slash:
-        case CommandType.Both: {
-            if (isAutocomplete(payload.event)) {
-                const option = treeSearch(payload.event, payload.module.options);
-                assert.ok(option, SernError.NotSupportedInteraction + ` There is no autocomplete tag for ` + inspect(payload.module));
-                const { command } = option;
-            
-             	return {
-                    ...payload,
-             	    module: command as Processed<Module>, //autocomplete is not a true "module" warning cast!
-             	    args: [payload.event],
-             	};
-            }
-            return { module: payload.module, args: contextArgs(payload.event) };
-        }
-        default: return { module: payload.module, args: [payload.event] };
-    }
-}

src/handlers/event-utils.ts

@@ -1,60 +1,125 @@
-import { Interaction, Message } from 'discord.js';
+import type { Interaction, Message, BaseInteraction } from 'discord.js';
+import util from 'node:util';
 import {
-    EMPTY,
+    EMPTY, type Observable, concatMap, filter,
-    Observable,
+    throwError, fromEvent, map, type OperatorFunction,
-    concatMap,
+    catchError, finalize, pipe, from, take, share, of,
-    filter,
-    from,
-    of,
-    throwError,
-    tap,
-    catchError,
-    finalize,
-    map,
 } from 'rxjs';
-import {
+import * as Id from '../core/id'
-    Files,
+import type { Emitter, ErrorHandling, Logging } from '../core/interfaces';
-    Id,
+import { SernError } from '../core/structures/enums'
-    callPlugin,
-    everyPluginOk,
-    filterMapTo,
-    handleError,
-    SernError,
-    VoidResult,
-    resultPayload,
-} from '../core/_internal';
-import { Emitter, ErrorHandling, Logging, ModuleManager, PayloadType } from '../core';
-import { contextArgs, createDispatcher } from './dispatchers';
-import { ObservableInput, pipe } from 'rxjs';
 import { Err, Ok, Result } from 'ts-results-es';
-import type { Awaitable } from '../types/utility';
+import type { UnpackedDependencies } from '../types/utility';
-import type { ControlPlugin } from '../types/core-plugin';
+import type { CommandModule, Module, Processed } from '../types/core-modules';
-import type { AnyModule, CommandMeta, CommandModule, Module, Processed } from '../types/core-modules';
+import * as assert from 'node:assert';
-import { disposeAll } from '../core/ioc/base';
+import { Context } from '../core/structures/context';
+import { CommandType } from '../core/structures/enums'
+import { inspect } from 'node:util'
+import { disposeAll } from '../core/ioc';
+import { resultPayload, isAutocomplete, treeSearch, fmt } from '../core/functions'
+import merge from 'deepmerge'
 
+function handleError<C>(crashHandler: ErrorHandling, emitter: Emitter, logging?: Logging) {
+    return (pload: unknown, caught: Observable<C>) => {
+        // This is done to fit the ErrorHandling contract
+        if(!emitter.emit('error', pload)) {
+            const err = pload instanceof Error ? pload : Error(util.inspect(pload, { colors: true }));
+            logging?.error({ message: util.inspect(pload) });
+            crashHandler.updateAlive(err);
+        }
+        return caught;
+    };
+}
+const arrayify= <T>(src: T) => 
+    Array.isArray(src) ? src : [src];
+
+interface ExecutePayload {
+    module: Module;
+    args: unknown[];
+    deps: Dependencies;
+    params?: string;
+    [key: string]: unknown
+}
+
+export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
+    concatMap(result => {
+        if(result.isOk()) {
+            return of(result.value)
+        }
+        onErr(result.error);
+        return EMPTY;
+    })
+
+export const sharedEventStream = <T>(e: Emitter, eventName: string) => 
+    (fromEvent(e, eventName) as Observable<T>).pipe(share());
+
+function intoPayload(module: Module, deps: Dependencies) {
+    return pipe(map(arrayify),
+                map(args => ({ module, args, deps })),
+                map(p => p.args));
+}
+/**
+ * Creates an observable from { source }
+ * @param module
+ * @param source
+ */
+export function eventDispatcher(deps: Dependencies, module: Module, source: unknown) {
+    assert.ok(source && typeof source === 'object',
+              `${source} cannot be constructed into an event listener`);
+    const execute: OperatorFunction<unknown[]|undefined, unknown> =
+        concatMap(async args => {
+            if(args) return Reflect.apply(module.execute, null, args);
+        });
+
+    //@ts-ignore
+    let ev = fromEvent(source ,module.name!);
+    //@ts-ignore
+    if(module['once']) {
+        ev = ev.pipe(take(1))
+    }
+    return ev.pipe(intoPayload(module, deps),
+                   execute);
+}
+
+interface DispatchPayload { 
+    module: Processed<CommandModule>;
+    event: BaseInteraction; 
+    defaultPrefix?: string;
+    deps: Dependencies;
+    params?: string
+};
+export function createDispatcher({ module, event, defaultPrefix, deps, params }: DispatchPayload): ExecutePayload {
+    assert.ok(CommandType.Text !== module.type,
+        SernError.MismatchEvent + 'Found text command in interaction stream');
+
+    if(isAutocomplete(event)) {
+        assert.ok(module.type === CommandType.Slash 
+               || module.type === CommandType.Both, "Autocomplete option on non command interaction");
+        const option = treeSearch(event, module.options);
+        assert.ok(option, SernError.NotSupportedInteraction + ` There is no autocomplete tag for ` + inspect(module));
+        const { command } = option;
+        return { module: command as Processed<Module>, //autocomplete is not a true "module" warning cast!
+                 args: [event],
+                 deps };
+    }
+    switch (module.type) {
+        case CommandType.Slash:
+        case CommandType.Both: {
+            return { module, args: [Context.wrap(event, defaultPrefix)], deps };
+        }
+        default: return { module, args: [event], deps, params };
+    }
+}
 function createGenericHandler<Source, Narrowed extends Source, Output>(
     source: Observable<Source>,
     makeModule: (event: Narrowed) => Promise<Output>,
 ) {
     return (pred: (i: Source) => i is Narrowed) => 
         source.pipe(
-            filter(pred),
+            filter(pred), // only handle this stream if it passes pred
-            concatMap(makeModule));
+            concatMap(makeModule)); // create a payload, preparing to execute
 }
 
-/**
- * Removes the first character(s) _[depending on prefix length]_ of the message
- * @param msg
- * @param prefix The prefix to remove
- * @returns The message without the prefix
- * @example
- * message.content = '!ping';
- * console.log(fmt(message, '!'));
- * // [ 'ping' ]
- */
-export function fmt(msg: string, prefix: string): string[] {
-    return msg.slice(prefix.length).trim().split(/\s+/g);
-}
 
 /**
  *
@@ -65,193 +130,141 @@ export function fmt(msg: string, prefix: string): string[] {
  */
 export function createInteractionHandler<T extends Interaction>(
     source: Observable<Interaction>,
-    mg: ModuleManager,
+    deps: Dependencies,
+    defaultPrefix?: string
 ) {
+    const mg = deps['@sern/modules'];
     return createGenericHandler<Interaction, T, Result<ReturnType<typeof createDispatcher>, void>>(
         source,
         async event => {
             const possibleIds = Id.reconstruct(event);
-            let fullPaths= possibleIds
+            let modules = possibleIds
-                .map(id => mg.get(id))
+                .map(({ id, params }) => ({ module: mg.get(id), params }))
-                .filter((id): id is Module => id !== undefined);
+                .filter(({ module }) => module !== undefined);
-
+            if(modules.length == 0) {
-            if(fullPaths.length == 0) {
                 return Err.EMPTY;
             }
-            const [ path ] = fullPaths;
+            const [{module, params}] = modules;
-            return Ok(createDispatcher({ module: path as Processed<CommandModule>, event }));
+            return Ok(createDispatcher({ 
+                module: module as Processed<CommandModule>, 
+                event, defaultPrefix, deps, params 
+            }));
     });
 }
 
 export function createMessageHandler(
     source: Observable<Message>,
     defaultPrefix: string,
-    mg: ModuleManager,
+    deps: Dependencies,
 ) {
+    const mg = deps['@sern/modules'];
     return createGenericHandler(source, async event => {
-        const [prefix, ...rest] = fmt(event.content, defaultPrefix);
+        const [prefix] = fmt(event.content, defaultPrefix);
-        let fullPath = mg.get(`${prefix}_T`);
+        let module= mg.get(`${prefix}_T`) ?? mg.get(`${prefix}_B`) as Module;
-        if(!fullPath) {
+        if(!module) {
-            fullPath = mg.get(`${prefix}_B`);
+            return Err('Possibly undefined behavior: could not find a static id to resolve');
-            if(!fullPath) {
-                return Err('Possibly undefined behavior: could not find a static id to resolve');
-            }
-        }
-        return Ok({ args: contextArgs(event, rest), module: fullPath as Processed<CommandModule>  })
-    });
-}
-/**
- * This function assigns remaining, incomplete data to each imported module.
- */
-function assignDefaults() {
-    return map(({ module, absPath }) => {
-        const processed = {
-            name: module.name ?? Files.filename(absPath),
-            description: module.description ?? '...',
-            ...module
-        }
-        return {
-            module: processed,
-            absPath,
-            metadata: {
-                isClass: module.constructor.name === 'Function',
-                fullPath: absPath,
-                id: Id.create(processed.name, module.type),
-            }
         }
+        return Ok({ args: [Context.wrap(event, defaultPrefix)], module, deps })
     });
 }
 
-export function buildModules<T extends AnyModule>(
-    input: ObservableInput<string>,
-) {
-    return Files
-        .buildModuleStream<Processed<T>>(input)
-        .pipe(assignDefaults());
-}
 
-
-interface ExecutePayload {
-    module: Processed<Module>;
-    task: () => Awaitable<unknown>;
-    args: unknown[]
-}
 /**
  * Wraps the task in a Result as a try / catch.
  * if the task is ok, an event is emitted and the stream becomes empty
  * if the task is an error, throw an error down the stream which will be handled by catchError
+ * thank u kingomes
  * @param emitter reference to SernEmitter that will emit a successful execution of module
  * @param module the module that will be executed with task
  * @param task the deferred execution which will be called
  */
-export function executeModule(
+export function executeModule(emitter: Emitter, { module, args }: ExecutePayload) {
-    emitter: Emitter,
+    return from(Result.wrapAsync(async () => module.execute(...args)))
-    logger: Logging|undefined,
+        .pipe(concatMap(result => { 
-    errHandler: ErrorHandling,
-    {
-        module,
-        task,
-        args
-    }: ExecutePayload,
-) {
-    return of(module).pipe(
-        //converting the task into a promise so rxjs can resolve the Awaitable properly
-        concatMap(() => Result.wrapAsync(async () => task())),
-        concatMap(result => {
             if (result.isOk()) {
-                emitter.emit('module.activate', resultPayload(PayloadType.Success, module));
+                emitter.emit('module.activate', resultPayload('success', module));
                 return EMPTY;
-            } 
+            }
-            return throwError(() => resultPayload(PayloadType.Failure, module, result.error));
+            return throwError(() => resultPayload('failure', module, result.error));
-            
+        }))
-        }),
+};
-    );
-}
-
-
 
 /**
  * A higher order function that
- * - creates a stream of {@link VoidResult} { config.createStream }
+ * - calls all control plugins.
- * - any failures results to { config.onFailure } being called
+ * - any failures results to { config.onStop } being called
  * - if all results are ok, the stream is converted to { config.onNext }
- * emit config.onSuccess Observable
+ * config.onNext will be returned if everything is okay.
  * @param config
- * @returns receiver function for flattening a stream of data
+ * @returns function which calls all plugins and returns onNext or fail 
  */
-export function createResultResolver<
+export function createResultResolver<Output>(config: {
-    T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
+    onStop?: (module: Module, err?: string) => unknown;
-    Args extends { module: T; [key: string]: unknown },
+    onNext: (args: ExecutePayload, map: Record<string, unknown>) => Output;
-    Output,
->(config: {
-    onStop?: (module: T) => unknown;
-    onNext: (args: Args) => Output;
-    createStream: (args: Args) => Observable<VoidResult>;
 }) {
-    return (args: Args) => {
+    const { onStop, onNext } = config;
-        const task$ = config.createStream(args);
+    return async (payload: ExecutePayload) => {
-        return task$.pipe(
+        const task = await callPlugins(payload);
-            tap(result => {
+        if (!task) throw Error("Plugin did not return anything.");
-                result.isErr() && config.onStop?.(args.module);
+        if(task.isOk()) {
-            }),
+            return onNext(payload, task.value) as Output;
-            everyPluginOk,
+        } else {
-            filterMapTo(() => config.onNext(args)),
+            onStop?.(payload.module, String(task.error));
-        );
+        }
     };
+};
+
+function isObject(item: unknown) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
 }
 
-/**
+//_module is frozen, preventing from mutations
- * Calls a module's init plugins and checks for Err. If so, call { onStop } and
+export async function callInitPlugins(_module: Module, deps: Dependencies, emit?: boolean) {
- * ignore the module
+    let module = _module;
- */
+    const emitter = deps['@sern/emitter'];
-export function callInitPlugins<T extends Processed<AnyModule>>(sernEmitter: Emitter) {
+    for(const plugin of module.plugins ?? []) {
-    return concatMap(
+        const result = await plugin.execute({ module, absPath: module.meta.absPath, deps });
-        createResultResolver({
+        if (!result) throw Error("Plugin did not return anything. " + inspect(plugin, false, Infinity, true));
-            createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
+        if(result.isErr()) {
-            onStop: (module: T) => {
+            if(emit) {
-                sernEmitter.emit('module.register', resultPayload(PayloadType.Failure, module, SernError.PluginFailure));
+                emitter?.emit('module.register',
-            },
+                              resultPayload('failure', module, result.error ?? SernError.PluginFailure));
-            onNext: (payload) => {
+            }
-                sernEmitter.emit('module.register', resultPayload(PayloadType.Success, payload.module));
+            throw Error(result.error ?? SernError.PluginFailure);
-                return payload as { module: T; metadata: CommandMeta };
+        }
-            },
+    }
-        }),
+    return module
-    );
 }
 
+export async function callPlugins({ args, module, deps, params }: ExecutePayload) {
+    let state = {};
+    for(const plugin of module.onEvent??[]) {
+        const result = await plugin.execute(...args, { state, deps, params, type: module.type });
+        if(result.isErr()) {
+            return result;
+        }
+        if(isObject(result.value)) {
+            state = merge(state, result.value!);
+        }
+    }
+    return Ok(state);
+}
 /**
- * Creates an executable task ( execute the command ) if  all control plugins are successful
+ * Creates an executable task ( execute the command ) if all control plugins are successful
  * @param onStop emits a failure response to the SernEmitter
  */
-export function makeModuleExecutor<
+export function intoTask(onStop: (m: Module) => unknown) {
-    M extends Processed<Module>,
+    const onNext = ({ args, module, deps, params }: ExecutePayload, state: Record<string, unknown>) => ({
-    Args extends { 
-        module: M;
-        args: unknown[];
-    },
->(onStop: (m: M) => unknown) {
-    const onNext = ({ args, module }: Args) => ({
-        task: () => module.execute(...args),
         module,
-        args
+        args: [...args, { state, deps, params, type: module.type }],
+        deps
     });
-    return concatMap(
+    return createResultResolver({ onStop, onNext });
-        createResultResolver({
-            onStop,
-            createStream: ({ args, module }) => 
-                from(module.onEvent)
-                    .pipe(callPlugin(args)),
-            onNext,
-        }),
-    );
 }
 
-export const handleCrash = (err: ErrorHandling,sernemitter: Emitter, log?: Logging) =>
+export const handleCrash = ({ "@sern/errors": err, '@sern/emitter': sem, '@sern/logger': log } : UnpackedDependencies, metadata: string) => 
-    pipe(
+    pipe(catchError(handleError(err, sem, log)),
-        catchError(handleError(err, sernemitter, log)),
+         finalize(() => {
-        finalize(() => {
+            log?.info({ message: 'A stream closed: ' + metadata  });
-            log?.info({
-                message: 'A stream closed or reached end of lifetime',
-            });
             disposeAll(log);
-        }));
+         }))

src/handlers/interaction-event.ts

@@ -1,33 +0,0 @@
-import { Interaction } from 'discord.js';
-import { mergeMap, merge } from 'rxjs';
-import { PayloadType } from '../core';
-import {
-    isAutocomplete,
-    isCommand,
-    isMessageComponent,
-    isModal,
-    sharedEventStream,
-    SernError,
-    filterTap,
-    resultPayload,
-} from '../core/_internal';
-import { createInteractionHandler, executeModule, makeModuleExecutor } from './_internal';
-import type { DependencyList } from '../types/ioc';
-
-export function interactionHandler([emitter, err, log, modules, client]: DependencyList) {
-    const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
-    const handle = createInteractionHandler(interactionStream$, modules);
-
-    const interactionHandler$ = merge(
-        handle(isMessageComponent),
-        handle(isAutocomplete),
-        handle(isCommand),
-        handle(isModal),
-    );
-    return interactionHandler$
-        .pipe(
-            filterTap(e => emitter.emit('warning', resultPayload(PayloadType.Warning, undefined, e))),
-            makeModuleExecutor(module => 
-                emitter.emit('module.activate', resultPayload(PayloadType.Failure, module, SernError.PluginFailure))),
-            mergeMap(payload => executeModule(emitter, log, err, payload)));
-}

src/handlers/interaction.ts

@@ -0,0 +1,30 @@
+import type { Interaction } from 'discord.js';
+import { mergeMap, merge, concatMap, EMPTY } from 'rxjs';
+import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash } from './event-utils';
+import { SernError } from '../core/structures/enums'
+import { isAutocomplete, isCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
+import { UnpackedDependencies } from '../types/utility';
+
+export default function interactionHandler(deps: UnpackedDependencies, defaultPrefix?: string) {
+    //i wish javascript had clojure destructuring 
+    const { '@sern/client': client,
+            '@sern/emitter': emitter } = deps
+    const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
+    const handle = createInteractionHandler(interactionStream$, deps, defaultPrefix);
+
+    const interactionHandler$ = merge(handle(isMessageComponent),
+                                      handle(isAutocomplete),
+                                      handle(isCommand),
+                                      handle(isModal));
+    return interactionHandler$
+        .pipe(filterTap(e => emitter.emit('warning', resultPayload('warning', undefined, e))),
+              concatMap(intoTask(module => {
+                emitter.emit('module.activate', resultPayload('failure', module, SernError.PluginFailure))
+              })),
+              mergeMap(payload => {
+                  if(payload)
+                    return executeModule(emitter, payload)
+                  return EMPTY;
+              }),
+              handleCrash(deps, "interaction handling"));
+}

src/handlers/message-event.ts

@@ -1,47 +0,0 @@
-import { mergeMap, EMPTY } from 'rxjs';
-import type { Message } from 'discord.js';
-import { PayloadType } from '../core';
-import { sharedEventStream, SernError, filterTap, resultPayload } from '../core/_internal';
-import { createMessageHandler, executeModule, makeModuleExecutor } from './_internal';
-import type { DependencyList } from '../types/ioc';
-
-/**
- * Ignores messages from any person / bot except itself
- * @param prefix
- */
-function isNonBot(prefix: string) {
-    return (msg: Message): msg is Message => !msg.author.bot && hasPrefix(prefix, msg.content);
-}
-
-function hasPrefix(prefix: string, content: string) {
-    const prefixInContent = content.slice(0, prefix.length);
-    return (
-        prefixInContent.localeCompare(prefix, undefined, {
-            sensitivity: 'accent',
-        }) === 0
-    );
-}
-
-export function messageHandler(
-    [emitter, err, log, modules, client]: DependencyList,
-    defaultPrefix: string | undefined,
-) {
-    if (!defaultPrefix) {
-        log?.debug({
-            message: 'No prefix found. message handler shutting down',
-        });
-        return EMPTY;
-    }
-    const messageStream$ = sharedEventStream<Message>(client, 'messageCreate');
-    const handle = createMessageHandler(messageStream$, defaultPrefix, modules);
-
-    const msgCommands$ = handle(isNonBot(defaultPrefix));
-
-    return msgCommands$.pipe(
-        filterTap((e) => emitter.emit('warning', resultPayload(PayloadType.Warning, undefined, e))),
-        makeModuleExecutor(module => {
-            const result = resultPayload(PayloadType.Failure, module, SernError.PluginFailure);
-            emitter.emit('module.activate', result);
-        }),
-        mergeMap(payload => executeModule(emitter, log, err, payload)));
-}

src/handlers/message.ts

@@ -0,0 +1,50 @@
+import { EMPTY, mergeMap, concatMap } from 'rxjs';
+import type { Message } from 'discord.js';
+import { createMessageHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash} from './event-utils';
+import { SernError } from '../core/structures/enums'
+import { resultPayload } from '../core/functions'
+import { UnpackedDependencies } from '../types/utility';
+import type { Emitter } from '../core/interfaces';
+
+/**
+ * Ignores messages from any person / bot except itself
+ * @param prefix
+ */
+function isNonBot(prefix: string) {
+    return (msg: Message): msg is Message => !msg.author.bot && hasPrefix(prefix, msg.content);
+}
+
+function hasPrefix(prefix: string, content: string) {
+    const prefixInContent = content.slice(0, prefix.length);
+    return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
+}
+
+export default 
+function (deps: UnpackedDependencies, defaultPrefix?: string) {
+    const {"@sern/emitter": emitter,  
+           '@sern/logger': log, 
+           '@sern/client': client} = deps
+
+    if (!defaultPrefix) {
+        log?.debug({ message: 'No prefix found. message handler shutting down' });
+        return EMPTY;
+    }
+    const messageStream$ = sharedEventStream<Message>(client as unknown as Emitter, 'messageCreate');
+    const handle = createMessageHandler(messageStream$, defaultPrefix, deps);
+
+    const msgCommands$ = handle(isNonBot(defaultPrefix));
+
+    return msgCommands$.pipe(
+        filterTap(e => emitter.emit('warning', resultPayload('warning', undefined, e))),
+        concatMap(intoTask(module => {
+            const result = resultPayload('failure', module, SernError.PluginFailure);
+            emitter.emit('module.activate', result);
+        })),
+        mergeMap(payload => {
+            if(payload)
+                return executeModule(emitter, payload)
+            return EMPTY;
+        }),
+        handleCrash(deps, "message handling")
+    )
+}

src/handlers/presence.ts

@@ -1,9 +1,8 @@
 import { concatMap, from, interval, of, map, scan, startWith, fromEvent, take } from "rxjs"
-import { Files } from "../core/_internal";
+import { Presence  } from "../core/presences";
-import * as Presence from "../core/presences";
 import { Services } from "../core/ioc";
 import assert from "node:assert";
-
+import * as Files from "../core/module-loading";
 type SetPresence = (conf: Presence.Result) => Promise<unknown>
 
 const parseConfig = async (conf: Promise<Presence.Result>) => {
@@ -15,20 +14,16 @@ const parseConfig = async (conf: Promise<Presence.Result>) => {
             const src$ = typeof repeat === 'number' 
                 ? interval(repeat)
                 : fromEvent(...repeat);
-                return src$
+                return src$.pipe(scan(onRepeat, s), 
-                    .pipe(scan(onRepeat, s), 
+                                 startWith(s));
-                          startWith(s));
         }
         return of(s).pipe(take(1));
     })
 };
 
 export const presenceHandler = (path: string, setPresence: SetPresence) => {
-    interface PresenceModule  {
-        module: Presence.Config<(keyof Dependencies)[]>
-    }
     const presence = Files
-        .importModule<PresenceModule>(path)
+        .importModule<Presence.Config<(keyof Dependencies)[]>>(path)
         .then(({ module }) => {
             //fetch services with the order preserved, passing it to the execute fn 
             const fetchedServices = Services(...module.inject ?? []);

src/handlers/ready-event.ts

@@ -1,54 +0,0 @@
-import { ObservableInput, concat, first, fromEvent, ignoreElements, pipe, tap } from 'rxjs';
-import { CommandType } from '../core/structures';
-import { SernError } from '../core/_internal';
-import { Result } from 'ts-results-es';
-import { Logging, ModuleManager } from '../core/contracts';
-import { buildModules, callInitPlugins } from './_internal';
-import * as assert from 'node:assert';
-import * as util from 'node:util';
-import type { DependencyList } from '../types/ioc';
-import type { AnyModule, CommandMeta, Processed } from '../types/core-modules';
-
-export function readyHandler(
-    [sEmitter, , log , moduleManager, client]: DependencyList,
-    allPaths: ObservableInput<string>,
-) {
-    //Todo: add module manager on on ready
-    const ready$ = fromEvent(client!, 'ready').pipe(once(log));
-    
-    return concat(ready$, buildModules<AnyModule>(allPaths))
-        .pipe(callInitPlugins(sEmitter))
-        .subscribe(({ module, metadata }) => {
-            register(moduleManager, module, metadata)
-                .expect(SernError.InvalidModuleType + ' ' + util.inspect(module));
-        });
-}
-
-const once = (log: Logging | undefined) => pipe(
-    tap(() => { log?.info({ message: "Waiting on discord client to be ready..." }) }),
-    first(),
-    ignoreElements())
-
-
-function register<T extends Processed<AnyModule>>(
-    manager: ModuleManager,
-    module: T,
-    metadata:CommandMeta 
-): Result<void, void> {
-    manager.setMetadata(module, metadata)!;
-
-    const validModuleType = module.type >= 0 && module.type <= 1 << 10;
-    assert.ok(
-        validModuleType,
-        //@ts-ignore
-        `Found ${module.name} at ${metadata.fullPath}, which does not have a valid type`,
-    );
-    if (module.type === CommandType.Both) {
-        module.alias?.forEach(a => manager.set(`${a}_B`, module));
-    } else {
-        if(module.type === CommandType.Text){ 
-            module.alias?.forEach(a => manager.set(`${a}_T`, module));
-        }
-    }
-    return Result.wrap(() => manager.set(metadata.id, module));
-}

src/handlers/ready.ts

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

src/handlers/tasks.ts

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

src/handlers/user-defined-events.ts

@@ -1,36 +1,33 @@
-import { ObservableInput, map, mergeAll } from 'rxjs';
+import { EventType,  SernError } from '../core/structures/enums';
-import { EventType } from '../core/structures';
+import { callInitPlugins, eventDispatcher, handleCrash } from './event-utils'
-import { SernError } from '../core/_internal';
+import { EventModule,  Module  } from '../types/core-modules';
-import { buildModules, callInitPlugins, handleCrash, eventDispatcher } from './_internal';
+import * as Files from '../core/module-loading'
-import { Service } from '../core/ioc';
+import type { UnpackedDependencies } from '../types/utility';
-import type { DependencyList } from '../types/ioc';
+import { from, map, mergeAll } from 'rxjs';
-import type { EventModule,  Processed } from '../types/core-modules';
 
-export function eventsHandler(
+const intoDispatcher = (deps: UnpackedDependencies) => 
-    [emitter, err, log, moduleManager, client]: DependencyList,
+    (module : EventModule) => {
-    allPaths: ObservableInput<string>,
+        switch (module.type) {
-) {
-    //code smell
-    const intoDispatcher = (e: { module: Processed<EventModule> }) => {
-        switch (e.module.type) {
             case EventType.Sern:
-                return eventDispatcher(e.module,  emitter);
+                return eventDispatcher(deps, module,  deps['@sern/emitter']);
             case EventType.Discord:
-                return eventDispatcher(e.module,  client);
+                return eventDispatcher(deps, module,  deps['@sern/client']);
             case EventType.External:
-                return eventDispatcher(e.module,  Service(e.module.emitter));
+                return eventDispatcher(deps, module,  deps[module.emitter]);
-            default:
+            default: throw Error(SernError.InvalidModuleType + ' while creating event handler');
-                throw Error(SernError.InvalidModuleType + ' while creating event handler');
         }
-    };
+};
-    buildModules<EventModule>(allPaths)
+
-        .pipe(
+export default async function(deps: UnpackedDependencies, eventDir: string) {
-            callInitPlugins(emitter),
+    const eventModules: EventModule[] = [];
-            map(intoDispatcher),
+    for await (const path of Files.readRecursive(eventDir)) {
-            /**
+        let { module } = await Files.importModule<Module>(path);
-             * Where all events are turned on
+        await callInitPlugins(module, deps)
-             */
+        eventModules.push(module as EventModule);
-            mergeAll(),
+    }
-            handleCrash(err, emitter, log))
+    from(eventModules)
-        .subscribe();
+        .pipe(map(intoDispatcher(deps)),
+               mergeAll(), // all eventListeners are turned on
+               handleCrash(deps, "event modules"))
+            .subscribe();
 }

src/index.ts

@@ -1,6 +1,7 @@
 export * as Sern from './sern';
-export * from './core';
+
 export type {
+    Module,
     CommandModule,
     EventModule,
     BothCommand,
@@ -24,30 +25,48 @@ export type {
     SernOptionsData,
     SernSubCommandData,
     SernSubCommandGroupData,
+    SDT,
+    ScheduledTask
 } from './types/core-modules';
 
 export type {
-    Controller,
     PluginResult,
     InitPlugin,
     ControlPlugin,
     Plugin,
-    AnyEventPlugin,
+    AnyPlugin,
-    AnyCommandPlugin,
 } from './types/core-plugin';
 
-export type { Wrapper } from './types/core';
 
-export type { Args, SlashOptions, Payload, SernEventsMapping } from './types/utility';
+export type { Payload, SernEventsMapping } from './types/utility';
-
-export type { Singleton, Transient, CoreDependencies, Initializable } from './types/ioc';
 
 export {
     commandModule,
     eventModule,
     discordEvent,
+    scheduledTask
 } from './core/modules';
 
-export * as Presence from './core/presences'
+export * from './core/presences'
+export * from './core/interfaces'
+export * from './core/plugin';
+export { CommandType, PluginType, PayloadType, EventType } from './core/structures/enums';
+export { Context } from './core/structures/context';
+export { type CoreDependencies, makeDependencies, single, transient, Service, Services } from './core/ioc';
 
 
+import type { Container } from '@sern/ioc';
+
+/**
+  * @deprecated This old signature will be incompatible with future versions of sern >= 4.0.0. See {@link makeDependencies}
+  * @example
+  * ```ts
+  *  To switch your old code:
+     await makeDependencies(({ add }) => { 
+            add('@sern/client', new Client())
+     })
+  *  ```
+  */
+export interface DependencyConfiguration {
+    build: (root: Container) => Container;
+}

src/sern.ts

@@ -1,19 +1,27 @@
-import { handleCrash } from './handlers/_internal';
+//side effect: global container
-import callsites from 'callsites';
+import { useContainerRaw } from '@sern/ioc/global';
-import { Files } from './core/_internal';
-import { merge } from 'rxjs';
-import { Services } from './core/ioc';
-import { Wrapper } from './types/core';
-import { eventsHandler } from './handlers/user-defined-events';
-import { readyHandler } from './handlers/ready-event';
-import { messageHandler } from './handlers/message-event';
-import { interactionHandler } from './handlers/interaction-event';
-import { presenceHandler } from './handlers/presence';
-import { Client } from 'discord.js';
 
+import callsites from 'callsites';
+import * as  Files from './core/module-loading';
+import { merge } from 'rxjs';
+import eventsHandler from './handlers/user-defined-events';
+import ready  from './handlers/ready';
+import messageHandler from './handlers/message';
+import interactionHandler from './handlers/interaction';
+import { presenceHandler } from './handlers/presence';
+import { UnpackedDependencies } from './types/utility';
+import type { Presence} from './core/presences';
+import { registerTasks } from './handlers/tasks';
+
+interface Wrapper {
+    commands: string;
+    defaultPrefix?: string;
+    events?: string;
+    tasks?: string;
+}
 /**
  * @since 1.0.0
- * @param wrapper Options to pass into sern.
+ * @param maybeWrapper Options to pass into sern.
  * Function to start the handler up
  * @example
  * ```ts title="src/index.ts"
@@ -23,40 +31,41 @@ import { Client } from 'discord.js';
  * })
  * ```
  */
-export function init(maybeWrapper: Wrapper | 'file') {
-    const startTime = performance.now();
-    const dependencies = Services('@sern/emitter', 
-                                  '@sern/errors',
-                                  '@sern/logger',
-                                  '@sern/modules',
-                                  '@sern/client');
-    const logger = dependencies[2],
-        errorHandler = dependencies[1];
 
-    const wrapper = Files.loadConfig(maybeWrapper, logger);
+export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
-    if (wrapper.events !== undefined) {
+    const startTime = performance.now();
-        eventsHandler(dependencies, Files.getFullPathTree(wrapper.events));
+    const deps = useContainerRaw().deps<UnpackedDependencies>();
+    
+    if (maybeWrapper.events !== undefined) {
+        eventsHandler(deps, maybeWrapper.events)
+            .then(() => {
+                deps['@sern/logger']?.info({ message: "Events registered" });
+            });
+    } else {
+        deps['@sern/logger']?.info({ message: "No events registered" });
     }
 
     const initCallsite = callsites()[1].getFileName();
     const presencePath = Files.shouldHandle(initCallsite!, "presence");
     //Ready event: load all modules and when finished, time should be taken and logged
-    readyHandler(dependencies, Files.getFullPathTree(wrapper.commands))
+    ready(maybeWrapper.commands, deps)
-        .add(() => {
+        .then(() => {
-            logger?.info({ message: "Client signaled ready, registering modules" });
             const time = ((performance.now() - startTime) / 1000).toFixed(2);
-            dependencies[0].emit('modulesLoaded');
+            deps['@sern/logger']?.info({ message: `sern: registered in ${time} s` });
-            logger?.info({ message: `sern: registered in ${time} s`, });
             if(presencePath.exists) {
-                const setPresence = async (p: any) => {
+                const setPresence = async (p: Presence.Result) => {
-                    return (dependencies[4] as Client).user?.setPresence(p);
+                    return deps['@sern/client'].user?.setPresence(p);
                 }
                 presenceHandler(presencePath.path, setPresence).subscribe();
             }
-        });
+            if(maybeWrapper.tasks) {
+                registerTasks(maybeWrapper.tasks, deps);
+            }
+        })
+        .catch(err => { throw err });
 
-    const messages$ = messageHandler(dependencies, wrapper.defaultPrefix);
+    const messages$ = messageHandler(deps, maybeWrapper.defaultPrefix);
-    const interactions$ = interactionHandler(dependencies);
+    const interactions$ = interactionHandler(deps, maybeWrapper.defaultPrefix);
     // listening to the message stream and interaction stream
-    merge(messages$, interactions$).pipe(handleCrash(errorHandler, dependencies[0], logger)).subscribe();
+    merge(messages$, interactions$).subscribe();
 }

src/types/core-modules.ts

@@ -14,17 +14,20 @@ import type {
     StringSelectMenuInteraction,
     UserContextMenuCommandInteraction,
     UserSelectMenuInteraction,
+    ChatInputCommandInteraction,
 } from 'discord.js';
-import { CommandType, Context, EventType } from '../../src/core';
+import type { CommandType, EventType } from '../core/structures/enums';
-import { AnyCommandPlugin, AnyEventPlugin, ControlPlugin, InitPlugin } from './core-plugin';
+import { Context } from '../core/structures/context'
-import { Awaitable, Args, SlashOptions, SernEventsMapping } from './utility';
+import { ControlPlugin, InitPlugin, Plugin } from './core-plugin';
+import { Awaitable, SernEventsMapping, UnpackedDependencies } from './utility';
 
-
+//state, deps, type (very original)
-export interface CommandMeta {
+export type SDT = {
-    fullPath: string;
+    state: Record<string,unknown>;
-    id: string;
+    deps: Dependencies;
-    isClass: boolean;
+    type: CommandType,
-}
+    params?: string
+};
 
 export type Processed<T> = T & { name: string; description: string };
 
@@ -34,6 +37,11 @@ export interface Module {
     onEvent: ControlPlugin[];
     plugins: InitPlugin[];
     description?: string;
+    meta: {
+        id: string;
+        absPath: string;
+    }
+    locals: Record<string,unknown>
     execute(...args: any[]): Awaitable<any>;
 }
 
@@ -43,6 +51,7 @@ export interface SernEventCommand<T extends keyof SernEventsMapping = keyof Sern
     type: EventType.Sern;
     execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
 }
+
 export interface ExternalEventCommand extends Module {
     name?: string;
     emitter: keyof Dependencies;
@@ -50,54 +59,54 @@ export interface ExternalEventCommand extends Module {
     execute(...args: unknown[]): Awaitable<unknown>;
 }
 
+
 export interface ContextMenuUser extends Module {
     type: CommandType.CtxUser;
-    execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
+    execute: (ctx: UserContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ContextMenuMsg extends Module {
     type: CommandType.CtxMsg;
-    execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
+    execute: (ctx: MessageContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ButtonCommand extends Module {
     type: CommandType.Button;
-    execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
+    execute: (ctx: ButtonInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface StringSelectCommand extends Module {
     type: CommandType.StringSelect;
-    execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: StringSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ChannelSelectCommand extends Module {
     type: CommandType.ChannelSelect;
-    execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: ChannelSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface RoleSelectCommand extends Module {
     type: CommandType.RoleSelect;
-    execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: RoleSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface MentionableSelectCommand extends Module {
     type: CommandType.MentionableSelect;
-    execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: MentionableSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface UserSelectCommand extends Module {
     type: CommandType.UserSelect;
-    execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: UserSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ModalSubmitCommand extends Module {
     type: CommandType.Modal;
-    execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
+    execute: (ctx: ModalSubmitInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
-export interface AutocompleteCommand
+export interface AutocompleteCommand {
-    extends Omit<Module, 'name' | 'type' | 'plugins' | 'description'> {
+    onEvent?: ControlPlugin[];
-    onEvent: ControlPlugin[];
     execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
 }
 
@@ -109,26 +118,24 @@ export interface DiscordEventCommand<T extends keyof ClientEvents = keyof Client
 }
 export interface TextCommand extends Module {
     type: CommandType.Text;
-    alias?: string[];
+    execute: (ctx: Context & { get options(): string[] }, tbd: SDT) => Awaitable<unknown>;
-    execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
 }
 
 export interface SlashCommand extends Module {
     type: CommandType.Slash;
     description: string;
     options?: SernOptionsData[];
-    execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
+    execute: (ctx: Context  & { get options(): ChatInputCommandInteraction['options']}, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface BothCommand extends Module {
     type: CommandType.Both;
-    alias?: string[];
     description: string;
     options?: SernOptionsData[];
-    execute: (ctx: Context, args: Args) => Awaitable<unknown>;
+    execute: (ctx: Context, tbd: SDT) => Awaitable<unknown>;
 }
 
-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;  
 export type CommandModule =
     | TextCommand
     | SlashCommand
@@ -143,7 +150,6 @@ export type CommandModule =
     | RoleSelectCommand
     | ModalSubmitCommand;
 
-export type AnyModule = CommandModule | EventModule;
 //https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
 // Explicit Module Definitions for mapping
 export interface CommandModuleDefs {
@@ -178,19 +184,22 @@ export interface SernAutocompleteData
 }
 
 type CommandModuleNoPlugins = {
-    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
+    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'>;
 };
 type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
+    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'> ;
 };
 
 export type InputEvent = {
-    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: AnyEventPlugin[] };
+    [T in EventType]: EventModulesNoPlugins[T] & {
+        once?: boolean;
+        plugins?: InitPlugin[] 
+    };
 }[EventType];
 
 export type InputCommand = {
     [T in CommandType]: CommandModuleNoPlugins[T] & {
-        plugins?: AnyCommandPlugin[];
+        plugins?: Plugin[];
     };
 }[CommandType];
 
@@ -213,3 +222,37 @@ export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsDa
     type: ApplicationCommandOptionType.SubcommandGroup;
     options?: SernSubCommandData[];
 }
+
+
+export interface ScheduledTaskContext {
+     
+    /**
+     * the uuid of the current task being run
+     */
+    id: string;
+    /**
+     * the last time this task was executed. If this is the first time, it is null.
+     */
+    lastTimeExecution: Date | null;
+    /**
+      * The next time this task will be executed.
+      */
+    nextTimeExecution: Date | null;
+}
+
+//name subject to change
+interface TaskAttrs {
+    /**
+     * An object of dependencies configured in `makeDependencies`
+     */
+    deps: UnpackedDependencies
+}
+
+export interface ScheduledTask {
+    name?: string;
+    trigger: string | Date;
+    timezone?: string;
+    execute(tasks: ScheduledTaskContext, sdt: TaskAttrs): Awaitable<void>
+}
+
+

src/types/core-plugin.ts

@@ -11,34 +11,18 @@
  * Plugins are reminiscent of middleware in express.
  */
 
-import type { Err, Ok, Result } from 'ts-results-es';
+import type { Result } from 'ts-results-es';
 import type {
-    BothCommand,
-    ButtonCommand,
-    ChannelSelectCommand,
-    CommandModule,
-    ContextMenuMsg,
-    ContextMenuUser,
-    DiscordEventCommand,
-    EventModule,
-    ExternalEventCommand,
-    MentionableSelectCommand,
-    ModalSubmitCommand,
     Module,
     Processed,
-    RoleSelectCommand,
+    SDT,
-    SernEventCommand,
-    SlashCommand,
-    StringSelectCommand,
-    TextCommand,
-    UserSelectCommand,
 } from './core-modules';
-import type { Args, Awaitable, Payload, SlashOptions } from './utility';
+import type { Awaitable } from './utility';
-import type { CommandType, Context, EventType, PluginType } from '../core';
+import type { CommandType, PluginType } from '../core/structures/enums'
+import type { Context } from '../core/structures/context'
 import type {
     ButtonInteraction,
     ChannelSelectMenuInteraction,
-    ClientEvents,
     MentionableSelectMenuInteraction,
     MessageContextMenuCommandInteraction,
     ModalSubmitInteraction,
@@ -48,106 +32,40 @@ import type {
     UserSelectMenuInteraction,
 } from 'discord.js';
 
-export type PluginResult = Awaitable<VoidResult>;
+export type PluginResult = Awaitable<Result<Record<string,unknown>|undefined, string|undefined>>;
-export type VoidResult = Result<void, void>;
+export interface InitArgs<T extends Processed<Module> = Processed<Module>> {
-
-export interface InitArgs<T extends Processed<Module>> {
     module: T;
     absPath: string;
-}
+    deps: Dependencies
-export interface Controller {
-    next: () => Ok<void>;
-    stop: () => Err<void>;
 }
 export interface Plugin<Args extends any[] = any[]> {
     type: PluginType;
     execute: (...args: Args) => PluginResult;
 }
 
-export interface InitPlugin<Args extends any[] = any[]> {
+export interface InitPlugin<Args extends any[] = any[]> extends Plugin<Args> {
     type: PluginType.Init;
     execute: (...args: Args) => PluginResult;
 }
-export interface ControlPlugin<Args extends any[] = any[]> {
+export interface ControlPlugin<Args extends any[] = any[]> extends Plugin<Args> {
     type: PluginType.Control;
-    execute: (...args: Args) => PluginResult;
 }
 
-export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
+export type AnyPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<Module>>]>;
-export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;
 
-export type CommandArgs<
+export type CommandArgs<I extends CommandType = CommandType> = CommandArgsMatrix[I]
-    I extends CommandType = CommandType,
-    J extends PluginType = PluginType,
-> = CommandArgsMatrix[I][J];
-
-export type EventArgs<
-    I extends EventType = EventType,
-    J extends PluginType = PluginType,
-> = EventArgsMatrix[I][J];
 
 interface CommandArgsMatrix {
-    [CommandType.Text]: {
+    [CommandType.Text]: [Context, SDT];
-        [PluginType.Control]: [Context, ['text', string[]]];
+    [CommandType.Slash]: [Context, SDT];
-        [PluginType.Init]: [InitArgs<Processed<TextCommand>>];
+    [CommandType.Both]: [Context, SDT];
-    };
+    [CommandType.CtxMsg]: [MessageContextMenuCommandInteraction, SDT];
-    [CommandType.Slash]: {
+    [CommandType.CtxUser]: [UserContextMenuCommandInteraction, SDT];
-        [PluginType.Control]: [Context, ['slash', /* library coupled */ SlashOptions]];
+    [CommandType.Button]: [ButtonInteraction, SDT];
-        [PluginType.Init]: [InitArgs<Processed<SlashCommand>>];
+    [CommandType.StringSelect]: [StringSelectMenuInteraction, SDT];
-    };
+    [CommandType.RoleSelect]: [RoleSelectMenuInteraction, SDT];
-    [CommandType.Both]: {
+    [CommandType.ChannelSelect]: [ChannelSelectMenuInteraction, SDT];
-        [PluginType.Control]: [Context, Args];
+    [CommandType.MentionableSelect]: [MentionableSelectMenuInteraction, SDT];
-        [PluginType.Init]: [InitArgs<Processed<BothCommand>>];
+    [CommandType.UserSelect]: [UserSelectMenuInteraction, SDT];
-    };
+    [CommandType.Modal]: [ModalSubmitInteraction, SDT];
-    [CommandType.CtxMsg]: {
-        [PluginType.Control]: [/* library coupled */ MessageContextMenuCommandInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ContextMenuMsg>>];
-    };
-    [CommandType.CtxUser]: {
-        [PluginType.Control]: [/* library coupled */ UserContextMenuCommandInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ContextMenuUser>>];
-    };
-    [CommandType.Button]: {
-        [PluginType.Control]: [/* library coupled */ ButtonInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ButtonCommand>>];
-    };
-    [CommandType.StringSelect]: {
-        [PluginType.Control]: [/* library coupled */ StringSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<StringSelectCommand>>];
-    };
-    [CommandType.RoleSelect]: {
-        [PluginType.Control]: [/* library coupled */ RoleSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<RoleSelectCommand>>];
-    };
-    [CommandType.ChannelSelect]: {
-        [PluginType.Control]: [/* library coupled */ ChannelSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ChannelSelectCommand>>];
-    };
-    [CommandType.MentionableSelect]: {
-        [PluginType.Control]: [/* library coupled */ MentionableSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<MentionableSelectCommand>>];
-    };
-    [CommandType.UserSelect]: {
-        [PluginType.Control]: [/* library coupled */ UserSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<UserSelectCommand>>];
-    };
-    [CommandType.Modal]: {
-        [PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
-    };
-}
-
-interface EventArgsMatrix {
-    [EventType.Discord]: {
-        [PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
-        [PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
-    };
-    [EventType.Sern]: {
-        [PluginType.Control]: [Payload];
-        [PluginType.Init]: [InitArgs<Processed<SernEventCommand>>];
-    };
-    [EventType.External]: {
-        [PluginType.Control]: unknown[];
-        [PluginType.Init]: [InitArgs<Processed<ExternalEventCommand>>];
-    };
 }

src/types/core.ts

@@ -1,23 +0,0 @@
-
-export interface ImportPayload<T> {
-    module: T;
-    absPath: string;
-    [key: string]: unknown;
-}
-
-export interface Wrapper {
-    commands: string;
-    defaultPrefix?: string;
-    events?: string;
-    /**
-     * Overload to enable mode in case developer does not use a .env file.
-     * @deprecated - https://github.com/sern-handler/handler/pull/325
-     */
-    mode?: string
-    /*
-     * @deprecated
-     */
-    containerConfig?: {
-        get: (...keys: (keyof Dependencies)[]) => unknown[];
-    };
-}

src/types/dependencies.d.ts

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

src/types/ioc.ts

@@ -1,57 +0,0 @@
-import { Container, UnpackFunction } from 'iti';
-import * as Contracts from '../core/contracts';
-/**
-  * Type to annotate that something is a singleton. 
-  * T is created once and lazily.
-  */
-export type Singleton<T> = () => T;
-/**
-  * Type to annotate that something is transient. 
-  * Every time this is called, a new object is created
-  */
-export type Transient<T> = () => () => T;
-/**
-  * Type to annotate that something is initializable. 
-  * If T has an init method, this will be called.
-  */
-export type Initializable<T extends Contracts.Init> = T
-
-export type DependencyList = [
-    Contracts.Emitter,
-    Contracts.ErrorHandling,
-    Contracts.Logging | undefined,
-    Contracts.ModuleManager,
-    Contracts.Emitter,
-];
-
-export interface CoreDependencies {
-    '@sern/client': () => Contracts.Emitter;
-    '@sern/emitter': () => Contracts.Emitter;
-    /**
-      * @deprecated
-      * Will be removed and turned internal
-      */
-    '@sern/store': () => Contracts.CoreModuleStore;
-    '@sern/modules': () => Contracts.ModuleManager;
-    '@sern/errors': () => Contracts.ErrorHandling;
-    '@sern/logger'?: () => Contracts.Logging;
-}
-
-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'] };
-
-/**
-  * @deprecated This old signature will be incompatible with future versions of sern.
-  */
-export interface DependencyConfiguration {
-    /*
-     * @deprecated. Loggers will be opt-in the future
-     */
-    exclude?: Set<'@sern/logger'>;
-    build: (
-        root: Container<Omit<CoreDependencies, '@sern/client'>, {}>,
-    ) => Container<Dependencies, {}>;
-}

src/types/utility.ts

@@ -1,32 +1,27 @@
-import type { CommandInteractionOptionResolver, InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
+import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-import type { PayloadType } from '../core';
+import type { Module } from './core-modules';
-import type { AnyModule } from './core-modules';
+import type { Result } from 'ts-results-es';
 
 export type Awaitable<T> = PromiseLike<T> | T;
 
-export type AnyFunction = (...args: unknown[]) => unknown;
+export type VoidResult = Result<void, void>;
-
+export type AnyFunction = (...args: any[]) => unknown;
-// Thanks to @kelsny
-type ParseType<T> = {
-    [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
-}[keyof T];
-
-export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
-
-export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
 
 export interface SernEventsMapping {
     'module.register': [Payload];
     'module.activate': [Payload];
-    error: [{ type: PayloadType.Failure; module?: AnyModule; reason: string | Error }];
+    error: [{ type: 'failure'; module?: Module; reason: string | Error }];
     warning: [Payload];
     modulesLoaded: [never?];
 }
 
 export type Payload =
-    | { type: PayloadType.Success; module: AnyModule }
+    | { type: 'success'; module: Module }
-    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: 'failure'; module?: Module; reason: string | Error }
-    | { type: PayloadType.Warning; module: undefined; reason: string };
+    | { type: 'warning'; module: undefined; reason: string };
-
 
+export type UnpackFunction<T> = T extends (...args: any) => infer U ? U : T
+export type UnpackedDependencies = {
+    [K in keyof Dependencies]: UnpackFunction<Dependencies[K]>
+}
 export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;

test/core/contracts.test.ts

@@ -1,16 +1,11 @@
 import { assertType, describe, it } from 'vitest';
 
-import { ModuleStore } from '../../src';
+import * as  __Services  from '../../src/core/structures/default-services';
-import * as DefaultContracts from '../../src/core/structures/services';
+import * as Contracts from '../../src/core/interfaces';
-import * as Contracts from '../../src/core/contracts/index.js';
 
 describe('default contracts', () => {
     it('should satisfy contracts', () => {
-        assertType<Contracts.Logging>(new DefaultContracts.DefaultLogging());
+        assertType<Contracts.Logging>(new __Services.DefaultLogging());
-        assertType<Contracts.ErrorHandling>(new DefaultContracts.DefaultErrorHandling());
+        assertType<Contracts.ErrorHandling>(new __Services.DefaultErrorHandling());
-        assertType<Contracts.ModuleManager>(
-            new DefaultContracts.DefaultModuleManager(new ModuleStore()),
-        );
-        assertType<Contracts.CoreModuleStore>(new ModuleStore());
     });
 });

test/core/create-plugin.test.ts

@@ -2,17 +2,12 @@ import { describe, it, expect } from 'vitest';
 import {
     CommandControlPlugin,
     CommandInitPlugin,
-    EventControlPlugin,
     EventInitPlugin,
-} from '../../src/core/create-plugins';
+} from '../../src';
 import { PluginType, controller } from '../../src';
 
 describe('create-plugins', () => {
     it('should make proper control plugins', () => {
-        const pl = EventControlPlugin(() => controller.next());
-        expect(pl).to.have.all.keys(['type', 'execute']);
-        expect(pl.type).toBe(PluginType.Control);
-        expect(pl.execute).an('function');
         const pl2 = CommandControlPlugin(() => controller.next());
         expect(pl2).to.have.all.keys(['type', 'execute']);
         expect(pl2.type).toBe(PluginType.Control);

test/core/functions.test.ts

@@ -1,11 +1,13 @@
+//@ts-nocheck
+
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { PluginType, SernOptionsData, controller } from '../../src/index';
 import { partitionPlugins, treeSearch } from '../../src/core/functions';
 import { faker } from '@faker-js/faker';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
 
-vi.mock('discord.js', () => {
+vi.mock('discord.js', async (importOriginal) => {
-    const Collection = Map;
+    const mod = await importOriginal()
     const ModalSubmitInteraction = class {
         customId;
         type = 5;
@@ -36,35 +38,11 @@ vi.mock('discord.js', () => {
     };
 
     return {
-        Collection,
+        Collection: mod.Collection,
-        ComponentType: {
+        ComponentType: mod.ComponentType,
-            Button: 2,
+        InteractionType: mod.InteractionType,
-        },
+        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
-        InteractionType: {
+        ApplicationCommandType: mod.ApplicationCommandType, 
-            Ping: 1,
-            ApplicationCommand: 2,
-            MessageComponent: 3,
-            ApplicationCommandAutocomplete: 4,
-            ModalSubmit: 5,
-        },
-        ApplicationCommandOptionType: {
-            Subcommand: 1,
-            SubcommandGroup: 2,
-            String: 3,
-            Integer: 4,
-            Boolean: 5,
-            User: 6,
-            Channel: 7,
-            Role: 8,
-            Mentionable: 9,
-            Number: 10,
-            Attachment: 11,
-        },
-        ApplicationCommandType: {
-            ChatInput: 1,
-            User: 2,
-            Message: 3,
-        },
         ModalSubmitInteraction,
         ButtonInteraction,
         AutocompleteInteraction,

test/core/id.test.ts

@@ -1,58 +1,91 @@
-import { CommandType } from '../../src/core';
+//@ts-nocheck
-import * as Id from '../../src/core/id'
+import { expect, test, vi } from 'vitest'
-import { expect, test } from 'vitest'
+import { CommandType } from '../../src/core/structures/enums';
 
+import * as Id from '../../src/core/id'
+import { ButtonInteraction, ModalSubmitInteraction } from 'discord.js';
+vi.mock('discord.js', async (importOriginal) => {
+    const mod = await importOriginal()
+    const ModalSubmitInteraction = class {
+        customId;
+        type = 5;
+        isModalSubmit = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const ButtonInteraction = class {
+        customId;
+        type = 3;
+        componentType = 2;
+        isButton = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const AutocompleteInteraction = class {
+        type = 4;
+        option: string;
+        constructor(s: string) {
+            this.option = s;
+        }
+        options = {
+            getFocused: vi.fn(),
+            getSubcommand: vi.fn(),
+        };
+    };
+
+    return {
+        Collection: mod.Collection,
+        ComponentType: mod.ComponentType,
+        InteractionType: mod.InteractionType,
+        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
+        ApplicationCommandType: mod.ApplicationCommandType, 
+        ModalSubmitInteraction,
+        ButtonInteraction,
+        AutocompleteInteraction,
+    };
+});
 test('id -> Text', () => {
-    const bothCmdId = Id.create("ping", CommandType.Text)
+    expect(Id.create("ping", CommandType.Text)).toBe("ping_T")
-    expect(bothCmdId).toBe("ping_T")
 })
 
 test('id -> Both', () => {
-    const bothCmdId = Id.create("ping", CommandType.Both)
+    expect(Id.create("ping", CommandType.Both)).toBe("ping_B")
-    expect(bothCmdId).toBe("ping_B")
 })
 
 test('id -> CtxMsg', () => {
-    const bothCmdId = Id.create("ping", CommandType.CtxMsg)
+    expect(Id.create("ping", CommandType.CtxMsg)).toBe("ping_A3")
-    expect(bothCmdId).toBe("ping_A3")
 })
 test('id -> CtxUsr', () => {
-    const bothCmdId = Id.create("ping", CommandType.CtxUser)
+    expect(Id.create("ping", CommandType.CtxUser)).toBe("ping_A2")
-    expect(bothCmdId).toBe("ping_A2")
 })
 test('id -> Modal', () => {
-    const modal = Id.create("my-modal", CommandType.Modal)
+    expect(Id.create("my-modal", CommandType.Modal)).toBe("my-modal_M");
-    expect(modal).toBe("my-modal_M");
 })
 
 test('id -> Button', () => {
-    const modal = Id.create("my-button", CommandType.Button)
+    expect(Id.create("my-button", CommandType.Button)).toBe("my-button_C2");
-    expect(modal).toBe("my-button_C2");
 })
 
 test('id -> Slash', () => {
-    const modal = Id.create("myslash", CommandType.Slash)
+    expect(Id.create("myslash", CommandType.Slash)).toBe("myslash_A1");
-    expect(modal).toBe("myslash_A1");
 })
 
 test('id -> StringSelect', () => {
-    const modal = Id.create("mystringselect", CommandType.StringSelect)
+    expect(Id.create("mystringselect", CommandType.StringSelect)).toBe("mystringselect_C3");
-    expect(modal).toBe("mystringselect_C3");
 })
 
 test('id -> UserSelect', () => {
-    const modal = Id.create("myuserselect", CommandType.UserSelect)
+    expect(Id.create("myuserselect", CommandType.UserSelect)).toBe("myuserselect_C5");
-    expect(modal).toBe("myuserselect_C5");
 })
 
 test('id -> RoleSelect', () => {
-    const modal = Id.create("myroleselect", CommandType.RoleSelect)
+    expect(Id.create("myroleselect", CommandType.RoleSelect)).toBe("myroleselect_C6");
-    expect(modal).toBe("myroleselect_C6");
 })
 
 test('id -> MentionSelect', () => {
-    const modal = Id.create("mymentionselect", CommandType.MentionableSelect)
+    expect(Id.create("mymentionselect", CommandType.MentionableSelect)).toBe("mymentionselect_C7");
-    expect(modal).toBe("mymentionselect_C7");
 })
 
 test('id -> ChannelSelect', () => {
@@ -60,5 +93,43 @@ test('id -> ChannelSelect', () => {
     expect(modal).toBe("mychannelselect_C8");
 })
 
+test('id reconstruct button', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn"))
+    expect(idload[0].id).toBe("btn_C2")
+})
+
+test('id reconstruct button with params', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn/asdf"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("asdf")
+})
+test('id reconstruct modal with params', () => {
+    const idload = Id.reconstruct(new ModalSubmitInteraction("btn/asdf"))
+    expect(idload[0].id).toBe("btn_M")
+    expect(idload[0].params).toBe("asdf")
+})
+test('id reconstruct modal', () => {
+    const idload = Id.reconstruct(new ModalSubmitInteraction("btn"))
+    expect(idload[0].id).toBe("btn_M")
+    expect(idload[0].params).toBe(undefined)
+})
+test('id reconstruct button with empty params', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn/"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("")
+})
+test('id reconstruct with multiple slashes', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn//"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe("/")
+})
+
+
+test('id reconstruct button', () => {
+    const idload = Id.reconstruct(new ButtonInteraction("btn"))
+    expect(idload[0].id).toBe("btn_C2")
+    expect(idload[0].params).toBe(undefined)
+})
+
 
 

test/core/ioc.test.ts

@@ -1,113 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CoreContainer } from '../../src/core/ioc/container';
-import { EventEmitter } from 'events';
-import { DefaultLogging, Disposable, Emitter, Init, Logging } from '../../src/core';
-import { CoreDependencies } from '../../src/types/ioc';
-
-describe('ioc container', () => {
-    let container: CoreContainer<{}> = new CoreContainer();
-    let dependency: Logging & Init & Disposable;
-    let dependency2: Emitter
-    beforeEach(() => {
-        dependency = {
-            init: vi.fn(),
-            error(): void {},
-            warning(): void {},
-            info(): void {},
-            debug(): void {},
-            dispose: vi.fn()
-        };
-        dependency2 = {
-            addListener: vi.fn(),
-            removeListener: vi.fn(),
-            emit: vi.fn()
-        };
-        container = new CoreContainer();
-    });
-    const wait = (seconds: number) =>  new Promise((resolve) => setTimeout(resolve, seconds));
-    class DB implements Init, Disposable {
-      public connected = false
-      constructor() {}
-      async init() {
-        this.connected = true
-        await wait(10)
-      }
-      async dispose() {
-        await wait(20)
-        this.connected = false
-      }
-    }
-    it('should be ready after calling container.ready()', () => {
-        container.ready();
-        expect(container.isReady()).toBe(true);
-    });
-    it('should container all core dependencies', async () => {
-        const keys = [
-            '@sern/modules',
-            '@sern/emitter',
-            '@sern/logger',
-            '@sern/errors',
-        ] satisfies (keyof CoreDependencies)[];
-        container.add({
-            '@sern/logger': () => new DefaultLogging(),
-            '@sern/client': () => new EventEmitter(),
-        });
-        for (const k of keys) {
-            //@ts-expect-error typings for iti are strict
-            expect(() => container.get(k)).not.toThrow();
-        }
-    });
-    it('should init modules', () => {
-        container.upsert({ '@sern/logger': dependency });
-        container.ready();
-        expect(dependency.init).to.toHaveBeenCalledOnce();
-    });
-    it('should dispose modules', async () => {
-        
-        container.upsert({ '@sern/logger': dependency })
-
-        container.ready();
-        // We need to access the dependency at least once to be able to dispose of it.
-        container.get('@sern/logger' as never);
-        await container.disposeAll();
-        expect(dependency.dispose).toHaveBeenCalledOnce();
-    });
-
-    it('should init and dispose', async () => {
-        container.add({ db: new DB() })
-        container.ready()
-        const db = container.get('db' as never) as DB
-        expect(db.connected).toBeTruthy()
-
-        await container.disposeAll();
-
-        expect(db.connected).toBeFalsy()
-    })
-
-    it('should not lazy module', () => {
-        container.upsert({ '@sern/logger': () => dependency });
-        container.ready();
-        expect(dependency.init).toHaveBeenCalledTimes(0);
-    });
-
-    it('should init dependency depending on something else', () => {
-        container.add({ '@sern/client': dependency2 });
-        container.upsert((cntr) => ({
-            '@sern/logger': dependency 
-        }));
-        container.ready();
-        expect(dependency.init).toHaveBeenCalledTimes(1);
-    })
-
-    it('should detect a key already exists', () => {
-        container.add({ '@sern/client': dependency2 });
-        expect(container.hasKey('@sern/client')).toBeTruthy()
-    })
-
-
-    it('should detect a key already exists', () => {
-        container.add({ '@sern/client': () => dependency2 });
-        expect(container.hasKey('@sern/client')).toBeTruthy()
-    })
-
-});

test/core/module-loading.test.ts

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

test/core/presence.test.ts

@@ -5,7 +5,7 @@ import { Presence } from '../../src';
 // Example test suite for the module function
 describe('module function', () => {
   it('should return a valid configuration', () => {
-    const config: Presence.Config<['dependency1', 'dependency2']> = Presence.module({
+    const config = Presence.module({
       inject: ['dependency1', 'dependency2'],
       execute: vi.fn(),
     });

test/core/services.test.ts

@@ -1,80 +0,0 @@
-import { SpyInstance, afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CoreContainer } from '../../src/core/ioc/container';
-import { DefaultLogging } from '../../src/core';
-import { faker } from '@faker-js/faker';
-import { commandModule } from '../../src';
-import * as Id from '../../src/core/id';
-import { CommandMeta } from '../../src/types/core-modules';
-
-describe('services', () => {
-    //@ts-ignore
-    let container: CoreContainer<Dependencies>;
-    let consoleMock: SpyInstance;
-    beforeEach(() => {
-        container = new CoreContainer();
-        container.add({ '@sern/logger': () => new DefaultLogging() });
-        container.ready();
-        consoleMock = vi.spyOn(container.get('@sern/logger'), 'error').mockImplementation(() => {});
-    });
-
-    afterAll(() => {
-        consoleMock.mockReset();
-    });
-    it('module-store.ts', async () => {
-        function createRandomCommandModules() {
-            return commandModule({
-                type: faker.number.int({ min: 1 << 0, max: 1 << 10 }),
-                description: faker.string.alpha(),
-                name: faker.string.alpha(),
-                execute: () => {},
-            });
-        }
-
-        const modules = faker.helpers.multiple(createRandomCommandModules, {
-            count: 40,
-        });
-
-        const paths = faker.helpers
-            .multiple(faker.system.directoryPath, { count: 40 })
-            .map((path, i) => `${path}/${modules[i]}.js`);
-
-        const metadata: CommandMeta[] = modules.map((cm, i) => ({
-            id: Id.create(cm.name!, cm.type),
-            isClass: false,
-            fullPath: `${paths[i]}/${cm.name}.js`,
-        }));
-        const moduleManager = container.get('@sern/modules');
-        let i = 0;
-        for (const m of modules) {
-            moduleManager.set(Id.create(m.name!, m.type), paths[i]);
-            moduleManager.setMetadata(m, metadata[i]);
-            i++;
-        }
-        for (const m of modules) {
-            expect(moduleManager.getMetadata(m), 'module references do not exist').toBeDefined();
-        }
-    });
-
-    //todo add more
-    it('error-handling', () => {
-        const errorHandler = container.get('@sern/errors');
-        const lifetime = errorHandler.keepAlive;
-        for (let i = 0; i < lifetime; i++) {
-            if (i == lifetime - 1) {
-                expect(() => errorHandler.updateAlive(new Error('poo'))).toThrowError();
-            } else {
-                expect(() => errorHandler.updateAlive(new Error('poo'))).not.toThrowError();
-            }
-        }
-    });
-    //todo add more, spy on every instance?
-    it('logger', () => {
-        container.get('@sern/logger').error({ message: 'error' });
-
-        expect(consoleMock).toHaveBeenCalledOnce();
-        expect(consoleMock).toHaveBeenLastCalledWith({ message: 'error' });
-    });
-
-
-    
-});

test/handlers.test.ts

@@ -0,0 +1,151 @@
+//@ts-nocheck
+import { beforeEach, describe, expect, vi, it, test } from 'vitest';
+import { callInitPlugins, eventDispatcher } from '../src/handlers/event-utils';
+
+import { Client, ChatInputCommandInteraction } from 'discord.js'
+import { faker } from '@faker-js/faker';
+import { Module } from '../src/types/core-modules';
+import { Processed } from '../src/types/core-modules';
+import { EventEmitter } from 'events';
+import { EventType } from '../src/core/structures/enums';
+import { CommandControlPlugin, CommandInitPlugin, CommandType, controller } from '../src';
+
+vi.mock('discord.js', async (importOriginal) => {
+    const mod = await importOriginal()
+    const ModalSubmitInteraction = class {
+        customId;
+        type = 5;
+        isModalSubmit = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const ButtonInteraction = class {
+        customId;
+        type = 3;
+        componentType = 2;
+        isButton = vi.fn();
+        constructor(customId) {
+            this.customId = customId;
+        }
+    };
+    const AutocompleteInteraction = class {
+        type = 4;
+        option: string;
+        constructor(s: string) {
+            this.option = s;
+        }
+        options = {
+            getFocused: vi.fn(),
+            getSubcommand: vi.fn(),
+        };
+    };
+
+    return {
+        Client : vi.fn(),
+        Collection: mod.Collection,
+        ComponentType: mod.ComponentType,
+        InteractionType: mod.InteractionType,
+        ApplicationCommandOptionType: mod.ApplicationCommandOptionType,
+        ApplicationCommandType: mod.ApplicationCommandType, 
+        ModalSubmitInteraction,
+        ButtonInteraction,
+        AutocompleteInteraction,
+        ChatInputCommandInteraction: vi.fn()
+    };
+});
+
+function createRandomPlugin (s: 'go', mut?: Partial<Module>) {
+    return CommandInitPlugin(({ module }) => {
+        if(mut) {
+            Object.entries(mut).forEach(([k, v]) => {
+                module[k] = v
+            })
+        }
+        return  s == 'go'
+            ? controller.next()
+            : controller.stop()
+    })
+}
+function createRandomModule(plugins: any[]): Processed<Module> {
+    return {
+        type: EventType.Discord,
+        meta: { id:"", absPath: "" },
+        description: faker.string.alpha(),
+        plugins, 
+        name: "cheese",
+        onEvent: [],
+        execute: vi.fn(),
+    };
+}
+
+function mockDeps() {
+   return {
+        '@sern/client': new Client(),
+        '@sern/emitter': new EventEmitter()
+   }
+}
+ 
+describe('eventDispatcher standard', () => {
+    let m: Processed<Module>;
+    let ee: EventEmitter;
+    beforeEach(() => {
+        ee = new EventEmitter();
+        m = createRandomModule();
+    });
+
+    it('should throw', () => {
+        expect(() => eventDispatcher(mockDeps(), m,  'not event emitter')).toThrowError();
+    });
+
+    it("Shouldn't throw", () => {
+        expect(() => eventDispatcher(mockDeps(), m, ee)).not.toThrowError();
+    });
+});
+
+test ('call init plugins', async () => {
+    const deps = mockDeps()
+    const plugins = createRandomPlugin('go', { name: "abc" })
+    const mod = createRandomModule([plugins])
+    const s = await callInitPlugins(mod, deps, false)
+    expect("abc").equal(s.name)
+})
+
+test('init plugins replace array', async () => {
+    const deps = mockDeps()
+    const plugins = createRandomPlugin('go', { opts: [] })
+    const plugins2 = createRandomPlugin('go', { opts: ['a'] })
+    const mod = createRandomModule([plugins, plugins2])
+    const s = await callInitPlugins(mod, deps, false)
+    expect(['a']).deep.equal(s.opts)
+})
+
+test('call control plugin ', async () => {
+    const plugin = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next();
+    });
+    const res = await plugin.execute(new ChatInputCommandInteraction(), {})
+    expect(res.isOk()).toBe(true)
+})
+
+test('form sdt', async () => {
+
+    const expectedObject = { 
+        "plugin/abc": faker.person.jobArea(),
+        "plugin2/abc": faker.git.branch(),
+        "plugin3/cheese": faker.person.jobArea()
+    }
+    
+    const plugin = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin/abc": expectedObject['plugin/abc'] });
+    });
+    const plugin2 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin2/abc": expectedObject['plugin2/abc'] });
+    });
+    const plugin3 = CommandControlPlugin<CommandType.Slash>((ctx,sdt) => {
+        return controller.next({ "plugin3/cheese": expectedObject['plugin3/cheese'] });
+    });
+    
+})
+
+

test/handlers/dispatchers.test.ts

@@ -1,45 +0,0 @@
-import { beforeEach, describe, expect, vi, it } from 'vitest';
-import { createResultResolver, eventDispatcher } from '../../src/handlers/_internal';
-import { faker } from '@faker-js/faker';
-import { Module } from '../../src/core/types/modules';
-import { Processed } from '../../src/handlers/types';
-import { CommandType } from '../../src/core';
-import { EventEmitter } from 'events';
-
-function createRandomModule(): Processed<Module> {
-    return {
-        type: faker.number.int({
-            min: CommandType.Text,
-            max: CommandType.ChannelSelect,
-        }),
-        description: faker.string.alpha(),
-        name: faker.string.alpha(),
-        onEvent: [],
-        plugins: [],
-        execute: vi.fn(),
-    };
-}
-
-describe('eventDispatcher standard', () => {
-    let m: Processed<Module>;
-    let ee: EventEmitter;
-    beforeEach(() => {
-        ee = new EventEmitter();
-        m = createRandomModule();
-    });
-
-    it('should throw', () => {
-        expect(() => eventDispatcher(m,  'not event emitter')).toThrowError();
-    });
-    it("Shouldn't throw", () => {
-        expect(() => eventDispatcher(m, ee)).not.toThrowError();
-    });
-
-    it('Should be called once', () => {
-        const s = eventDispatcher(m,  ee);
-        s.subscribe();
-        ee.emit(m.name, faker.string.alpha());
-
-        expect(m.execute).toHaveBeenCalledOnce();
-    });
-});

test/handlers/id.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import * as Id from '../../src/core/id';
-import { faker } from '@faker-js/faker';
-import { CommandModule, CommandType, commandModule } from '../../src';
-
-function createRandomCommandModules() {
-    const randomCommandType = [
-        CommandType.Text,
-        CommandType.Both,
-        CommandType.CtxMsg,
-        CommandType.CtxUser,
-        CommandType.Modal,
-        CommandType.ChannelSelect,
-        CommandType.RoleSelect,
-        CommandType.UserSelect,
-        CommandType.StringSelect,
-        CommandType.Button,
-    ];
-    return commandModule({
-        type: faker.helpers.uniqueArray(randomCommandType, 1)[0],
-        description: faker.string.alpha(),
-        name: faker.string.alpha(),
-        execute: () => {},
-    });
-}
-function createMetadata(c: CommandModule) {
-    return {
-        fullPath: faker.system.filePath(),
-        id: Id.create(c.name, c.type),
-        isClass: Boolean(Math.floor(Math.random())),
-    };
-}
-const appBitField = 0b000000001111;
-
-describe('id resolution', () => {
-    it('should resolve application commands correctly', () => {
-        const modules = faker.helpers.multiple(createRandomCommandModules, {
-            count: 20,
-        });
-        const metadata = modules.map(createMetadata);
-        metadata.forEach((meta, idx) => {
-            const associatedModule = modules[idx];
-            const uid = Id.create(associatedModule.name!, associatedModule.type!);
-            expect(meta.id).toBe(uid);
-        });
-    });
-});

test/mockules/module.ts

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

test/mockules/ug/pass.ts

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

tsconfig.json

@@ -4,15 +4,17 @@
         "strict": true,
         "esModuleInterop": true,
         "strictNullChecks": true,
-        "moduleResolution": "node",
+        "moduleResolution": "node16",
         "skipLibCheck": true,
         "declaration": true,
         "preserveSymlinks": true,
         "allowSyntheticDefaultImports": true,
         "forceConsistentCasingInFileNames": true,
         "isolatedModules": true,
-        "module": "esnext",
+        "outDir": "dist",
-        "target": "esnext"
+        "module": "node16",
+        "target": "esnext",
+        "sourceMap": true
     },
     "exclude": ["node_modules", "dist"],
     "include": ["./src", "./src/**/*.d.ts"]

tsup.config.js

@@ -1,24 +0,0 @@
-import { defineConfig } from 'tsup';
-const shared = {
-    entry: ['src/index.ts'],
-    external: ['discord.js', 'iti'],
-    platform: 'node',
-    clean: true,
-    sourcemap: true,
-    treeshake: {
-        moduleSideEffects: false,
-        correctVarValueBeforeDeclaration: true, //need this to treeshake esm discord.js empty import
-        annotations: true,
-    },
-};
-export default defineConfig([
-    {
-        format: ['esm', 'cjs'],
-        target: 'node18',
-        tsconfig: './tsconfig.json',
-        outDir: './dist',
-        minify: false,
-        dts: true,
-        ...shared,
-    },
- ]);