seedcord 0.4.3 → 0.5.0

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 require('reflect-metadata');
 var services = require('@seedcord/services');
-var chalk2 = require('chalk');
+var chalk4 = require('chalk');
 var discord_js = require('discord.js');
 var envapt = require('envapt');
 var utils = require('@seedcord/utils');
@@ -29,7 +29,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var chalk2__default = /*#__PURE__*/_interopDefault(chalk2);
+var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
 
 var __defProp = Object.defineProperty;
@@ -62,26 +62,26 @@ var Pluggable = class _Pluggable {
     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: ... })
-  * ```
-  */
+   * 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.`);
@@ -90,13 +90,27 @@ var Pluggable = class _Pluggable {
       [key]: instance
     };
     this.startup.addTask(startupPhase, `Plugin:${key}`, async () => {
-      instance.logger.info(chalk2__default.default.bold("Initializing"));
+      instance.logger.info(chalk4__default.default.bold("Initializing"));
       await instance.init();
-      instance.logger.info(chalk2__default.default.bold("Initialized"));
+      instance.logger.info(chalk4__default.default.bold("Initialized"));
     }, _Pluggable.PLUGIN_INIT_TIMEOUT_MS);
     return Object.assign(this, entry);
   }
 };
+function parseEnvColor(raw, fallback) {
+  if (!raw) return fallback;
+  const toHex = /* @__PURE__ */ __name((n) => `#${n.toString(16).padStart(6, "0")}`, "toHex");
+  const num = Number(raw);
+  if (!Number.isNaN(num) && num >= 0) return toHex(num);
+  if (raw.startsWith("#")) return raw;
+  if (/^[0-9A-Fa-f]{6}$/.test(raw)) return `#${raw}`;
+  const colorKey = Object.keys(discord_js.Colors).find((key) => key.toLowerCase() === raw.toLowerCase());
+  if (colorKey) return toHex(discord_js.Colors[colorKey]);
+  return fallback;
+}
+__name(parseEnvColor, "parseEnvColor");
+
+// src/interfaces/Components.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -109,8 +123,18 @@ function _ts_metadata(k, v) {
 }
 __name(_ts_metadata, "_ts_metadata");
 var BuilderTypes = {
+  // Command Components
   command: discord_js.SlashCommandBuilder,
+  context_menu: discord_js.ContextMenuCommandBuilder,
+  subcommand: discord_js.SlashCommandSubcommandBuilder,
+  group: discord_js.SlashCommandSubcommandGroupBuilder,
+  // Embed Components
   embed: discord_js.EmbedBuilder,
+  // Modal Components
+  modal: discord_js.ModalBuilder,
+  label: discord_js.LabelBuilder,
+  text_input: discord_js.TextInputBuilder,
+  // Action Row Components
   button: discord_js.ButtonBuilder,
   menu_string: discord_js.StringSelectMenuBuilder,
   menu_option_string: discord_js.StringSelectMenuOptionBuilder,
@@ -118,10 +142,7 @@ var BuilderTypes = {
   menu_channel: discord_js.ChannelSelectMenuBuilder,
   menu_mentionable: discord_js.MentionableSelectMenuBuilder,
   menu_role: discord_js.RoleSelectMenuBuilder,
-  modal: discord_js.ModalBuilder,
-  context_menu: discord_js.ContextMenuCommandBuilder,
-  subcommand: discord_js.SlashCommandSubcommandBuilder,
-  group: discord_js.SlashCommandSubcommandGroupBuilder,
+  // ComponentsV2
   container: discord_js.ContainerBuilder,
   text_display: discord_js.TextDisplayBuilder,
   file: discord_js.FileBuilder,
@@ -135,13 +156,9 @@ var RowTypes = {
   menu_user: discord_js.ActionRowBuilder,
   menu_channel: discord_js.ActionRowBuilder,
   menu_mentionable: discord_js.ActionRowBuilder,
-  menu_role: discord_js.ActionRowBuilder,
-  modal: discord_js.ActionRowBuilder
-};
-var ModalTypes = {
-  text: discord_js.TextInputBuilder
+  menu_role: discord_js.ActionRowBuilder
 };
-var BaseComponent = class BaseComponent2 {
+var BaseComponent = class {
   static {
     __name(this, "BaseComponent");
   }
@@ -151,26 +168,26 @@ var BaseComponent = class BaseComponent2 {
     this._component = new ComponentClass();
   }
   /**
-  * Gets the component instance for configuration
-  *
-  * Use this to access Discord.js builder methods like setTitle(), setDescription(), etc.
-  *
-  * Use this in your component classes to configure the builder
-  * @example this.instance.setTitle('My Modal')
-  */
+   * Gets the component instance for configuration
+   *
+   * Use this to access Discord.js builder methods like setTitle(), setDescription(), etc.
+   *
+   * Use this in your component classes to configure the builder
+   * @example this.instance.setTitle('My Modal')
+   */
   get instance() {
     return this._component;
   }
   /**
-  * Builds a customId string for interactive components
-  *
-  * Creates customIds in the format "prefix:arg1-arg2-arg3" for buttons, modals, etc.
-  * Arguments are joined with hyphens and separated from prefix with a colon.
-  *
-  * @param prefix - The route prefix that handlers will match against
-  * @param args - Additional arguments to encode in the customId
-  * @returns Formatted customId string
-  */
+   * Builds a customId string for interactive components
+   *
+   * Creates customIds in the format `prefix:arg1-arg2-arg3` for buttons, modals, etc.
+   * Arguments are joined with hyphens and separated from prefix with a colon.
+   *
+   * @param prefix - The route prefix that handlers will match against
+   * @param args - Additional arguments to encode in the customId
+   * @returns Formatted customId string
+   */
   buildCustomId(prefix, ...args) {
     if (args.length === 0) return prefix;
     return `${prefix}:${args.join("-")}`;
@@ -184,6 +201,9 @@ var BuilderComponent = class extends BaseComponent {
     const ComponentClass = BuilderTypes[type];
     super(ComponentClass);
     if (this.instance instanceof discord_js.EmbedBuilder) this.instance.setColor(this.botColor);
+    if (this.instance instanceof discord_js.ContainerBuilder) {
+      this.instance.setAccentColor(this.botColor === "Default" ? void 0 : utils.hexToNumber(this.botColor.toString()));
+    }
     if (this.instance instanceof discord_js.SlashCommandBuilder || this.instance instanceof discord_js.ContextMenuCommandBuilder) {
       this.instance.setContexts(discord_js.InteractionContextType.Guild);
     }
@@ -194,7 +214,8 @@ var BuilderComponent = class extends BaseComponent {
 };
 _ts_decorate([
   envapt.Envapt("DEFAULT_BOT_COLOR", {
-    fallback: "Default"
+    fallback: "Default",
+    converter: /* @__PURE__ */ __name((raw, fallback) => parseEnvColor(raw, fallback), "converter")
   }),
   _ts_metadata("design:type", typeof ColorResolvable === "undefined" ? Object : ColorResolvable)
 ], BuilderComponent.prototype, "botColor", void 0);
@@ -210,39 +231,13 @@ var RowComponent = class extends BaseComponent {
     return this.instance;
   }
 };
-var ModalRow = class ModalRow2 extends RowComponent {
-  static {
-    __name(this, "ModalRow");
-  }
-  /**
-  * Creates a new modal action row with the specified component.
-  *
-  * @param component - The modal field component to wrap in an action row
-  */
-  constructor(component) {
-    super("modal");
-    this.instance.addComponents(component);
-  }
-};
-var ModalComponent = class extends BaseComponent {
-  static {
-    __name(this, "ModalComponent");
-  }
-  constructor(type) {
-    const ComponentClass = ModalTypes[type];
-    super(ComponentClass);
-  }
-  get component() {
-    return new ModalRow(this.instance).component;
-  }
-};
 var BaseErrorEmbed = class extends BuilderComponent {
   static {
     __name(this, "BaseErrorEmbed");
   }
   /**
-  * Creates a new error embed with default configuration.
-  */
+   * Creates a new error embed with default configuration.
+   */
   constructor() {
     super("embed");
     this.instance.setTitle("Cannot Proceed");
@@ -260,27 +255,25 @@ var CustomError = class extends Error {
     Error.captureStackTrace(this, this.constructor);
   }
   /**
-  * Whether this error should be emitted to logs
-  *
-  * Controls logging behavior. Errors with emit=true will always be logged,
-  * while emit=false errors may be suppressed in production.
-  *
-  * @returns True if the error should be logged
-  */
+   * Whether this error should be emitted to logs
+   *
+   * Controls logging behavior. Errors with emit=true will always be logged,
+   * while emit=false errors may be suppressed in production.
+   *
+   * @returns True if the error should be logged
+   */
   get emit() {
     return this._emit;
   }
   /**
-  * Sets whether this error should be emitted to logs
-  *
-  * @see {@link emit}
-  */
+   * Sets whether this error should be emitted to logs
+   */
   set emit(value) {
     this._emit = value;
   }
 };
 
-// src/bot/decorators/CommandRegisterable.ts
+// src/bot/decorators/Command.ts
 var CommandMetadataKey = Symbol("command:metadata");
 function RegisterCommand(scope, guilds = []) {
   return (ctor) => {
@@ -311,9 +304,9 @@ var CommandRegistry = class {
   async init() {
     if (this.isInitialised) return;
     this.isInitialised = true;
-    this.logger.info(chalk2__default.default.bold(this.core.config.bot.commands.path));
+    this.logger.info(chalk4__default.default.bold(this.core.config.bot.commands.path));
     await this.loadCommands(this.core.config.bot.commands.path);
-    this.logger.info(`${chalk2__default.default.bold.green("Loaded")}: ${chalk2__default.default.magenta.bold(this.globalCommands.length)} global, ${chalk2__default.default.magenta.bold(this.guildCommands.size)} guild groups`);
+    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`);
   }
   async loadCommands(dir) {
     await utils.traverseDirectory(dir, (_full, rel, mod) => {
@@ -332,24 +325,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(`${chalk2__default.default.italic("Registered")} ${chalk2__default.default.bold.yellow(ctor.name)} from ${chalk2__default.default.gray(rel)}`);
-      this.logger.info(`  \u2192 Global ${commandType}: ${chalk2__default.default.bold.cyan(comp.name)}`);
+      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)}`);
     } else {
       for (const g of meta.guilds) {
         const arr = this.guildCommands.get(g) ?? [];
         arr.push(comp);
         this.guildCommands.set(g, arr);
       }
-      this.logger.info(`${chalk2__default.default.italic("Registered")} ${chalk2__default.default.bold.yellow(ctor.name)} from ${chalk2__default.default.gray(rel)}`);
-      this.logger.info(`  \u2192 Guild ${commandType}: ${chalk2__default.default.bold.cyan(comp.name)} for ${chalk2__default.default.magenta.bold(meta.guilds.length)} guild(s)`);
+      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)`);
     }
   }
   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(`${chalk2__default.default.bold.green("Configured")} ${chalk2__default.default.magenta.bold(this.globalCommands.length)} global ${tag}`);
-      this.logger.info(` \u2192 ${this.globalCommands.map((command) => chalk2__default.default.bold.cyan(command.name)).join(", ")}`);
+      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(", ")}`);
     }
     for (const [guildId, commands] of this.guildCommands.entries()) {
       const guild = this.core.bot.client.guilds.cache.get(guildId);
@@ -359,14 +352,14 @@ var CommandRegistry = class {
       }
       await guild.commands.set(commands);
       const tag = commands.length === 1 ? "command" : "commands";
-      this.logger.info(`${chalk2__default.default.bold.green("Configured")} ${chalk2__default.default.magenta.bold(commands.length)} ${tag} for guild ${chalk2__default.default.bold.yellow(guild.name)}`);
-      this.logger.info(` \u2192 ${commands.map((command) => chalk2__default.default.bold.cyan(command.name)).join(", ")}`);
+      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(", ")}`);
     }
   }
 };
 
 // src/interfaces/Handler.ts
-var BaseHandler = class BaseHandler2 {
+var BaseHandler = class {
   static {
     __name(this, "BaseHandler");
   }
@@ -397,19 +390,19 @@ var BaseHandler = class BaseHandler2 {
     return this.event;
   }
   /**
-  * Gets arguments parsed from interaction customId
-  *
-  * Arguments are extracted from customId using ":" and "-" separators.
-  * For customId "accept:user123-guild456", returns ["user123", "guild456"]
-  */
+   * Gets arguments parsed from interaction customId
+   *
+   * Arguments are extracted from customId using `:` and `-` separators.
+   * For customId `accept:user123-guild456`, returns `["user123", "guild456"]`
+   */
   getArgs() {
     return this.args;
   }
   /**
-  * Gets a specific argument by index from parsed customId
-  * @param index - Zero-based index of the argument to retrieve
-  * @returns The argument at the specified index, or undefined if not found
-  */
+   * Gets a specific argument by index from parsed customId
+   * @param index - Zero-based index of the argument to retrieve
+   * @returns The argument at the specified index, or undefined if not found
+   */
   getArg(index) {
     return this.args[index];
   }
@@ -430,11 +423,19 @@ var InteractionMiddleware = class extends BaseHandler {
     super(event, core, args);
   }
 };
+var EventMiddleware = class extends BaseHandler {
+  static {
+    __name(this, "EventMiddleware");
+  }
+  constructor(event, core, args) {
+    super(event, core, args);
+  }
+};
 var AutocompleteHandler = class extends BaseHandler {
   static {
     __name(this, "AutocompleteHandler");
   }
-  /** The currently focused autocomplete option (Based on what you set in \@AutocompleteRoute) */
+  /** The currently focused autocomplete option (Based on what you set in `@AutocompleteRoute`) */
   focused;
   constructor(event, core, args) {
     super(event, core, args);
@@ -450,15 +451,57 @@ var EventHandler = class extends BaseHandler {
   }
 };
 
-// src/bot/decorators/EventRegisterable.ts
+// src/miscellaneous/areRoutes.ts
+function areRoutes(routes) {
+  return Array.isArray(routes) && routes.every((r) => typeof r === "string");
+}
+__name(areRoutes, "areRoutes");
+
+// src/bot/decorators/Events.ts
 var EventMetadataKey = Symbol("event:metadata");
-function RegisterEvent(eventName) {
+function RegisterEvent(events) {
   return function(constructor) {
-    Reflect.defineMetadata(EventMetadataKey, eventName, 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 {
@@ -468,6 +511,7 @@ var EventController = class {
   logger = new services.Logger("Events");
   isInitialized = false;
   eventMap = new discord_js.Collection();
+  middlewares = [];
   constructor(core) {
     this.core = core;
   }
@@ -477,42 +521,96 @@ var EventController = class {
     }
     this.isInitialized = true;
     const handlersDir = this.core.config.bot.events.path;
-    this.logger.info(chalk2__default.default.bold(handlersDir));
+    this.logger.info(chalk4__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)")}`);
+      await this.loadMiddlewares(middlewareDir);
+    }
     await this.loadHandlers(handlersDir);
     this.attachToClient();
+    this.logger.info(`\u2192 ${chalk4__default.default.magenta.bold(this.middlewares.length)} middlewares`);
     const loadedEventsArray = [];
     this.eventMap.forEach((handlers, eventName) => {
-      loadedEventsArray.push(`${chalk2__default.default.magenta.bold(handlers.length)} ${eventName}`);
+      loadedEventsArray.push(`${chalk4__default.default.magenta.bold(handlers.length)} ${eventName}`);
     });
-    this.logger.info(`${chalk2__default.default.bold.green("Loaded")}: ${this.eventMap.size > 0 ? loadedEventsArray.join(", ") : "none"}`);
+    this.logger.info(`${chalk4__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)) {
-          this.registerHandler(val);
-          this.logger.info(`${chalk2__default.default.italic("Registered")} ${chalk2__default.default.bold.yellow(val.name)} from ${chalk2__default.default.gray(relativePath)}`);
-        }
+        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);
+  }
+  async loadMiddlewares(dir) {
+    await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
+      for (const val of Object.values(imported)) {
+        if (!this.isMiddlewareClass(val)) continue;
+        const metadata = Reflect.getMetadata(MiddlewareMetadataKey, val);
+        if (metadata?.type !== MiddlewareType.Event) continue;
+        this.registerMiddleware(val, metadata, relativePath);
       }
     }, this.logger);
   }
+  registerMiddleware(middlewareCtor, metadata, relativePath) {
+    const alreadyRegistered = this.middlewares.some((entry) => entry.ctor === middlewareCtor);
+    if (alreadyRegistered) return;
+    this.middlewares.push({
+      ctor: middlewareCtor,
+      priority: metadata.priority,
+      ...metadata.events ? {
+        events: metadata.events
+      } : {}
+    });
+    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)}`);
+  }
+  async runMiddlewares(eventName, args) {
+    for (const { ctor, events } of this.middlewares) {
+      if (events && !events.includes(eventName)) continue;
+      try {
+        const middleware = new ctor(args, this.core);
+        if (middleware.hasChecks()) await middleware.runChecks();
+        if (middleware.shouldBreak() || middleware.hasErrors()) return false;
+        await middleware.execute();
+        if (middleware.shouldBreak() || middleware.hasErrors()) return false;
+      } catch (err) {
+        this.logger.error(`Error in event middleware ${ctor.name} for event ${String(eventName)}:`, err);
+        return false;
+      }
+    }
+    return true;
+  }
   isEventHandlerClass(obj) {
     if (typeof obj !== "function") return false;
     return obj.prototype instanceof EventHandler && Reflect.hasMetadata(EventMetadataKey, obj);
   }
+  isMiddlewareClass(obj) {
+    if (typeof obj !== "function") return false;
+    return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+  }
   registerHandler(handlerClass) {
-    const eventName = Reflect.getMetadata(EventMetadataKey, handlerClass);
-    if (!eventName) return;
-    let handlers = this.eventMap.get(eventName);
-    if (!handlers) {
-      handlers = [];
-      this.eventMap.set(eventName, handlers);
+    const raw = Reflect.getMetadata(EventMetadataKey, handlerClass);
+    const names = areRoutes(raw) ? raw : typeof raw === "string" ? [
+      raw
+    ] : [];
+    if (names.length === 0) return;
+    for (const name of names) {
+      const key = name;
+      let handlers = this.eventMap.get(key);
+      if (!handlers) {
+        handlers = [];
+        this.eventMap.set(key, handlers);
+      }
+      handlers.push(handlerClass);
     }
-    handlers.push(handlerClass);
   }
   attachToClient() {
     for (const [eventName] of this.eventMap) {
-      this.logger.debug(`Attaching ${chalk2__default.default.bold.green(eventName)} to ${chalk2__default.default.bold.yellow(this.core.bot.client.user?.username)}`);
+      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);
@@ -521,11 +619,13 @@ var EventController = class {
     }
   }
   async processEvent(eventName, args) {
+    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 ${chalk2__default.default.bold.green(eventName)} with ${chalk2__default.default.gray(HandlerCtor.name)}`);
+        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();
@@ -541,7 +641,7 @@ var EventController = class {
   }
 };
 
-// src/bot/decorators/InteractionConfigurable.ts
+// src/bot/decorators/Interactions.ts
 var InteractionRoutes = /* @__PURE__ */ (function(InteractionRoutes2) {
   InteractionRoutes2["Slash"] = "interaction:slash";
   InteractionRoutes2["Button"] = "interaction:button";
@@ -621,9 +721,6 @@ function SelectMenuRoute(type, routeOrRoutes) {
 }
 __name(SelectMenuRoute, "SelectMenuRoute");
 function storeMetadata(symbol, routes, constructor) {
-  const areRoutes = /* @__PURE__ */ __name((routes2) => {
-    return Array.isArray(routes2) && routes2.every((r) => typeof r === "string");
-  }, "areRoutes");
   const savedRoutes = Reflect.getMetadata(symbol, constructor);
   const existing = areRoutes(savedRoutes) ? savedRoutes : [];
   const toStore = Array.isArray(routes) ? routes : [
@@ -644,11 +741,11 @@ var DatabaseError = class extends CustomError {
   }
   uuid;
   /**
-  * Creates a new DatabaseError.
-  *
-  * @param message - The error message describing what went wrong
-  * @param uuid - A unique identifier for this specific error instance
-  */
+   * Creates a new DatabaseError.
+   *
+   * @param message - The error message describing what went wrong
+   * @param uuid - A unique identifier for this specific error instance
+   */
   constructor(message, uuid) {
     super(message), this.uuid = uuid;
     this.emit = true;
@@ -658,69 +755,71 @@ var DatabaseError = class extends CustomError {
   }
 };
 
-// src/bot/utilities/ErrorHandlingUtils.ts
-var ErrorHandlingUtils = class {
-  static {
-    __name(this, "ErrorHandlingUtils");
-  }
-  static logger = new services.Logger("Errors");
-  /**
-  * Processes an error and extracts the standardized response, if available.
-  *
-  * Handles different error types (CustomError, DatabaseError) with appropriate
-  * logging, side effects, and user-facing error messages.
-  *
-  * @param error - The error to process
-  * @param core - The core framework instance
-  * @param guild - The guild where the error occurred (if any)
-  * @param user - The user who triggered the error (if any)
-  * @returns Object containing UUID and formatted error response embed
-  */
-  static extractErrorResponse(error, core, guild, user) {
-    const uuid = crypto2__namespace.randomUUID();
-    if (error instanceof CustomError) {
-      if (error instanceof DatabaseError) {
-        core.effects.emit("unknownException", {
-          uuid,
-          error,
-          guild,
-          user
-        });
-        this.logger.error(`DatabaseError: ${error.uuid}`);
-      } else if (error.emit) {
-        this.logger.error(`${error.name}: ${error.message}`, error);
-      }
-      return {
+// src/bot/utilities/errors/extractErrorResponse.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var logger = new services.Logger("ErrorsHandling");
+function extractErrorResponse(error, core, guild, user, metadata) {
+  const uuid = crypto2__namespace.randomUUID();
+  if (error instanceof CustomError) {
+    if (error instanceof DatabaseError) {
+      core.effects.emit("unknownException", {
         uuid,
-        response: error.response
-      };
+        error,
+        guild,
+        user,
+        metadata
+      });
+      logger.error(`DatabaseError: ${error.uuid}`);
+    } else if (error.emit) {
+      logger.error(`${error.name}: ${error.message}`, error);
     }
-    const showStack = core.config.bot.errorStack;
-    if (showStack) this.logger.error(uuid, error);
-    else this.logger.error(`${uuid} | ${error.message}`);
-    core.effects.emit("unknownException", {
-      uuid,
-      error,
-      guild,
-      user
-    });
     return {
       uuid,
-      response: new GenericError(uuid).response
+      response: error.response
     };
   }
-};
-var GenericError = class GenericError2 extends CustomError {
+  const showStack = core.config.bot.errorStack;
+  if (showStack) logger.error(uuid, error);
+  else logger.error(`${uuid} | ${error.message}`);
+  core.effects.emit("unknownException", {
+    uuid,
+    error,
+    guild,
+    user,
+    metadata
+  });
+  return {
+    uuid,
+    response: new GenericError(uuid).response
+  };
+}
+__name(extractErrorResponse, "extractErrorResponse");
+var GenericError = class extends CustomError {
   static {
     __name(this, "GenericError");
   }
   uuid;
+  developerUsername = "the developer";
   constructor(uuid) {
     super("An unknown error occurred"), this.uuid = uuid;
-    this.response.setTitle("Error").setDescription(`An unknown error occurred. Please reach out to the developer with a way to reproduce the error and the following:
+    this.response.setTitle("Error").setDescription(`An unknown error occurred. Please reach out to ${this.developerUsername} with a way to reproduce the error and the following:
 ### UUID: \`${this.uuid}\``);
   }
 };
+_ts_decorate2([
+  envapt.Envapt("DEVELOPER_DISCORD_USERNAME"),
+  _ts_metadata2("design:type", String)
+], GenericError.prototype, "developerUsername", void 0);
 
 // src/bot/decorators/Catchable.ts
 function Catchable(options) {
@@ -737,7 +836,7 @@ function Catchable(options) {
         if (!(error instanceof Error)) throw error;
         this.setErrored();
         if (log) console.error(error);
-        const { response } = ErrorHandlingUtils.extractErrorResponse(error, this.core, interaction.guild, interaction.user);
+        const { response } = extractErrorResponse(error, this.core, interaction.guild, interaction.user, interaction);
         const res = {
           embeds: [
             response
@@ -771,17 +870,17 @@ function Catchable(options) {
 __name(Catchable, "Catchable");
 
 // src/bot/defaults/UnhandledEvent.ts
-function _ts_decorate2(decorators, target, key, desc) {
+function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate2, "_ts_decorate");
-function _ts_metadata2(k, v) {
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata2, "_ts_metadata");
+__name(_ts_metadata3, "_ts_metadata");
 var UnhandledEvent = class extends InteractionHandler {
   static {
     __name(this, "UnhandledEvent");
@@ -793,12 +892,32 @@ var UnhandledEvent = class extends InteractionHandler {
     });
   }
 };
-_ts_decorate2([
+_ts_decorate3([
   Catchable(),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", Promise)
+  _ts_metadata3("design:type", Function),
+  _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 {
@@ -832,40 +951,66 @@ var InteractionController = class {
     if (this.isInitialized) return;
     this.isInitialized = true;
     const handlersDir = this.core.config.bot.interactions.path;
-    this.logger.info(chalk2__default.default.bold(handlersDir));
+    this.logger.info(chalk4__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)")}`);
+      await this.loadMiddlewares(middlewareDir);
+    }
     await this.loadHandlers(handlersDir);
     this.attachToClient();
-    this.logger.info(`${chalk2__default.default.bold.green("Loaded interaction handlers:")}`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.slashMap.size)} slash commands`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.buttonMap.size)} buttons`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.modalMap.size)} modals`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.stringSelectMap.size)} string selects`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.userSelectMap.size)} user selects`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.roleSelectMap.size)} role selects`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.channelSelectMap.size)} channel selects`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.messageContextMenuMap.size)} message context menus`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.userContextMenuMap.size)} user context menus`);
-    this.logger.info(`\u2192 ${chalk2__default.default.magenta.bold(this.autocompleteMap.size)} autocomplete`);
+    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`);
   }
   async loadHandlers(dir) {
     await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
       for (const val of Object.values(imported)) {
-        if (this.isHandlerClass(val)) {
-          this.registerHandler(val);
-          this.logger.info(`${chalk2__default.default.italic("Registered")} ${chalk2__default.default.bold.yellow(val.name)} from ${chalk2__default.default.gray(relativePath)}`);
-        }
+        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);
   }
+  async loadMiddlewares(dir) {
+    await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
+      for (const val of Object.values(imported)) {
+        if (!this.isMiddlewareClass(val)) continue;
+        const metadata = Reflect.getMetadata(MiddlewareMetadataKey, val);
+        if (metadata?.type !== MiddlewareType.Interaction) continue;
+        this.registerMiddleware(val, metadata, relativePath);
+      }
+    }, this.logger);
+  }
+  registerMiddleware(middlewareCtor, metadata, relativePath) {
+    const alreadyRegistered = this.middlewares.some((entry) => entry.ctor === middlewareCtor);
+    if (alreadyRegistered) return;
+    this.middlewares.push({
+      ctor: middlewareCtor,
+      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)}`);
+  }
   isHandlerClass(obj) {
     if (typeof obj !== "function") return false;
     return obj.prototype instanceof InteractionHandler && Reflect.hasMetadata(InteractionMetadataKey, obj) || obj.prototype instanceof AutocompleteHandler && Reflect.hasMetadata(InteractionMetadataKey, obj);
   }
+  isMiddlewareClass(obj) {
+    if (typeof obj !== "function") return false;
+    return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+  }
   registerHandler(handlerClass) {
-    const areRoutes = /* @__PURE__ */ __name((routes) => {
-      return Array.isArray(routes) && routes.every((r) => typeof r === "string");
-    }, "areRoutes");
     const routeTypes = [
       [
         InteractionRoutes.Slash,
@@ -922,7 +1067,7 @@ var InteractionController = class {
   attachToClient() {
     this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
       this.handleInteraction(interaction).catch((err) => {
-        this.logger.error(`[${chalk2__default.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+        this.logger.error(`[${chalk4__default.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
       });
     });
   }
@@ -944,17 +1089,19 @@ var InteractionController = class {
   async processInteraction(interaction, extractKey, getHandler, args) {
     const key = extractKey(interaction);
     if (this.keysToIgnore.has(key)) return;
-    for (const MiddlewareCtor of this.middlewares) {
-      const middleware = new MiddlewareCtor(interaction, this.core, args);
+    for (const { ctor } of this.middlewares) {
+      const middleware = new ctor(interaction, this.core, args);
+      if (middleware.hasChecks()) await middleware.runChecks();
+      if (middleware.shouldBreak() || middleware.hasErrors()) return;
       await middleware.execute();
-      if (middleware.hasErrors()) return;
+      if (middleware.shouldBreak() || middleware.hasErrors()) return;
     }
     let HandlerCtor = getHandler(key);
     if (!HandlerCtor) {
-      this.logger.warn(`No handler found for key ${chalk2__default.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
+      this.logger.warn(`No handler found for key ${chalk4__default.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
       HandlerCtor = UnhandledEvent;
     }
-    this.logger.debug(`Processing ${chalk2__default.default.bold.green(key)} with ${chalk2__default.default.gray(HandlerCtor.name)}`);
+    this.logger.debug(`Processing ${chalk4__default.default.bold.green(key)} with ${chalk4__default.default.gray(HandlerCtor.name)}`);
     const handler = new HandlerCtor(interaction, this.core, args);
     if (handler.hasChecks()) await handler.runChecks();
     if (handler.shouldBreak()) return;
@@ -1001,7 +1148,7 @@ var InteractionController = class {
     }
   }
   async handleSlashCommand(interaction) {
-    const route = this.buildSlashRoute(interaction);
+    const route = buildSlashRoute(interaction);
     await this.processInteraction(interaction, () => route, (key) => this.slashMap.get(key));
   }
   async handleButton(interaction) {
@@ -1032,26 +1179,11 @@ var InteractionController = class {
     await this.processInteraction(interaction, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
   }
   async handleAutocomplete(interaction) {
-    const route = this.buildSlashRoute(interaction);
+    const route = buildSlashRoute(interaction);
     const focused = interaction.options.getFocused(true);
     const autocompleteKey = `${route}:${focused.name}`;
     await this.processInteraction(interaction, () => autocompleteKey, (key) => this.autocompleteMap.get(key));
   }
-  // Build the route from commandName, subcommandGroup, subcommand
-  buildSlashRoute(interaction) {
-    const command = interaction.commandName;
-    const group = interaction.options.getSubcommandGroup(false);
-    const sub = interaction.options.getSubcommand(false);
-    let route = command;
-    if (group && sub) {
-      route = `${route}/${group}/${sub}`;
-    } else if (group) {
-      route = `${route}/${group}`;
-    } else if (sub) {
-      route = `${route}/${sub}`;
-    }
-    return route;
-  }
 };
 var EmojiInjector = class {
   static {
@@ -1064,7 +1196,7 @@ var EmojiInjector = class {
   }
   async init() {
     if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
-      this.logger.info(`${chalk2__default.default.bold.green("Loaded")}: ${chalk2__default.default.magenta.bold("0")} emojis`);
+      this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.magenta.bold("0")} emojis`);
       return;
     }
     const configEmojis = this.core.config.bot.emojis;
@@ -1075,25 +1207,25 @@ var EmojiInjector = class {
       if (emoji) {
         configEmojis[key] = `<${emoji.identifier}>`;
         foundCount++;
-        this.logger.debug(`${chalk2__default.default.bold.green("Found")}: ${chalk2__default.default.magenta.bold(emojiName)} (${emoji.id})`);
+        this.logger.debug(`${chalk4__default.default.bold.green("Found")}: ${chalk4__default.default.magenta.bold(emojiName)} (${emoji.id})`);
       }
     });
-    this.logger.info(`${chalk2__default.default.bold.green("Loaded")}: ${chalk2__default.default.magenta.bold(foundCount)} emojis`);
+    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.magenta.bold(foundCount)} emojis`);
   }
 };
 
 // src/bot/Bot.ts
-function _ts_decorate3(decorators, target, key, desc) {
+function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate3, "_ts_decorate");
-function _ts_metadata3(k, v) {
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata3, "_ts_metadata");
+__name(_ts_metadata4, "_ts_metadata");
 var Bot = class extends Plugin {
   static {
     __name(this, "Bot");
@@ -1106,10 +1238,6 @@ var Bot = class extends Plugin {
   events;
   commands;
   emojiInjector;
-  /**
-  * @param core - Seedcord core instance
-  * @internal
-  */
   constructor(core) {
     super(core), this.core = core;
     this._client = new discord_js.Client(core.config.bot.clientOptions);
@@ -1120,9 +1248,9 @@ var Bot = class extends Plugin {
     this.core.shutdown.addTask(services.ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop());
   }
   /**
-  * Initializes Discord client and all controllers
-  * @internal
-  */
+   * Initializes Discord client and all controllers
+   * @internal
+   */
   async init() {
     if (this.isInitialized) {
       return;
@@ -1136,40 +1264,40 @@ var Bot = class extends Plugin {
     await this.emojiInjector.init();
   }
   /**
-  * Stops the bot and cleans up connections
-  * @internal
-  */
+   * Stops the bot and cleans up connections
+   * @internal
+   */
   async stop() {
     this._client.removeAllListeners();
     await this.logout();
   }
   /**
-  * Logs the bot into Discord using the configured token
-  */
+   * Logs the bot into Discord using the configured token
+   */
   async login() {
     await this._client.login(this.botToken);
-    this.logger.info(`Logged in as ${chalk2__default.default.bold.magenta(this._client.user?.username)}!`);
+    this.logger.info(`Logged in as ${chalk4__default.default.bold.magenta(this._client.user?.username)}!`);
     return this;
   }
   /**
-  * Logs out and destroys the Discord client connection
-  */
+   * Logs out and destroys the Discord client connection
+   */
   async logout() {
     await this._client.destroy();
-    this.logger.info(chalk2__default.default.bold.red("Logged out of Discord!"));
+    this.logger.info(chalk4__default.default.bold.red("Logged out of Discord!"));
   }
   get client() {
     return this._client;
   }
 };
-_ts_decorate3([
+_ts_decorate4([
   envapt.Envapt("DISCORD_BOT_TOKEN", {
     converter(raw, _fallback) {
       if (typeof raw !== "string") throw new Error("Missing DISCORD_BOT_TOKEN");
       return raw;
     }
   }),
-  _ts_metadata3("design:type", String)
+  _ts_metadata4("design:type", String)
 ], Bot.prototype, "botToken", void 0);
 
 // src/effects/decorators/RegisterEffect.ts
@@ -1189,11 +1317,11 @@ var EffectsHandler = class {
   data;
   core;
   /**
-  * Creates a new effects handler instance.
-  *
-  * @param data - The effect event data
-  * @param core - The core framework instance
-  */
+   * Creates a new effects handler instance.
+   *
+   * @param data - The effect event data
+   * @param core - The core framework instance
+   */
   constructor(data, core) {
     this.data = data;
     this.core = core;
@@ -1213,35 +1341,55 @@ var WebhookLog = class extends EffectsHandler {
 };
 
 // src/effects/default/UnknownException.ts
-function _ts_decorate4(decorators, target, key, desc) {
+function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate4, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
-var UnknownException = class _UnknownException extends WebhookLog {
+__name(_ts_metadata5, "_ts_metadata");
+exports.UnknownException = class _UnknownException extends WebhookLog {
   static {
     __name(this, "UnknownException");
   }
+  static logger = new services.Logger("Effect: UnknownException");
   webhook = new discord_js.WebhookClient({
     url: _UnknownException.unknownExceptionWebhookUrl
   });
   async execute() {
-    await this.webhook.send({
-      username: "Unknown Exception",
-      avatarURL: "https://cdn.discordapp.com/attachments/1351446034827579466/1351446912947191830/warning-2.png",
-      embeds: [
-        new UnhandledErrorEmbed(this.data).component
-      ]
+    const metadataFile = this.prepareMetadataFile();
+    try {
+      await this.webhook.send({
+        flags: "IsComponentsV2",
+        withComponents: true,
+        username: "Unknown Exception",
+        avatarURL: "https://cdn.discordapp.com/attachments/1351446034827579466/1351446912947191830/warning-2.png",
+        components: [
+          new UnhandledErrorContainer(this.data).component
+        ],
+        files: metadataFile ? [
+          metadataFile
+        ] : []
+      });
+    } catch (error) {
+      _UnknownException.logger.error("Failed to send unknown exception webhook", error);
+    }
+  }
+  prepareMetadataFile() {
+    const { metadata } = this.data;
+    if (!metadata) return null;
+    const content = utils.filterCirculars(metadata);
+    return new discord_js.AttachmentBuilder(Buffer.from(JSON.stringify(content, void 0, 2), "utf-8"), {
+      name: "metadata.json",
+      description: "Metadata associated with the error"
     });
   }
 };
-_ts_decorate4([
+_ts_decorate5([
   envapt.Envapt("UNKNOWN_EXCEPTION_WEBHOOK_URL", {
     converter(raw, _fallback) {
       if (!raw) throw new Error("Missing UNKNOWN_EXCEPTION_WEBHOOK_URL");
@@ -1249,27 +1397,38 @@ _ts_decorate4([
       return raw;
     }
   }),
-  _ts_metadata4("design:type", String)
-], UnknownException, "unknownExceptionWebhookUrl", void 0);
-UnknownException = _ts_decorate4([
+  _ts_metadata5("design:type", String)
+], exports.UnknownException, "unknownExceptionWebhookUrl", void 0);
+exports.UnknownException = _ts_decorate5([
   RegisterEffect("unknownException")
-], UnknownException);
-var UnhandledErrorEmbed = class UnhandledErrorEmbed2 extends BuilderComponent {
+], exports.UnknownException);
+var DefaultSeparator = class DefaultSeparator2 extends BuilderComponent {
   static {
-    __name(this, "UnhandledErrorEmbed");
+    __name(this, "DefaultSeparator");
+  }
+  constructor() {
+    super("separator");
+    this.instance.setSpacing(discord_js.SeparatorSpacingSize.Small).setDivider(true);
+  }
+};
+var UnhandledErrorContainer = class UnhandledErrorContainer2 extends BuilderComponent {
+  static {
+    __name(this, "UnhandledErrorContainer");
   }
   constructor(data) {
-    super("embed");
-    const { uuid, error, guild, user } = data;
-    this.instance.setTitle(`An unknown exception was thrown`).setColor("#ef4860").setDescription(`**Guild ID:** \`${guild?.id ?? "Not used in a guild"}\`
+    super("container");
+    const { uuid, error, guild, user, metadata } = data;
+    this.instance.addTextDisplayComponents((text) => text.setContent(`### An unknown exception was thrown
+**Guild ID:** \`${guild?.id ?? "Not used in a guild"}\`
 **Guild Name:** ${guild?.name ?? "Not used in a guild"}
 **User ID:** \`${user?.id ?? "Missing user info"}\`
 **Username:** ${user?.username ?? "Missing user info"}
-### UUID: \`${uuid}\`
-\`\`\`${error.stack}\`\`\``);
-    this.setTimestampsIfAvailable(error);
+`)).addSeparatorComponents(new DefaultSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`
+\`\`\`${error.stack}\`\`\``));
+    this.addTimestampsIfAvailable(error);
+    this.addMetadataIfAvailable(metadata);
   }
-  setTimestampsIfAvailable(error) {
+  addTimestampsIfAvailable(error) {
     if (!(error instanceof discord_js.DiscordAPIError)) return;
     const now = Date.now();
     const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
@@ -1278,15 +1437,14 @@ var UnhandledErrorEmbed = class UnhandledErrorEmbed2 extends BuilderComponent {
     const diff = now - interactionTs;
     const seconds = Math.floor(diff / 1e3);
     const millis = diff % 1e3;
-    this.instance.addFields([
-      {
-        name: "Timestamps",
-        value: `- **\`Interaction sent\` :** ${new Date(interactionTs).toISOString()} (${interactionTs})
+    this.instance.addSeparatorComponents(new DefaultSeparator().component).addTextDisplayComponents((text) => text.setContent(`### Timestamps
+- **\`Interaction sent\` :** ${new Date(interactionTs).toISOString()} (${interactionTs})
 - **\`Error logged    \` :** ${new Date(now).toISOString()} (${now})
-- **\`Offset          \` :** ${seconds}s ${millis}ms`,
-        inline: true
-      }
-    ]);
+- **\`Offset          \` :** ${seconds}s ${millis}ms`));
+  }
+  addMetadataIfAvailable(metadata) {
+    if (!metadata) return;
+    this.instance.addSeparatorComponents(new DefaultSeparator().component).addTextDisplayComponents((text) => text.setContent("### Metadata")).addFileComponents((file) => file.setURL("attachment://metadata.json"));
   }
 };
 var EffectsEmitter = class {
@@ -1295,37 +1453,37 @@ var EffectsEmitter = class {
   }
   emitter = new events.EventEmitter();
   /**
-  * Registers a listener for the specified side effect.
-  *
-  * @typeParam KeyOfEffects - The side effect name type
-  * @param event - The side effect name to listen for
-  * @param listener - Function to call when the event is emitted
-  * @returns This EffectsEmitter instance for chaining
-  */
+   * Registers a listener for the specified side effect.
+   *
+   * @typeParam KeyOfEffects - The side effect name type
+   * @param event - The side effect name to listen for
+   * @param listener - Function to call when the event is emitted
+   * @returns This EffectsEmitter instance for chaining
+   */
   on(event, listener) {
     this.emitter.on(event, listener);
     return this;
   }
   /**
-  * Registers a one-time listener for the specified side effect.
-  *
-  * @typeParam KeyOfEffects - The side effect name type
-  * @param event - The side effect name to listen for once
-  * @param listener - Function to call when the event is emitted
-  * @returns This EffectsEmitter instance for chaining
-  */
+   * Registers a one-time listener for the specified side effect.
+   *
+   * @typeParam KeyOfEffects - The side effect name type
+   * @param event - The side effect name to listen for once
+   * @param listener - Function to call when the event is emitted
+   * @returns This EffectsEmitter instance for chaining
+   */
   once(event, listener) {
     this.emitter.once(event, listener);
     return this;
   }
   /**
-  * Emits a side effect with the provided data.
-  *
-  * @typeParam KeyOfEffects - The side effect name type
-  * @param event - The side effect name to emit
-  * @param data - The data to pass to registered listeners
-  * @returns True if the event had listeners, false otherwise
-  */
+   * Emits a side effect with the provided data.
+   *
+   * @typeParam KeyOfEffects - The side effect name type
+   * @param event - The side effect name to emit
+   * @param data - The data to pass to registered listeners
+   * @returns True if the event had listeners, false otherwise
+   */
   emit(event, data) {
     return this.emitter.emit(event, data);
   }
@@ -1348,12 +1506,12 @@ var EffectsRegistry = class extends Plugin {
     if (this.isInitialized) return;
     this.isInitialized = true;
     const effectsDir = this.core.config.effects.path;
-    this.logger.info(chalk2__default.default.bold(effectsDir));
-    this.registerEffect("unknownException", UnknownException);
+    this.logger.info(chalk4__default.default.bold(effectsDir));
+    this.registerEffect("unknownException", exports.UnknownException);
     await this.loadEffects(effectsDir);
     this.attachEffects();
     const totalEffects = Array.from(this.effectsMap.values()).reduce((acc, handlers) => acc + handlers.length, 0);
-    this.logger.info(`${chalk2__default.default.bold.green("Loaded")}: ${chalk2__default.default.bold.magenta(totalEffects)} side effects`);
+    this.logger.info(`${chalk4__default.default.bold.green("Loaded")}: ${chalk4__default.default.bold.magenta(totalEffects)} side effects`);
   }
   async loadEffects(dir) {
     await utils.traverseDirectory(dir, (_fullPath, relativePath, imported) => {
@@ -1363,7 +1521,7 @@ var EffectsRegistry = class extends Plugin {
           const effectName = Reflect.getMetadata(EffectMetadataKey, val);
           if (effectName) {
             this.registerEffect(effectName, val);
-            this.logger.info(`${chalk2__default.default.italic("Registered")} ${chalk2__default.default.bold.yellow(val.name)} from ${chalk2__default.default.gray(relativePath)}`);
+            this.logger.info(`${chalk4__default.default.italic("Registered")} ${chalk4__default.default.bold.yellow(val.name)} from ${chalk4__default.default.gray(relativePath)}`);
           }
         }
       }
@@ -1418,11 +1576,11 @@ var Seedcord = class _Seedcord extends Pluggable {
   /** @see {@link HealthCheck} */
   healthCheck;
   /**
-  * Creates a new Seedcord instance
-  *
-  * @param config - Bot configuration including paths and Discord client options
-  * @throws An {@link Error} When attempting to create multiple instances (singleton)
-  */
+   * Creates a new Seedcord instance
+   *
+   * @param config - Bot configuration including paths and Discord client options
+   * @throws An {@link Error} When attempting to create multiple instances (singleton)
+   */
   constructor(config) {
     const shutdown = new services.CoordinatedShutdown();
     const startup = new services.CoordinatedStartup();
@@ -1439,31 +1597,31 @@ var Seedcord = class _Seedcord extends Pluggable {
     this.registerStartupTasks();
   }
   /**
-  * Registers default startup tasks
-  * @internal
-  */
+   * Registers default startup tasks
+   * @internal
+   */
   registerStartupTasks() {
     this.startup.addTask(services.StartupPhase.Configuration, "Effect Initialization", async () => {
-      this.effects.logger.info(chalk2__default.default.bold("Initializing"));
+      this.effects.logger.info(chalk4__default.default.bold("Initializing"));
       await this.effects.init();
-      this.effects.logger.info(chalk2__default.default.bold("Initialized"));
+      this.effects.logger.info(chalk4__default.default.bold("Initialized"));
     });
     this.startup.addTask(services.StartupPhase.Instantiation, "Bot Initialization", async () => {
-      this.bot.logger.info(chalk2__default.default.bold("Initializing"));
+      this.bot.logger.info(chalk4__default.default.bold("Initializing"));
       await this.bot.init();
-      this.bot.logger.info(chalk2__default.default.bold("Initialized"));
+      this.bot.logger.info(chalk4__default.default.bold("Initialized"));
     });
     this.startup.addTask(services.StartupPhase.Ready, "Health Check", async () => {
-      this.healthCheck.logger.info(chalk2__default.default.bold("Initializing"));
+      this.healthCheck.logger.info(chalk4__default.default.bold("Initializing"));
       await this.healthCheck.init();
-      this.healthCheck.logger.info(chalk2__default.default.bold("Initialized"));
+      this.healthCheck.logger.info(chalk4__default.default.bold("Initialized"));
     });
   }
   /**
-  * Starts the bot and runs all initialization tasks
-  *
-  * @returns This Seedcord instance when fully initialized
-  */
+   * Starts the bot and runs all initialization tasks
+   *
+   * @returns This Seedcord instance when fully initialized
+   */
   async start() {
     await super.init();
     return this;
@@ -1493,7 +1651,7 @@ function EventCatchable(log) {
           this.getEvent()
         ];
         const msg = eventArgs.find((x) => x instanceof discord_js.Message);
-        const { response } = ErrorHandlingUtils.extractErrorResponse(err, this.core, msg?.guild ?? null, msg?.author ?? null);
+        const { response } = extractErrorResponse(err, this.core, msg?.guild ?? null, msg?.author ?? null, eventArgs);
         if (!msg) return;
         await msg.reply({
           embeds: [
@@ -1506,6 +1664,232 @@ function EventCatchable(log) {
   };
 }
 __name(EventCatchable, "EventCatchable");
+
+// src/bot/errors/Channels.ts
+var ChannelNotFoundError = class extends CustomError {
+  static {
+    __name(this, "ChannelNotFoundError");
+  }
+  channelId;
+  /**
+   * Creates a new ChannelNotFoundError.
+   *
+   * @param message - The error message
+   * @param channelId - The ID of the channel that could not be found
+   */
+  constructor(message, channelId) {
+    super(message), this.channelId = channelId;
+    this.response.setDescription(`Channel with ID \`${this.channelId}\` not found.`);
+  }
+};
+var CannotSendEmbedsError = class extends CustomError {
+  static {
+    __name(this, "CannotSendEmbedsError");
+  }
+  channelId;
+  /**
+   * Creates a new CannotSendEmbedsError.
+   *
+   * @param message - The error message
+   * @param channelId - The ID of the channel where embeds cannot be sent
+   */
+  constructor(message, channelId) {
+    super(message), this.channelId = channelId;
+    this.response.setDescription(`Cannot send embeds in <#${this.channelId}>.
+
+Please ensure I have the following permissions:
+\u2022 View Channel
+\u2022 Send Messages
+\u2022 Embed Links
+\u2022 Attach Files
+\u2022 Read Message History
+\u2022 Use External Emojis
+`);
+  }
+};
+var CouldNotFindChannel = class extends CustomError {
+  static {
+    __name(this, "CouldNotFindChannel");
+  }
+  channelId;
+  /**
+   * Creates a new CouldNotFindChannel error.
+   *
+   * @param message - The error message
+   * @param channelId - The ID of the channel that could not be found
+   */
+  constructor(message, channelId) {
+    super(message), this.channelId = channelId;
+    this.response.setDescription(`Could not find channel with ID \`${this.channelId}\`. It could also be that the channel is not a text channel.`);
+  }
+};
+var ChannelNotTextChannel = class extends CustomError {
+  static {
+    __name(this, "ChannelNotTextChannel");
+  }
+  channelId;
+  /**
+   * Creates a new ChannelNotTextChannel error.
+   *
+   * @param message - The error message
+   * @param channelId - The ID of the channel that is not a text channel
+   */
+  constructor(message, channelId) {
+    super(message), this.channelId = channelId;
+    this.response.setDescription(`Channel with ID \`${this.channelId}\` is not a text channel.`);
+  }
+};
+var MissingPermissions = class extends CustomError {
+  static {
+    __name(this, "MissingPermissions");
+  }
+  missingPerms;
+  roleOrChannel;
+  /**
+   * Creates a new BotMissingPermissionsError.
+   *
+   * @param message - The error message
+   * @param missingPerms - Array of missing permission names
+   * @param roleOrChannel - The role or channel where permissions are missing
+   */
+  constructor(message, missingPerms, roleOrChannel) {
+    super(message), this.missingPerms = missingPerms, this.roleOrChannel = roleOrChannel;
+    const missing = this.missingPerms.map((perm) => `\u2022 ${perm}`).join("\n");
+    const errorSubtext = this.roleOrChannel instanceof discord_js.Role ? `My role, <@&${this.roleOrChannel.id}>, is missing the following permissions:` : `I am missing the following permissions in <#${this.roleOrChannel.id}>:`;
+    this.response.setDescription(`${errorSubtext}
+
+Please ensure I have the following missing permission(s):
+${missing}`);
+  }
+};
+var RoleHigherThanMe = class extends CustomError {
+  static {
+    __name(this, "RoleHigherThanMe");
+  }
+  role;
+  botRole;
+  /**
+   * Creates a new RoleHigherThanMe error.
+   *
+   * @param message - The error message
+   */
+  constructor(message, role, botRole) {
+    super(message), this.role = role, this.botRole = botRole;
+    this.response.setDescription(`I cannot assign a role that is higher than me.
+
+The role <@&${this.role.id}> is higher than my role <@&${this.botRole.id}> in the hierarchy.`);
+  }
+};
+var CannotAssignBotRole = class extends CustomError {
+  static {
+    __name(this, "CannotAssignBotRole");
+  }
+  /**
+   * Creates a new CannotAssignBotRole error.
+   *
+   * @param message - The error message
+   */
+  constructor(message = "I cannot assign a managed role.") {
+    super(message);
+    this.response.setDescription("I cannot assign a managed role.");
+  }
+};
+var RoleDoesNotExist = class extends CustomError {
+  static {
+    __name(this, "RoleDoesNotExist");
+  }
+  roleId;
+  /**
+   * Creates a new RoleDoesNotExist error.
+   *
+   * @param message - The error message
+   * @param roleId - The ID of the role that doesn't exist
+   */
+  constructor(message, roleId) {
+    super(message), this.roleId = roleId;
+    this.response.setDescription(`The role with ID \`${this.roleId}\` does not exist.`);
+  }
+};
+var HasDangerousPermissions = class extends CustomError {
+  static {
+    __name(this, "HasDangerousPermissions");
+  }
+  role;
+  dangerousPerms;
+  /**
+   * Creates a new HasDangerousPermissions error.
+   *
+   * @param message - The error message
+   * @param role - The role with dangerous permissions
+   * @param dangerousPerms - Array of dangerous permission names
+   */
+  constructor(message, role, dangerousPerms) {
+    super(message), this.role = role, this.dangerousPerms = dangerousPerms;
+    const dangerous = this.dangerousPerms.map((perm) => `\u2022 ${perm}`).join("\n");
+    this.response.setDescription(`The role <@&${this.role.id}> has the following dangerous permissions:
+
+Please ensure the following dangerous permission(s) are not enabled:
+${dangerous}`);
+  }
+};
+
+// src/bot/errors/User.ts
+var UserNotInGuild = class extends CustomError {
+  static {
+    __name(this, "UserNotInGuild");
+  }
+  /**
+   * Creates a new UserNotInGuild error.
+   *
+   * @param message - The error message
+   */
+  constructor(message = "User is not in the guild.") {
+    super(message);
+    this.response.setDescription("User is not in the guild.");
+  }
+};
+var UserNotFound = class extends CustomError {
+  static {
+    __name(this, "UserNotFound");
+  }
+  userArg;
+  /**
+   * Creates a new UserNotFound error.
+   *
+   * @param userArg - The user argument that could not be resolved
+   */
+  constructor(userArg) {
+    super(`User not found: ${userArg}`), this.userArg = userArg;
+    this.response.setTitle("User Not Found").setDescription(`User probably doesn't exist or was deleted.
+**User Argument:** \`${this.userArg}\`
+Please check the user ID and try again. Only pass valid user IDs as the argument.`);
+  }
+};
+async function fetchText(client, channelId) {
+  if (channelId instanceof discord_js.TextChannel) {
+    return channelId;
+  }
+  let channel = client.channels.cache.get(channelId);
+  if (!channel) {
+    try {
+      channel = await client.channels.fetch(channelId);
+    } catch {
+      throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
+    }
+  }
+  if (channel?.isTextBased()) {
+    return channel;
+  }
+  throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
+}
+__name(fetchText, "fetchText");
+
+// src/bot/utilities/channels/sendInText.ts
+async function sendInText(client, channelId, message) {
+  const channel = await fetchText(client, channelId);
+  return await channel.send(message);
+}
+__name(sendInText, "sendInText");
 function throwCustomError(error, message, CustomError2) {
   const uuid = crypto.randomUUID();
   services.Logger.Error("Throwing Custom Error", error.name);
@@ -1522,43 +1906,343 @@ function throwCustomError(error, message, CustomError2) {
 }
 __name(throwCustomError, "throwCustomError");
 
+// src/bot/utilities/messages/attemptSendDM.ts
+async function attemptSendDM(user, content) {
+  const payload = {
+    ...content.content !== void 0 && {
+      content: content.content
+    },
+    ...content.embeds !== void 0 && {
+      embeds: [
+        ...content.embeds
+      ]
+    },
+    ...content.components !== void 0 && {
+      components: [
+        ...content.components
+      ]
+    }
+  };
+  try {
+    return await user.send(payload);
+  } catch {
+    return null;
+  }
+}
+__name(attemptSendDM, "attemptSendDM");
+var PermissionNames = new Map(Object.entries(discord_js.PermissionFlagsBits).map(([key, bit]) => [
+  bit,
+  utils.prettify(key)
+]));
+var PERM_GROUPS = {
+  manage: /* @__PURE__ */ new Map([
+    [
+      discord_js.PermissionFlagsBits.ManageChannels,
+      "Manage Channels"
+    ],
+    [
+      discord_js.PermissionFlagsBits.ManageRoles,
+      "Manage Roles"
+    ],
+    [
+      discord_js.PermissionFlagsBits.ManageWebhooks,
+      "Manage Webhooks"
+    ],
+    [
+      discord_js.PermissionFlagsBits.ManageMessages,
+      "Manage Messages"
+    ],
+    [
+      discord_js.PermissionFlagsBits.ManageNicknames,
+      "Manage Nicknames"
+    ]
+  ]),
+  embed: /* @__PURE__ */ new Map([
+    [
+      discord_js.PermissionFlagsBits.ViewChannel,
+      "View Channel"
+    ],
+    [
+      discord_js.PermissionFlagsBits.SendMessages,
+      "Send Messages"
+    ],
+    [
+      discord_js.PermissionFlagsBits.EmbedLinks,
+      "Embed Links"
+    ],
+    [
+      discord_js.PermissionFlagsBits.AttachFiles,
+      "Attach Files"
+    ],
+    [
+      discord_js.PermissionFlagsBits.UseExternalEmojis,
+      "Use External Emojis"
+    ],
+    [
+      discord_js.PermissionFlagsBits.ReadMessageHistory,
+      "Read Message History"
+    ]
+  ]),
+  others: /* @__PURE__ */ new Map([
+    [
+      discord_js.PermissionFlagsBits.AddReactions,
+      "Add Reactions"
+    ],
+    [
+      discord_js.PermissionFlagsBits.UseApplicationCommands,
+      "Use Application Commands"
+    ]
+  ])
+};
+function checkPermissions(client, roleOrChannel, scope = "all", inverse = false) {
+  let required;
+  if (Array.isArray(scope)) {
+    required = /* @__PURE__ */ new Map();
+    for (const bit of scope) {
+      const name = PermissionNames.get(bit);
+      if (name) required.set(bit, name);
+    }
+  } else {
+    switch (scope) {
+      case "manage":
+        required = PERM_GROUPS.manage;
+        break;
+      case "embed":
+        required = PERM_GROUPS.embed;
+        break;
+      case "others":
+        required = new Map([
+          ...PERM_GROUPS.others,
+          ...PERM_GROUPS.embed
+        ]);
+        break;
+      default:
+        required = new Map([
+          ...PERM_GROUPS.manage,
+          ...PERM_GROUPS.others,
+          ...PERM_GROUPS.embed
+        ]);
+        break;
+    }
+  }
+  let permissions;
+  if (roleOrChannel instanceof discord_js.Role) {
+    permissions = roleOrChannel.permissions;
+  } else {
+    if (!client.user) throw new Error("Client user is not available");
+    permissions = roleOrChannel.permissionsFor(client.user, true);
+  }
+  if (!permissions) {
+    throw new MissingPermissions("Missing Permissions", Array.from(required.values()), roleOrChannel);
+  }
+  if (inverse) {
+    const dangerous = Array.from(required.entries()).filter(([bit]) => permissions.has(bit, true)).map(([, name]) => name);
+    if (dangerous.length > 0) {
+      throw new HasDangerousPermissions("Role has dangerous permissions", roleOrChannel, dangerous);
+    }
+  } else {
+    const missing = Array.from(required.entries()).filter(([bit]) => !permissions.has(bit, true)).map(([, name]) => name);
+    if (missing.length > 0) {
+      throw new MissingPermissions("Missing Permissions", missing, roleOrChannel);
+    }
+  }
+}
+__name(checkPermissions, "checkPermissions");
+
+// src/bot/utilities/roles/getBotRole.ts
+function getBotRole(client, guild) {
+  if (!client.user) throw new Error("Client user is not available");
+  const botRole = guild.roles.botRoleFor(client.user);
+  if (!botRole) throw new Error("Bot role not found in guild");
+  return botRole;
+}
+__name(getBotRole, "getBotRole");
+
+// src/bot/utilities/roles/checkBotPermissions.ts
+function checkBotPermissions(client, guildOrChannel, scope = "all", inverse = false) {
+  if (guildOrChannel instanceof discord_js.Guild) {
+    const botRole = getBotRole(client, guildOrChannel);
+    checkPermissions(client, botRole, scope, inverse);
+  } else {
+    checkPermissions(client, guildOrChannel, scope);
+  }
+}
+__name(checkBotPermissions, "checkBotPermissions");
+async function fetchRole(clientOrGuild, roleId) {
+  let role;
+  if (!roleId) {
+    throw new RoleDoesNotExist("Role ID is null or undefined", roleId);
+  }
+  if (clientOrGuild instanceof discord_js.Guild) {
+    const guild = clientOrGuild;
+    role = guild.roles.cache.get(roleId);
+    if (!role) {
+      try {
+        role = await guild.roles.fetch(roleId);
+      } catch {
+        throw new RoleDoesNotExist("Role not found in specified guild", roleId);
+      }
+    }
+  } else {
+    const client = clientOrGuild;
+    role = client.guilds.cache.map((guild) => guild.roles.cache.get(roleId)).find((role2) => role2);
+    if (!role) {
+      const guilds = client.guilds.cache;
+      for (const guild of guilds.values()) {
+        try {
+          role = await guild.roles.fetch(roleId);
+          if (role) break;
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+  if (!role) {
+    throw new RoleDoesNotExist("Role not found", roleId);
+  }
+  return role;
+}
+__name(fetchRole, "fetchRole");
+function hasPermsToAssign(targetRole) {
+  const botRole = getBotRole(targetRole.client, targetRole.guild);
+  if (targetRole.comparePositionTo(botRole) >= 0) {
+    throw new RoleHigherThanMe("Role is higher than me", targetRole, botRole);
+  }
+  if (targetRole.managed) {
+    throw new CannotAssignBotRole(`Cannot assign bot role ${targetRole.name}`);
+  }
+  checkBotPermissions(targetRole.client, targetRole.guild, [
+    discord_js.PermissionFlagsBits.ManageRoles
+  ]);
+}
+__name(hasPermsToAssign, "hasPermsToAssign");
+
+// src/bot/utilities/users/fetchGuildMember.ts
+async function fetchGuildMember(guild, userId) {
+  let user = guild.members.cache.get(userId);
+  user ??= await guild.members.fetch(userId).catch(() => {
+    throw new UserNotInGuild(`User with ID ${userId} not found in guild`);
+  });
+  return user;
+}
+__name(fetchGuildMember, "fetchGuildMember");
+
+// src/bot/utilities/users/fetchManyGuildMembers.ts
+async function fetchManyGuildMembers(guild, userIds) {
+  const results = await Promise.allSettled(userIds.map((userId) => fetchGuildMember(guild, userId)));
+  return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
+}
+__name(fetchManyGuildMembers, "fetchManyGuildMembers");
+async function fetchUser(client, userId) {
+  let user = client.users.cache.get(userId);
+  user ??= await client.users.fetch(userId).catch((err) => {
+    if (err instanceof discord_js.DiscordAPIError && err.code === discord_js.RESTJSONErrorCodes.UnknownUser) {
+      throw new UserNotFound(userId);
+    }
+    throw err;
+  });
+  return user;
+}
+__name(fetchUser, "fetchUser");
+
+// src/bot/utilities/users/fetchManyUsers.ts
+async function fetchManyUsers(client, userIds) {
+  const results = await Promise.allSettled(userIds.map((userId) => fetchUser(client, userId)));
+  return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
+}
+__name(fetchManyUsers, "fetchManyUsers");
+
+// src/bot/utilities/users/updateMemberRoles.ts
+async function updateMemberRoles(rolesToAdd, rolesToRemove, member) {
+  const current = new Set(member.roles.cache.map((r) => r.id));
+  const toAdd = new Set(rolesToAdd);
+  const toRemove = new Set(rolesToRemove);
+  const updated = current.union(toAdd).difference(toRemove);
+  await member.roles.set([
+    ...updated
+  ]);
+}
+__name(updateMemberRoles, "updateMemberRoles");
+
 exports.AutocompleteHandler = AutocompleteHandler;
 exports.AutocompleteRoute = AutocompleteRoute;
+exports.BaseComponent = BaseComponent;
 exports.BaseErrorEmbed = BaseErrorEmbed;
+exports.BaseHandler = BaseHandler;
 exports.Bot = Bot;
 exports.BuilderComponent = BuilderComponent;
+exports.BuilderTypes = BuilderTypes;
 exports.ButtonRoute = ButtonRoute;
+exports.CannotAssignBotRole = CannotAssignBotRole;
+exports.CannotSendEmbedsError = CannotSendEmbedsError;
 exports.Catchable = Catchable;
+exports.ChannelNotFoundError = ChannelNotFoundError;
+exports.ChannelNotTextChannel = ChannelNotTextChannel;
 exports.Checkable = Checkable;
 exports.CommandMetadataKey = CommandMetadataKey;
+exports.CommandRegistry = CommandRegistry;
 exports.ContextMenuRoute = ContextMenuRoute;
+exports.CouldNotFindChannel = CouldNotFindChannel;
 exports.CustomError = CustomError;
 exports.DatabaseError = DatabaseError;
 exports.EffectMetadataKey = EffectMetadataKey;
 exports.EffectsEmitter = EffectsEmitter;
 exports.EffectsHandler = EffectsHandler;
 exports.EffectsRegistry = EffectsRegistry;
+exports.EmojiInjector = EmojiInjector;
 exports.EventCatchable = EventCatchable;
+exports.EventController = EventController;
 exports.EventHandler = EventHandler;
 exports.EventMetadataKey = EventMetadataKey;
+exports.EventMiddleware = EventMiddleware;
+exports.GenericError = GenericError;
+exports.HasDangerousPermissions = HasDangerousPermissions;
+exports.InteractionController = InteractionController;
 exports.InteractionHandler = InteractionHandler;
 exports.InteractionMetadataKey = InteractionMetadataKey;
 exports.InteractionMiddleware = InteractionMiddleware;
 exports.InteractionRoutes = InteractionRoutes;
-exports.ModalComponent = ModalComponent;
+exports.Middleware = Middleware;
+exports.MiddlewareMetadataKey = MiddlewareMetadataKey;
+exports.MiddlewareType = MiddlewareType;
+exports.MissingPermissions = MissingPermissions;
 exports.ModalRoute = ModalRoute;
+exports.PERM_GROUPS = PERM_GROUPS;
+exports.PermissionNames = PermissionNames;
 exports.Pluggable = Pluggable;
 exports.Plugin = Plugin;
 exports.RegisterCommand = RegisterCommand;
 exports.RegisterEffect = RegisterEffect;
 exports.RegisterEvent = RegisterEvent;
+exports.RoleDoesNotExist = RoleDoesNotExist;
+exports.RoleHigherThanMe = RoleHigherThanMe;
 exports.RowComponent = RowComponent;
+exports.RowTypes = RowTypes;
 exports.Seedcord = Seedcord;
 exports.SelectMenuRoute = SelectMenuRoute;
 exports.SelectMenuType = SelectMenuType;
 exports.SlashRoute = SlashRoute;
+exports.UnhandledEvent = UnhandledEvent;
+exports.UserNotFound = UserNotFound;
+exports.UserNotInGuild = UserNotInGuild;
 exports.WebhookLog = WebhookLog;
+exports.attemptSendDM = attemptSendDM;
+exports.buildSlashRoute = buildSlashRoute;
+exports.checkBotPermissions = checkBotPermissions;
+exports.checkPermissions = checkPermissions;
+exports.extractErrorResponse = extractErrorResponse;
+exports.fetchGuildMember = fetchGuildMember;
+exports.fetchManyGuildMembers = fetchManyGuildMembers;
+exports.fetchManyUsers = fetchManyUsers;
+exports.fetchRole = fetchRole;
+exports.fetchText = fetchText;
+exports.fetchUser = fetchUser;
+exports.getBotRole = getBotRole;
+exports.hasPermsToAssign = hasPermsToAssign;
+exports.sendInText = sendInText;
 exports.throwCustomError = throwCustomError;
+exports.updateMemberRoles = updateMemberRoles;
 Object.keys(services).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,