seedcord 0.5.0 → 0.6.1

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 require('reflect-metadata');
 var services = require('@seedcord/services');
-var chalk4 = require('chalk');
+var chalk3 = require('chalk');
 var discord_js = require('discord.js');
 var envapt = require('envapt');
 var utils = require('@seedcord/utils');
@@ -29,74 +29,26 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
+var chalk3__default = /*#__PURE__*/_interopDefault(chalk3);
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var Plugin = class {
-  static {
-    __name(this, "Plugin");
-  }
-  pluggable;
-  constructor(pluggable) {
-    this.pluggable = pluggable;
-  }
-};
-var Pluggable = class _Pluggable {
-  static {
-    __name(this, "Pluggable");
-  }
-  isInitialized = false;
-  shutdown;
-  startup;
-  static PLUGIN_INIT_TIMEOUT_MS = 15e3;
-  constructor(shutdown, startup) {
-    this.shutdown = shutdown;
-    this.startup = startup;
-  }
-  async init() {
-    if (this.isInitialized) return this;
-    await this.startup.run();
-    this.isInitialized = true;
-    return this;
-  }
-  /**
-   * Attaches a plugin to this instance
-   *
-   * Plugins provide external functionality and are initialized during the specified startup phase.
-   * The plugin instance becomes available as a property in `core` wherever it's available.
-   *
-   * Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
-   *
-   * @typeParam Key - The property name for accessing the plugin
-   * @typeParam Ctor - The plugin constructor type
-   * @param key - Property name to access the plugin instance
-   * @param Plugin - Plugin constructor class
-   * @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
-   * @param args - Additional arguments to pass to the plugin constructor
-   * @returns This instance with the plugin attached as a typed property
-   * @throws An {@link Error} When called after initialization or if key already exists
-   * @example
-   * ```typescript
-   * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
-   * ```
-   */
-  attach(key, Plugin2, startupPhase, ...args) {
-    if (this.isInitialized) throw new Error("Cannot attach a plugin after initialization.");
-    if (this[key]) throw new Error(`Plugin with key "${key}" already exists.`);
-    const instance = new Plugin2(this, ...args);
-    const entry = {
-      [key]: instance
+
+// src/bot/decorators/Command.ts
+var CommandMetadataKey = Symbol("command:metadata");
+function RegisterCommand(scope, guilds = []) {
+  return (ctor) => {
+    const meta = scope === "global" ? {
+      scope
+    } : {
+      scope,
+      guilds
     };
-    this.startup.addTask(startupPhase, `Plugin:${key}`, async () => {
-      instance.logger.info(chalk4__default.default.bold("Initializing"));
-      await instance.init();
-      instance.logger.info(chalk4__default.default.bold("Initialized"));
-    }, _Pluggable.PLUGIN_INIT_TIMEOUT_MS);
-    return Object.assign(this, entry);
-  }
-};
+    Reflect.defineMetadata(CommandMetadataKey, meta, ctor);
+  };
+}
+__name(RegisterCommand, "RegisterCommand");
 function parseEnvColor(raw, fallback) {
   if (!raw) return fallback;
   const toHex = /* @__PURE__ */ __name((n) => `#${n.toString(16).padStart(6, "0")}`, "toHex");
@@ -134,6 +86,7 @@ var BuilderTypes = {
   modal: discord_js.ModalBuilder,
   label: discord_js.LabelBuilder,
   text_input: discord_js.TextInputBuilder,
+  file_upload: discord_js.FileUploadBuilder,
   // Action Row Components
   button: discord_js.ButtonBuilder,
   menu_string: discord_js.StringSelectMenuBuilder,
@@ -273,21 +226,6 @@ var CustomError = class extends Error {
   }
 };
 
-// src/bot/decorators/Command.ts
-var CommandMetadataKey = Symbol("command:metadata");
-function RegisterCommand(scope, guilds = []) {
-  return (ctor) => {
-    const meta = scope === "global" ? {
-      scope
-    } : {
-      scope,
-      guilds
-    };
-    Reflect.defineMetadata(CommandMetadataKey, meta, ctor);
-  };
-}
-__name(RegisterCommand, "RegisterCommand");
-
 // src/bot/controllers/CommandRegistry.ts
 var CommandRegistry = class {
   static {
@@ -304,9 +242,9 @@ var CommandRegistry = class {
   async init() {
     if (this.isInitialised) return;
     this.isInitialised = true;
-    this.logger.info(chalk4__default.default.bold(this.core.config.bot.commands.path));
+    this.logger.info(chalk3__default.default.bold(this.core.config.bot.commands.path));
     await this.loadCommands(this.core.config.bot.commands.path);
-    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.magenta.bold(this.globalCommands.length)} global, ${chalk4__default.default.magenta.bold(this.guildCommands.size)} guild groups`);
+    this.logger.info(`${chalk3__default.default.bold.green("Loaded")}: ${chalk3__default.default.magenta.bold(this.globalCommands.length)} global, ${chalk3__default.default.magenta.bold(this.guildCommands.size)} guild groups`);
   }
   async loadCommands(dir) {
     await utils.traverseDirectory(dir, (_full, rel, mod) => {
@@ -325,24 +263,24 @@ var CommandRegistry = class {
     const commandType = comp instanceof discord_js.SlashCommandBuilder ? "slash command" : "context menu command";
     if (meta.scope === "global") {
       this.globalCommands.push(comp);
-      this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(ctor.name)} from ${chalk4__default.default.gray(rel)}`);
-      this.logger.info(`  \u2192 Global ${commandType}: ${chalk4__default.default.bold.cyan(comp.name)}`);
+      this.logger.info(`${chalk3__default.default.italic("Registered")} ${chalk3__default.default.bold.yellow(ctor.name)} from ${chalk3__default.default.gray(rel)}`);
+      this.logger.info(`\u2192 Global ${commandType}: ${chalk3__default.default.bold.cyan(comp.name)}`);
     } else {
       for (const g of meta.guilds) {
         const arr = this.guildCommands.get(g) ?? [];
         arr.push(comp);
         this.guildCommands.set(g, arr);
       }
-      this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(ctor.name)} from ${chalk4__default.default.gray(rel)}`);
-      this.logger.info(`  \u2192 Guild ${commandType}: ${chalk4__default.default.bold.cyan(comp.name)} for ${chalk4__default.default.magenta.bold(meta.guilds.length)} guild(s)`);
+      this.logger.info(`${chalk3__default.default.italic("Registered")} ${chalk3__default.default.bold.yellow(ctor.name)} from ${chalk3__default.default.gray(rel)}`);
+      this.logger.info(`\u2192 Guild ${commandType}: ${chalk3__default.default.bold.cyan(comp.name)} for ${chalk3__default.default.magenta.bold(meta.guilds.length)} guild(s)`);
     }
   }
   async setCommands() {
     if (this.globalCommands.length > 0) {
       await this.core.bot.client.application?.commands.set(this.globalCommands);
       const tag = this.globalCommands.length === 1 ? "command" : "commands";
-      this.logger.info(`${chalk4__default.default.bold.green("Configured")} ${chalk4__default.default.magenta.bold(this.globalCommands.length)} global ${tag}`);
-      this.logger.info(` \u2192 ${this.globalCommands.map((command) => chalk4__default.default.bold.cyan(command.name)).join(", ")}`);
+      this.logger.info(`${chalk3__default.default.bold.green("Configured")} ${chalk3__default.default.magenta.bold(this.globalCommands.length)} global ${tag}`);
+      this.logger.info(`\u2192 ${this.globalCommands.map((command) => chalk3__default.default.bold.cyan(command.name)).join(", ")}`);
     }
     for (const [guildId, commands] of this.guildCommands.entries()) {
       const guild = this.core.bot.client.guilds.cache.get(guildId);
@@ -352,12 +290,62 @@ var CommandRegistry = class {
       }
       await guild.commands.set(commands);
       const tag = commands.length === 1 ? "command" : "commands";
-      this.logger.info(`${chalk4__default.default.bold.green("Configured")} ${chalk4__default.default.magenta.bold(commands.length)} ${tag} for guild ${chalk4__default.default.bold.yellow(guild.name)}`);
-      this.logger.info(` \u2192 ${commands.map((command) => chalk4__default.default.bold.cyan(command.name)).join(", ")}`);
+      this.logger.info(`${chalk3__default.default.bold.green("Configured")} ${chalk3__default.default.magenta.bold(commands.length)} ${tag} for guild ${chalk3__default.default.bold.yellow(guild.name)}`);
+      this.logger.info(` \u2192 ${commands.map((command) => chalk3__default.default.bold.cyan(command.name)).join(", ")}`);
     }
   }
 };
 
+// src/bot/decorators/Events.ts
+var EventMetadataKey = Symbol("event:metadata");
+function RegisterEvent(events, options) {
+  return function(constructor) {
+    const saved = Reflect.getMetadata(EventMetadataKey, constructor);
+    const existing = saved ?? [];
+    const toStore = Array.isArray(events) ? events : [
+      events
+    ];
+    const frequency = options?.frequency ?? "on";
+    const entries = toStore.map((event) => ({
+      event,
+      frequency
+    }));
+    Reflect.defineMetadata(EventMetadataKey, [
+      ...existing,
+      ...entries
+    ], constructor);
+  };
+}
+__name(RegisterEvent, "RegisterEvent");
+
+// src/bot/decorators/Middlewares.ts
+var MiddlewareType = /* @__PURE__ */ (function(MiddlewareType2) {
+  MiddlewareType2["Interaction"] = "middleware:interaction";
+  MiddlewareType2["Event"] = "middleware:event";
+  return MiddlewareType2;
+})({});
+var MiddlewareMetadataKey = Symbol("middleware:metadata");
+function Middleware(type, priority = 0, options = {}) {
+  return (ctor) => {
+    const normalizedPriority = Number(priority);
+    if (!Number.isFinite(normalizedPriority)) {
+      throw new TypeError("Middleware priority must be a finite number");
+    }
+    if (type === "middleware:interaction" && options.events?.length) {
+      throw new Error("Interaction middleware cannot specify event filters");
+    }
+    const metadata = {
+      priority: normalizedPriority,
+      type,
+      ...options.events ? {
+        events: options.events
+      } : {}
+    };
+    Reflect.defineMetadata(MiddlewareMetadataKey, metadata, ctor);
+  };
+}
+__name(Middleware, "Middleware");
+
 // src/interfaces/Handler.ts
 var BaseHandler = class {
   static {
@@ -457,51 +445,6 @@ function areRoutes(routes) {
 }
 __name(areRoutes, "areRoutes");
 
-// src/bot/decorators/Events.ts
-var EventMetadataKey = Symbol("event:metadata");
-function RegisterEvent(events) {
-  return function(constructor) {
-    const saved = Reflect.getMetadata(EventMetadataKey, constructor);
-    const existing = areRoutes(saved) ? saved : [];
-    const toStore = Array.isArray(events) ? events : [
-      events
-    ];
-    Reflect.defineMetadata(EventMetadataKey, [
-      ...existing,
-      ...toStore
-    ], constructor);
-  };
-}
-__name(RegisterEvent, "RegisterEvent");
-
-// src/bot/decorators/Middlewares.ts
-var MiddlewareType = /* @__PURE__ */ (function(MiddlewareType2) {
-  MiddlewareType2["Interaction"] = "middleware:interaction";
-  MiddlewareType2["Event"] = "middleware:event";
-  return MiddlewareType2;
-})({});
-var MiddlewareMetadataKey = Symbol("middleware:metadata");
-function Middleware(type, priority = 0, options = {}) {
-  return (ctor) => {
-    const normalizedPriority = Number(priority);
-    if (!Number.isFinite(normalizedPriority)) {
-      throw new TypeError("Middleware priority must be a finite number");
-    }
-    if (type === "middleware:interaction" && options.events?.length) {
-      throw new Error("Interaction middleware cannot specify event filters");
-    }
-    const metadata = {
-      priority: normalizedPriority,
-      type,
-      ...options.events ? {
-        events: options.events
-      } : {}
-    };
-    Reflect.defineMetadata(MiddlewareMetadataKey, metadata, ctor);
-  };
-}
-__name(Middleware, "Middleware");
-
 // src/bot/controllers/EventController.ts
 var EventController = class {
   static {
@@ -521,27 +464,27 @@ var EventController = class {
     }
     this.isInitialized = true;
     const handlersDir = this.core.config.bot.events.path;
-    this.logger.info(chalk4__default.default.bold(handlersDir));
+    this.logger.info(chalk3__default.default.bold(handlersDir));
     const middlewareDir = this.core.config.bot.events.middlewares;
     if (middlewareDir) {
-      this.logger.info(`${chalk4__default.default.bold(middlewareDir)} ${chalk4__default.default.gray("(middlewares)")}`);
+      this.logger.info(`${chalk3__default.default.bold(middlewareDir)} ${chalk3__default.default.gray("(middlewares)")}`);
       await this.loadMiddlewares(middlewareDir);
     }
     await this.loadHandlers(handlersDir);
     this.attachToClient();
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.middlewares.length)} middlewares`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.middlewares.length)} middlewares`);
     const loadedEventsArray = [];
     this.eventMap.forEach((handlers, eventName) => {
-      loadedEventsArray.push(`${chalk4__default.default.magenta.bold(handlers.length)} ${eventName}`);
+      loadedEventsArray.push(`${chalk3__default.default.magenta.bold(handlers.length)} ${eventName}`);
     });
-    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${this.eventMap.size > 0 ? loadedEventsArray.join(", ") : "none"}`);
+    this.logger.info(`${chalk3__default.default.bold.green("Loaded")}: ${this.eventMap.size > 0 ? loadedEventsArray.join(", ") : "none"}`);
   }
   async loadHandlers(dir) {
     await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
       for (const val of Object.values(imported)) {
         if (!this.isEventHandlerClass(val)) continue;
         this.registerHandler(val);
-        this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(val.name)} from ${chalk4__default.default.gray(relativePath)}`);
+        this.logger.info(`${chalk3__default.default.italic("Registered")} ${chalk3__default.default.bold.yellow(val.name)} from ${chalk3__default.default.gray(relativePath)}`);
       }
     }, this.logger);
   }
@@ -566,7 +509,7 @@ var EventController = class {
       } : {}
     });
     this.middlewares.sort((a, b) => a.priority - b.priority);
-    this.logger.info(`${chalk4__default.default.italic("Registered event middleware")} ${chalk4__default.default.bold.yellow(middlewareCtor.name)} ${chalk4__default.default.gray(`(priority ${metadata.priority})`)} from ${chalk4__default.default.gray(relativePath)}`);
+    this.logger.info(`${chalk3__default.default.italic("Registered event middleware")} ${chalk3__default.default.bold.yellow(middlewareCtor.name)} ${chalk3__default.default.gray(`(priority ${metadata.priority})`)} from ${chalk3__default.default.gray(relativePath)}`);
   }
   async runMiddlewares(eventName, args) {
     for (const { ctor, events } of this.middlewares) {
@@ -594,6 +537,21 @@ var EventController = class {
   }
   registerHandler(handlerClass) {
     const raw = Reflect.getMetadata(EventMetadataKey, handlerClass);
+    if (Array.isArray(raw)) {
+      for (const entry of raw) {
+        const key = entry.event;
+        let handlers = this.eventMap.get(key);
+        if (!handlers) {
+          handlers = [];
+          this.eventMap.set(key, handlers);
+        }
+        handlers.push({
+          ctor: handlerClass,
+          frequency: entry.frequency
+        });
+      }
+      return;
+    }
     const names = areRoutes(raw) ? raw : typeof raw === "string" ? [
       raw
     ] : [];
@@ -605,38 +563,47 @@ var EventController = class {
         handlers = [];
         this.eventMap.set(key, handlers);
       }
-      handlers.push(handlerClass);
+      handlers.push({
+        ctor: handlerClass,
+        frequency: "on"
+      });
     }
   }
   attachToClient() {
-    for (const [eventName] of this.eventMap) {
-      this.logger.debug(`Attaching ${chalk4__default.default.bold.green(eventName)} to ${chalk4__default.default.bold.yellow(this.core.bot.client.user?.username)}`);
-      this.core.bot.client.on(eventName, (...args) => {
-        void (async () => {
-          await this.processEvent(eventName, args);
-        })();
-      });
+    for (const [eventName, handlerEntries] of this.eventMap) {
+      this.logger.debug(`Attaching ${chalk3__default.default.bold.green(eventName)} to ${chalk3__default.default.bold.yellow(this.core.bot.client.user?.username)}`);
+      for (const entry of handlerEntries) {
+        const register = entry.frequency === "once" ? this.core.bot.client.once.bind(this.core.bot.client) : this.core.bot.client.on.bind(this.core.bot.client);
+        register(eventName, (...args) => {
+          void (async () => {
+            await this.processEvent(eventName, args, entry.ctor);
+          })();
+        });
+      }
     }
   }
-  async processEvent(eventName, args) {
+  async processEvent(eventName, args, specificHandler) {
     const shouldContinue = await this.runMiddlewares(eventName, args);
     if (!shouldContinue) return;
-    const handlerCtors = this.eventMap.get(eventName);
-    if (!handlerCtors || handlerCtors.length === 0) return;
-    for (const HandlerCtor of handlerCtors) {
-      try {
-        this.logger.debug(`Processing ${chalk4__default.default.bold.green(eventName)} with ${chalk4__default.default.gray(HandlerCtor.name)}`);
-        const handler = new HandlerCtor(args, this.core);
-        if (handler.hasChecks()) {
-          await handler.runChecks();
-        }
-        if (handler.shouldBreak()) return;
-        if (!handler.hasErrors()) {
-          await handler.execute();
-        }
-      } catch (err) {
-        this.logger.error(`Error in event ${String(eventName)} handler ${HandlerCtor.name}:`, err);
-      }
+    if (specificHandler) {
+      await this.processHandler(eventName, specificHandler, args);
+      return;
+    }
+    const handlerEntries = this.eventMap.get(eventName);
+    if (!handlerEntries || handlerEntries.length === 0) return;
+    for (const entry of handlerEntries) {
+      await this.processHandler(eventName, entry.ctor, args);
+    }
+  }
+  async processHandler(eventName, ctor, args) {
+    try {
+      this.logger.debug(`Processing ${chalk3__default.default.bold.green(eventName)} with ${chalk3__default.default.gray(ctor.name)}`);
+      const handler = new ctor(args, this.core);
+      if (handler.hasChecks()) await handler.runChecks();
+      if (handler.shouldBreak()) return;
+      if (!handler.hasErrors()) await handler.execute();
+    } catch (err) {
+      this.logger.error(`Error in event ${String(eventName)} handler ${ctor.name}:`, err);
     }
   }
 };
@@ -733,6 +700,26 @@ function storeMetadata(symbol, routes, constructor) {
   Reflect.defineMetadata(InteractionMetadataKey, true, constructor);
 }
 __name(storeMetadata, "storeMetadata");
+function buildSlashRoute(arg1, arg2, arg3) {
+  let command;
+  let sub;
+  let group;
+  if (typeof arg1 === "string") {
+    command = arg1;
+    sub = arg2;
+    group = arg3;
+  } else if (arg1 instanceof discord_js.ChatInputCommandInteraction || arg1 instanceof discord_js.AutocompleteInteraction) {
+    command = arg1.commandName;
+    group = arg1.options.getSubcommandGroup(false) ?? void 0;
+    sub = arg1.options.getSubcommand(false) ?? void 0;
+  } else {
+    throw new TypeError("Invalid argument passed to buildSlashRoute");
+  }
+  if (sub && group) return `${command}/${group}/${sub}`;
+  if (sub) return `${command}/${sub}`;
+  return command;
+}
+__name(buildSlashRoute, "buildSlashRoute");
 
 // src/bot/errors/Database.ts
 var DatabaseError = class extends CustomError {
@@ -898,26 +885,6 @@ _ts_decorate3([
   _ts_metadata3("design:paramtypes", []),
   _ts_metadata3("design:returntype", Promise)
 ], UnhandledEvent.prototype, "execute", null);
-function buildSlashRoute(arg1, arg2, arg3) {
-  let command;
-  let sub;
-  let group;
-  if (typeof arg1 === "string") {
-    command = arg1;
-    sub = arg2;
-    group = arg3;
-  } else if (arg1 instanceof discord_js.ChatInputCommandInteraction || arg1 instanceof discord_js.AutocompleteInteraction) {
-    command = arg1.commandName;
-    group = arg1.options.getSubcommandGroup(false) ?? void 0;
-    sub = arg1.options.getSubcommand(false) ?? void 0;
-  } else {
-    throw new TypeError("Invalid argument passed to buildSlashRoute");
-  }
-  if (sub && group) return `${command}/${group}/${sub}`;
-  if (sub) return `${command}/${sub}`;
-  return command;
-}
-__name(buildSlashRoute, "buildSlashRoute");
 
 // src/bot/controllers/InteractionController.ts
 var InteractionController = class {
@@ -951,34 +918,34 @@ var InteractionController = class {
     if (this.isInitialized) return;
     this.isInitialized = true;
     const handlersDir = this.core.config.bot.interactions.path;
-    this.logger.info(chalk4__default.default.bold(handlersDir));
+    this.logger.info(chalk3__default.default.bold(handlersDir));
     const middlewareDir = this.core.config.bot.interactions.middlewares;
     if (middlewareDir) {
-      this.logger.info(`${chalk4__default.default.bold(middlewareDir)} ${chalk4__default.default.gray("(middlewares)")}`);
+      this.logger.info(`${chalk3__default.default.bold(middlewareDir)} ${chalk3__default.default.gray("(middlewares)")}`);
       await this.loadMiddlewares(middlewareDir);
     }
     await this.loadHandlers(handlersDir);
     this.attachToClient();
-    this.logger.info(`${chalk4__default.default.bold.green("Loaded interaction handlers:")}`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.middlewares.length)} middlewares`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.slashMap.size)} slash commands`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.buttonMap.size)} buttons`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.modalMap.size)} modals`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.stringSelectMap.size)} string selects`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.userSelectMap.size)} user selects`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.roleSelectMap.size)} role selects`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.channelSelectMap.size)} channel selects`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.messageContextMenuMap.size)} message context menus`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.userContextMenuMap.size)} user context menus`);
-    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.autocompleteMap.size)} autocomplete`);
+    this.logger.info(`${chalk3__default.default.bold.green("Loaded interaction handlers:")}`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.middlewares.length)} middlewares`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.slashMap.size)} slash commands`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.buttonMap.size)} buttons`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.modalMap.size)} modals`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.stringSelectMap.size)} string selects`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.userSelectMap.size)} user selects`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.roleSelectMap.size)} role selects`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.channelSelectMap.size)} channel selects`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.messageContextMenuMap.size)} message context menus`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.userContextMenuMap.size)} user context menus`);
+    this.logger.info(`\u2192 ${chalk3__default.default.magenta.bold(this.autocompleteMap.size)} autocomplete`);
   }
   async loadHandlers(dir) {
     await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
       for (const val of Object.values(imported)) {
         if (!this.isHandlerClass(val)) continue;
         this.registerHandler(val);
-        this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(val.name)} from ${chalk4__default.default.gray(relativePath)}`);
+        this.logger.info(`${chalk3__default.default.italic("Registered")} ${chalk3__default.default.bold.yellow(val.name)} from ${chalk3__default.default.gray(relativePath)}`);
       }
     }, this.logger);
   }
@@ -1000,7 +967,7 @@ var InteractionController = class {
       priority: metadata.priority
     });
     this.middlewares.sort((a, b) => a.priority - b.priority);
-    this.logger.info(`${chalk4__default.default.italic("Registered middleware")} ${chalk4__default.default.bold.yellow(middlewareCtor.name)} ${chalk4__default.default.gray(`(priority ${metadata.priority})`)} from ${chalk4__default.default.gray(relativePath)}`);
+    this.logger.info(`${chalk3__default.default.italic("Registered middleware")} ${chalk3__default.default.bold.yellow(middlewareCtor.name)} ${chalk3__default.default.gray(`(priority ${metadata.priority})`)} from ${chalk3__default.default.gray(relativePath)}`);
   }
   isHandlerClass(obj) {
     if (typeof obj !== "function") return false;
@@ -1067,7 +1034,7 @@ var InteractionController = class {
   attachToClient() {
     this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
       this.handleInteraction(interaction).catch((err) => {
-        this.logger.error(`[${chalk4__default.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+        this.logger.error(`[${chalk3__default.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
       });
     });
   }
@@ -1098,10 +1065,10 @@ var InteractionController = class {
     }
     let HandlerCtor = getHandler(key);
     if (!HandlerCtor) {
-      this.logger.warn(`No handler found for key ${chalk4__default.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
+      this.logger.warn(`No handler found for key ${chalk3__default.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
       HandlerCtor = UnhandledEvent;
     }
-    this.logger.debug(`Processing ${chalk4__default.default.bold.green(key)} with ${chalk4__default.default.gray(HandlerCtor.name)}`);
+    this.logger.debug(`Processing ${chalk3__default.default.bold.green(key)} with ${chalk3__default.default.gray(HandlerCtor.name)}`);
     const handler = new HandlerCtor(interaction, this.core, args);
     if (handler.hasChecks()) await handler.runChecks();
     if (handler.shouldBreak()) return;
@@ -1185,6 +1152,69 @@ var InteractionController = class {
     await this.processInteraction(interaction, () => autocompleteKey, (key) => this.autocompleteMap.get(key));
   }
 };
+var Plugin = class {
+  static {
+    __name(this, "Plugin");
+  }
+  pluggable;
+  constructor(pluggable) {
+    this.pluggable = pluggable;
+  }
+};
+var Pluggable = class _Pluggable {
+  static {
+    __name(this, "Pluggable");
+  }
+  isInitialized = false;
+  shutdown;
+  startup;
+  static PLUGIN_INIT_TIMEOUT_MS = 15e3;
+  constructor(shutdown, startup) {
+    this.shutdown = shutdown;
+    this.startup = startup;
+  }
+  async init() {
+    if (this.isInitialized) return this;
+    await this.startup.run();
+    this.isInitialized = true;
+    return this;
+  }
+  /**
+   * Attaches a plugin to this instance
+   *
+   * Plugins provide external functionality and are initialized during the specified startup phase.
+   * The plugin instance becomes available as a property in `core` wherever it's available.
+   *
+   * Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
+   *
+   * @typeParam Key - The property name for accessing the plugin
+   * @typeParam Ctor - The plugin constructor type
+   * @param key - Property name to access the plugin instance
+   * @param Plugin - Plugin constructor class
+   * @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
+   * @param args - Additional arguments to pass to the plugin constructor
+   * @returns This instance with the plugin attached as a typed property
+   * @throws An {@link Error} When called after initialization or if key already exists
+   * @example
+   * ```typescript
+   * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
+   * ```
+   */
+  attach(key, Plugin2, startupPhase, ...args) {
+    if (this.isInitialized) throw new Error("Cannot attach a plugin after initialization.");
+    if (this[key]) throw new Error(`Plugin with key "${key}" already exists.`);
+    const instance = new Plugin2(this, ...args);
+    const entry = {
+      [key]: instance
+    };
+    this.startup.addTask(startupPhase, `Plugin:${key}`, async () => {
+      instance.logger.info(chalk3__default.default.bold("Initializing"));
+      await instance.init();
+      instance.logger.info(chalk3__default.default.bold("Initialized"));
+    }, _Pluggable.PLUGIN_INIT_TIMEOUT_MS);
+    return Object.assign(this, entry);
+  }
+};
 var EmojiInjector = class {
   static {
     __name(this, "EmojiInjector");
@@ -1196,7 +1226,7 @@ var EmojiInjector = class {
   }
   async init() {
     if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
-      this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.magenta.bold("0")} emojis`);
+      this.logger.info(`${chalk3__default.default.bold.green("Loaded")}: ${chalk3__default.default.magenta.bold("0")} emojis`);
       return;
     }
     const configEmojis = this.core.config.bot.emojis;
@@ -1207,10 +1237,10 @@ var EmojiInjector = class {
       if (emoji) {
         configEmojis[key] = `<${emoji.identifier}>`;
         foundCount++;
-        this.logger.debug(`${chalk4__default.default.bold.green("Found")}: ${chalk4__default.default.magenta.bold(emojiName)} (${emoji.id})`);
+        this.logger.debug(`${chalk3__default.default.bold.green("Found")}: ${chalk3__default.default.magenta.bold(emojiName)} (${emoji.id})`);
       }
     });
-    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.magenta.bold(foundCount)} emojis`);
+    this.logger.info(`${chalk3__default.default.bold.green("Loaded")}: ${chalk3__default.default.magenta.bold(foundCount)} emojis`);
   }
 };
 
@@ -1276,7 +1306,7 @@ var Bot = class extends Plugin {
    */
   async login() {
     await this._client.login(this.botToken);
-    this.logger.info(`Logged in as ${chalk4__default.default.bold.magenta(this._client.user?.username)}!`);
+    this.logger.info(`Logged in as ${chalk3__default.default.bold.magenta(this._client.user?.username)}!`);
     return this;
   }
   /**
@@ -1284,7 +1314,7 @@ var Bot = class extends Plugin {
    */
   async logout() {
     await this._client.destroy();
-    this.logger.info(chalk4__default.default.bold.red("Logged out of Discord!"));
+    this.logger.info(chalk3__default.default.bold.red("Logged out of Discord!"));
   }
   get client() {
     return this._client;
@@ -1302,14 +1332,18 @@ _ts_decorate4([
 
 // src/effects/decorators/RegisterEffect.ts
 var EffectMetadataKey = Symbol("effect:metadata");
-function RegisterEffect(effect) {
+function RegisterEffect(effect, options) {
   return function(constructor) {
-    Reflect.defineMetadata(EffectMetadataKey, effect, constructor);
+    const meta = {
+      effect,
+      frequency: options?.frequency
+    };
+    Reflect.defineMetadata(EffectMetadataKey, meta, constructor);
   };
 }
 __name(RegisterEffect, "RegisterEffect");
 
-// src/effects/interfaces/EffectsHandler.ts
+// src/effects/EffectsHandler.ts
 var EffectsHandler = class {
   static {
     __name(this, "EffectsHandler");
@@ -1330,7 +1364,7 @@ var EffectsHandler = class {
   }
 };
 
-// src/effects/interfaces/abstracts/WebhookLog.ts
+// src/effects/bases/WebhookLog.ts
 var WebhookLog = class extends EffectsHandler {
   static {
     __name(this, "WebhookLog");
@@ -1506,51 +1540,56 @@ var EffectsRegistry = class extends Plugin {
     if (this.isInitialized) return;
     this.isInitialized = true;
     const effectsDir = this.core.config.effects.path;
-    this.logger.info(chalk4__default.default.bold(effectsDir));
-    this.registerEffect("unknownException", exports.UnknownException);
+    this.logger.info(chalk3__default.default.bold(effectsDir));
+    this.registerEffect(exports.UnknownException, {
+      effect: "unknownException",
+      frequency: "on"
+    });
     await this.loadEffects(effectsDir);
     this.attachEffects();
     const totalEffects = Array.from(this.effectsMap.values()).reduce((acc, handlers) => acc + handlers.length, 0);
-    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.bold.magenta(totalEffects)} side effects`);
+    this.logger.info(`${chalk3__default.default.bold.green("Loaded")}: ${chalk3__default.default.bold.magenta(totalEffects)} side effects`);
   }
   async loadEffects(dir) {
     await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
       for (const exportName of Object.keys(imported)) {
         const val = imported[exportName];
         if (this.isEffectHandler(val)) {
-          const effectName = Reflect.getMetadata(EffectMetadataKey, val);
-          if (effectName) {
-            this.registerEffect(effectName, val);
-            this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(val.name)} from ${chalk4__default.default.gray(relativePath)}`);
-          }
+          const meta = Reflect.getMetadata(EffectMetadataKey, val);
+          this.registerEffect(val, meta);
+          this.logger.info(`${chalk3__default.default.italic("Registered")} ${chalk3__default.default.bold.yellow(val.name)} from ${chalk3__default.default.gray(relativePath)}`);
         }
       }
     }, this.logger);
   }
-  registerEffect(effectName, handler) {
-    let handlers = this.effectsMap.get(effectName);
+  registerEffect(handler, options) {
+    let handlers = this.effectsMap.get(options.effect);
     if (!handlers) {
       handlers = [];
-      this.effectsMap.set(effectName, handlers);
+      this.effectsMap.set(options.effect, handlers);
     }
-    handlers.push(handler);
+    handlers.push({
+      ctor: handler,
+      frequency: options.frequency ?? "on"
+    });
   }
   isEffectHandler(obj) {
     if (typeof obj !== "function") return false;
-    return obj.prototype instanceof EffectsHandler;
+    return obj.prototype instanceof EffectsHandler && Reflect.hasMetadata(EffectMetadataKey, obj);
   }
   attachEffects() {
-    for (const [effectName, handlerCtors] of this.effectsMap) {
-      this.emitter.on(effectName, (data) => {
-        for (const HandlerCtor of handlerCtors) {
+    for (const [effectName, handlerEntries] of this.effectsMap) {
+      for (const entry of handlerEntries) {
+        const register = entry.frequency === "once" ? this.emitter.once.bind(this.emitter) : this.emitter.on.bind(this.emitter);
+        register(effectName, (data) => {
           try {
-            const instance = new HandlerCtor(data, this.core);
+            const instance = new entry.ctor(data, this.core);
             void instance.execute();
           } catch (err) {
-            this.logger.error(`Error in side effect ${String(effectName)} handler ${HandlerCtor.name}:`, err);
+            this.logger.error(`Error in side effect ${String(effectName)} handler ${entry.ctor.name}:`, err);
           }
-        }
-      });
+        });
+      }
     }
   }
   emit(event, data) {
@@ -1602,19 +1641,19 @@ var Seedcord = class _Seedcord extends Pluggable {
    */
   registerStartupTasks() {
     this.startup.addTask(services.StartupPhase.Configuration, "Effect Initialization", async () => {
-      this.effects.logger.info(chalk4__default.default.bold("Initializing"));
+      this.effects.logger.info(chalk3__default.default.bold("Initializing"));
       await this.effects.init();
-      this.effects.logger.info(chalk4__default.default.bold("Initialized"));
+      this.effects.logger.info(chalk3__default.default.bold("Initialized"));
     });
     this.startup.addTask(services.StartupPhase.Instantiation, "Bot Initialization", async () => {
-      this.bot.logger.info(chalk4__default.default.bold("Initializing"));
+      this.bot.logger.info(chalk3__default.default.bold("Initializing"));
       await this.bot.init();
-      this.bot.logger.info(chalk4__default.default.bold("Initialized"));
+      this.bot.logger.info(chalk3__default.default.bold("Initialized"));
     });
     this.startup.addTask(services.StartupPhase.Ready, "Health Check", async () => {
-      this.healthCheck.logger.info(chalk4__default.default.bold("Initializing"));
+      this.healthCheck.logger.info(chalk3__default.default.bold("Initializing"));
       await this.healthCheck.init();
-      this.healthCheck.logger.info(chalk4__default.default.bold("Initialized"));
+      this.healthCheck.logger.info(chalk3__default.default.bold("Initialized"));
     });
   }
   /**