seedcord 0.1.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,2279 @@
+'use strict';
+
+require('reflect-metadata');
+var chalk6 = require('chalk');
+var discord_js = require('discord.js');
+var envapt = require('envapt');
+var promises = require('fs/promises');
+var path = require('path');
+var winston = require('winston');
+var crypto2 = require('crypto');
+var events = require('events');
+var http = require('http');
+var mongoose2 = require('mongoose');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var chalk6__default = /*#__PURE__*/_interopDefault(chalk6);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
+var mongoose2__default = /*#__PURE__*/_interopDefault(mongoose2);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+  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_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var Globals = class extends envapt.Envapter {
+  static {
+    __name(this, "Globals");
+  }
+  static botToken;
+  // Healthcheck
+  static healthCheckPort;
+  static healthCheckPath;
+  // Coordinated Shutdown
+  static shutdownIsEnabled;
+  // Unknown Exception Webhook URL
+  static unknownExceptionWebhookUrl;
+  // Variables
+  /**
+  * The default color of the bot's embeds. Can simply override by `Globals.botColor =`
+  */
+  static botColor = this.isProduction ? "#fe565a" : "#3fa045";
+};
+_ts_decorate([
+  envapt.Envapt("DISCORD_BOT_TOKEN", {
+    fallback: void 0
+  }),
+  _ts_metadata("design:type", String)
+], Globals, "botToken", void 0);
+_ts_decorate([
+  envapt.Envapt("HEALTH_CHECK_PORT", {
+    fallback: 6956
+  }),
+  _ts_metadata("design:type", Number)
+], Globals, "healthCheckPort", void 0);
+_ts_decorate([
+  envapt.Envapt("HEALTH_CHECK_PATH", {
+    fallback: "/healthcheck"
+  }),
+  _ts_metadata("design:type", String)
+], Globals, "healthCheckPath", void 0);
+_ts_decorate([
+  envapt.Envapt("SHUTDOWN_IS_ENABLED", {
+    fallback: false
+  }),
+  _ts_metadata("design:type", Boolean)
+], Globals, "shutdownIsEnabled", void 0);
+_ts_decorate([
+  envapt.Envapt("UNKNOWN_EXCEPTION_WEBHOOK_URL", {
+    fallback: void 0
+  }),
+  _ts_metadata("design:type", String)
+], Globals, "unknownExceptionWebhookUrl", void 0);
+
+// src/interfaces/Components.ts
+var BuilderTypes = {
+  command: discord_js.SlashCommandBuilder,
+  embed: discord_js.EmbedBuilder,
+  button: discord_js.ButtonBuilder,
+  menu_string: discord_js.StringSelectMenuBuilder,
+  menu_option_string: discord_js.StringSelectMenuOptionBuilder,
+  menu_user: discord_js.UserSelectMenuBuilder,
+  menu_channel: discord_js.ChannelSelectMenuBuilder,
+  menu_mentionable: discord_js.MentionableSelectMenuBuilder,
+  menu_role: discord_js.RoleSelectMenuBuilder,
+  modal: discord_js.ModalBuilder,
+  subcommand: discord_js.SlashCommandSubcommandBuilder,
+  group: discord_js.SlashCommandSubcommandGroupBuilder,
+  context_menu: discord_js.ContextMenuCommandBuilder
+};
+var RowTypes = {
+  button: discord_js.ActionRowBuilder,
+  menu_string: discord_js.ActionRowBuilder,
+  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
+};
+var BaseComponent = class BaseComponent2 {
+  static {
+    __name(this, "BaseComponent");
+  }
+  _component;
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  constructor(ComponentClass) {
+    this._component = new ComponentClass();
+  }
+  /**
+  * @description Returns the instantiated component
+  * @note Use this for configuring the component using its instance setters.
+  * @usage `this.instance.someMethod()`
+  */
+  get instance() {
+    return this._component;
+  }
+};
+var BuilderComponent = class extends BaseComponent {
+  static {
+    __name(this, "BuilderComponent");
+  }
+  constructor(type) {
+    const ComponentClass = BuilderTypes[type];
+    super(ComponentClass);
+    if (this.instance instanceof discord_js.EmbedBuilder) this.instance.setColor(Globals.botColor);
+    if (this.instance instanceof discord_js.SlashCommandBuilder || this.instance instanceof discord_js.ContextMenuCommandBuilder) {
+      this.instance.setContexts(discord_js.InteractionContextType.Guild);
+    }
+  }
+  get component() {
+    return this.instance;
+  }
+  buildCustomId(prefix, ...args) {
+    if (args.length === 0) return prefix;
+    return `${prefix}:${args.join("-")}`;
+  }
+};
+var RowComponent = class extends BaseComponent {
+  static {
+    __name(this, "RowComponent");
+  }
+  constructor(type) {
+    const ComponentClass = RowTypes[type];
+    super(ComponentClass);
+  }
+  get component() {
+    return this.instance;
+  }
+};
+var ModalRow = class ModalRow2 extends RowComponent {
+  static {
+    __name(this, "ModalRow");
+  }
+  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");
+  }
+  constructor() {
+    super("embed");
+    this.instance.setTitle("Cannot Proceed");
+  }
+};
+var CustomError = class extends Error {
+  static {
+    __name(this, "CustomError");
+  }
+  message;
+  _emit = false;
+  response = new BaseErrorEmbed().component;
+  constructor(message) {
+    super(message), this.message = message;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  get emit() {
+    return this._emit;
+  }
+};
+
+// src/bot/errors/Database.ts
+var DatabaseConnectionFailure = class extends CustomError {
+  static {
+    __name(this, "DatabaseConnectionFailure");
+  }
+  constructor(message = "Failed to connect to the database.") {
+    super(message);
+    this.response.setDescription("Failed to connect to the database.");
+  }
+};
+var DatabaseError = class extends CustomError {
+  static {
+    __name(this, "DatabaseError");
+  }
+  uuid;
+  _emit = true;
+  constructor(message, uuid) {
+    super(message), this.uuid = uuid;
+    this.name = "DatabaseError";
+    this.response.setTitle("Database Error").setDescription(`An error occurred while interacting with the database.
+### UUID: \`${this.uuid}\``);
+  }
+};
+var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
+  static instances = /* @__PURE__ */ new Map();
+  static instance(prefix) {
+    let instance = this.instances.get(prefix);
+    if (!instance) {
+      instance = new _Logger(prefix);
+      this.instances.set(prefix, instance);
+    }
+    return instance;
+  }
+  constructor(transportName) {
+    const consoleTransport = this.createConsoleTransport(transportName);
+    this.initializeLogger(consoleTransport);
+  }
+  getFormatCustomizations() {
+    const padding = 7;
+    return [
+      winston.format.errors({
+        stack: true
+      }),
+      winston.format.splat(),
+      winston.format.colorize({
+        level: true
+      }),
+      winston.format.timestamp({
+        format: "D MMM, hh:mm:ss a"
+      }),
+      winston.format.printf((info) => {
+        const ts = String(info.timestamp ?? "");
+        const lvl = String(info.level).padEnd(padding);
+        const lbl = String(info.label ?? "");
+        const msg = String(info.message ?? "");
+        const base = `${ts} [${lvl}]: ${lbl} - ${msg}`;
+        const splatSym = Symbol.for("splat");
+        const raw = info[splatSym];
+        const extras = Array.isArray(raw) ? raw : [];
+        const cleaned = extras.filter((x) => !(x instanceof Error)).filter((x) => {
+          if (!x) return false;
+          if (typeof x !== "object") return true;
+          return Object.keys(x).length > 0;
+        });
+        let rendered = base;
+        if (typeof info.stack === "string") {
+          rendered += `
+${String(info.stack)}`;
+        }
+        if (cleaned.length) {
+          const parts = [];
+          for (const x of cleaned) {
+            if (typeof x === "string") parts.push(x);
+            else {
+              try {
+                parts.push(JSON.stringify(x, null, 2));
+              } catch {
+                parts.push(String(x));
+              }
+            }
+          }
+          rendered += `
+${parts.join(" ")}`;
+        }
+        return rendered;
+      })
+    ];
+  }
+  createConsoleTransport(transportName) {
+    return new winston.transports.Console({
+      format: winston.format.combine(winston.format.label({
+        label: transportName
+      }), ...this.getFormatCustomizations()),
+      level: Globals.isDevelopment ? "silly" : Globals.isStaging ? "debug" : "info"
+    });
+  }
+  initializeLogger(consoleTransport) {
+    const transportsArray = [
+      consoleTransport
+    ];
+    if (Globals.isDevelopment) {
+      const maxSizeInMB = 10;
+      transportsArray.push(new winston.transports.File({
+        filename: "logs/application.log",
+        level: "debug",
+        format: winston.format.combine(winston.format.uncolorize(), winston.format.errors({
+          stack: true
+        }), winston.format.timestamp(), winston.format.json({
+          bigint: true,
+          space: 2
+        })),
+        maxsize: maxSizeInMB * 1024 * 1024,
+        maxFiles: 5,
+        tailable: true
+      }));
+    }
+    this.logger = winston.createLogger({
+      transports: transportsArray
+    });
+  }
+  error(msg, ...args) {
+    this.logger.error(msg, ...args);
+  }
+  warn(msg, ...args) {
+    this.logger.warn(msg, ...args);
+  }
+  info(msg, ...args) {
+    this.logger.info(msg, ...args);
+  }
+  http(msg, ...args) {
+    this.logger.http(msg, ...args);
+  }
+  verbose(msg, ...args) {
+    this.logger.verbose(msg, ...args);
+  }
+  debug(msg, ...args) {
+    this.logger.debug(msg, ...args);
+  }
+  silly(msg, ...args) {
+    this.logger.silly(msg, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static Error(prefix, msg, ...args) {
+    const logger = this.instance(prefix);
+    logger.error(msg, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static Info(prefix, msg, ...args) {
+    const logger = this.instance(prefix);
+    logger.info(msg, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static Warn(prefix, msg, ...args) {
+    const logger = this.instance(prefix);
+    logger.warn(msg, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static Debug(prefix, msg, ...args) {
+    const logger = this.instance(prefix);
+    logger.debug(msg, ...args);
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static Silly(prefix, msg, ...args) {
+    const logger = this.instance(prefix);
+    logger.silly(msg, ...args);
+  }
+};
+
+// src/library/Helpers.ts
+function numberFixer(num, decimalPlaces) {
+  const factor = Math.pow(10, decimalPlaces);
+  return Math.round((num + Number.EPSILON) * factor) / factor;
+}
+__name(numberFixer, "numberFixer");
+function percentage(num1, num2) {
+  return Number((num1 / num2 * 100).toFixed(2));
+}
+__name(percentage, "percentage");
+function generateAsciiTable(data) {
+  if (data.length === 0) return "";
+  const firstRow = data[0];
+  if (!firstRow || firstRow.length === 0) return "";
+  let table = "";
+  const columnWidths = [];
+  for (let i = 0; i < firstRow.length; i++) {
+    let maxWidth = 0;
+    for (const row of data) {
+      const cell = row[i];
+      if (cell !== void 0) maxWidth = Math.max(maxWidth, cell.length);
+    }
+    columnWidths.push(maxWidth);
+  }
+  const createLine = /* @__PURE__ */ __name((char, left, intersect, right) => {
+    let line = left;
+    columnWidths.forEach((width, index) => {
+      line += char.repeat(width + 2);
+      if (index < columnWidths.length - 1) line += intersect;
+      else line += right;
+    });
+    line += "\n";
+    return line;
+  }, "createLine");
+  table += createLine("\u2550", "\u2554", "\u2566", "\u2557");
+  data.forEach((row, rowIndex) => {
+    table += "\u2551";
+    row.forEach((cell, columnIndex) => {
+      const columnWidth = columnWidths[columnIndex];
+      if (columnWidth !== void 0) table += ` ${cell.padEnd(columnWidth)} \u2551`;
+    });
+    table += "\n";
+    if (rowIndex < data.length - 1) table += createLine("\u2500", "\u2560", "\u256C", "\u2563");
+    else table += createLine("\u2550", "\u255A", "\u2569", "\u255D");
+  });
+  return table;
+}
+__name(generateAsciiTable, "generateAsciiTable");
+function formatWord(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+__name(formatWord, "formatWord");
+function longestStringLength(arr) {
+  return Math.max(...arr.map((el) => el.toString().length));
+}
+__name(longestStringLength, "longestStringLength");
+function currentTime() {
+  return Math.floor(Date.now() / 1e3);
+}
+__name(currentTime, "currentTime");
+function ordinal(n) {
+  const s = [
+    "th",
+    "st",
+    "nd",
+    "rd"
+  ];
+  const v = n % 100;
+  const index = (v - 20) % 10;
+  const suffix = s[index] ?? s[v] ?? s[0];
+  if (!suffix) return `${n}th`;
+  return `${n}${suffix}`;
+}
+__name(ordinal, "ordinal");
+function prettyDifference(numBefore, numAfter) {
+  return (numAfter - numBefore > 0 ? `+${numAfter - numBefore}` : numAfter - numBefore).toString();
+}
+__name(prettyDifference, "prettyDifference");
+function isTsOrJsFile(entry) {
+  return entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".map");
+}
+__name(isTsOrJsFile, "isTsOrJsFile");
+async function traverseDirectory(dir, callback) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir, {
+      withFileTypes: true
+    });
+  } catch {
+    Logger.Error("Failed to read directory", dir);
+    entries = [];
+  }
+  for (const entry of entries) {
+    const fullPath = path__namespace.join(dir, entry.name);
+    const relativePath = path__namespace.relative(process.cwd(), fullPath);
+    if (entry.isDirectory()) {
+      await traverseDirectory(fullPath, callback);
+    } else if (isTsOrJsFile(entry)) {
+      const imported = await import(fullPath);
+      await callback(fullPath, relativePath, imported);
+    }
+  }
+}
+__name(traverseDirectory, "traverseDirectory");
+function throwCustomError(error, message, customError) {
+  const uuid = crypto.randomUUID();
+  Logger.Error("Throwing Custom Error", error.name);
+  if (typeof customError === typeof DatabaseError) {
+    const errorMessage = error instanceof Error ? error.message : message;
+    throw new customError(errorMessage, uuid);
+  } else {
+    if (error instanceof Error) {
+      throw new customError(`${message}: ${error.message ? error.message : error.toString()}`);
+    } else {
+      throw new customError(message);
+    }
+  }
+}
+__name(throwCustomError, "throwCustomError");
+function prettify(key) {
+  return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").trim();
+}
+__name(prettify, "prettify");
+function fyShuffle(items) {
+  const array = items.slice();
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [
+      array[j],
+      array[i]
+    ];
+  }
+  return array;
+}
+__name(fyShuffle, "fyShuffle");
+
+// src/bot/decorators/CommandRegisterable.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 {
+    __name(this, "CommandRegistry");
+  }
+  core;
+  logger = new Logger("Commands");
+  isInitialised = false;
+  globalCommands = [];
+  guildCommands = /* @__PURE__ */ new Map();
+  constructor(core) {
+    this.core = core;
+  }
+  async init() {
+    if (this.isInitialised) return;
+    this.isInitialised = true;
+    this.logger.info(chalk6__default.default.bold(this.core.config.bot.commands.path));
+    await this.loadCommands(this.core.config.bot.commands.path);
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${chalk6__default.default.magenta.bold(this.globalCommands.length)} global, ${chalk6__default.default.magenta.bold(this.guildCommands.size)} guild groups`);
+  }
+  async loadCommands(dir) {
+    await traverseDirectory(dir, (_full, rel, mod) => {
+      for (const exported of Object.values(mod)) if (this.isCommandClass(exported)) this.registerCommand(exported, rel);
+    });
+  }
+  isCommandClass(obj) {
+    if (typeof obj !== "function") return false;
+    return obj.prototype instanceof BuilderComponent && Reflect.hasMetadata(CommandMetadataKey, obj);
+  }
+  registerCommand(ctor, rel) {
+    const meta = Reflect.getMetadata(CommandMetadataKey, ctor);
+    if (!meta) return;
+    const instance = new ctor();
+    const comp = instance.component;
+    const commandType = comp instanceof discord_js.SlashCommandBuilder ? "slash command" : "context menu command";
+    if (meta.scope === "global") {
+      this.globalCommands.push(comp);
+      this.logger.info(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(ctor.name)} from ${chalk6__default.default.gray(rel)}`);
+      this.logger.info(`  \u2192 Global ${commandType}: ${chalk6__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(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(ctor.name)} from ${chalk6__default.default.gray(rel)}`);
+      this.logger.info(`  \u2192 Guild ${commandType}: ${chalk6__default.default.bold.cyan(comp.name)} for ${chalk6__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(`${chalk6__default.default.bold.green("Configured")} ${chalk6__default.default.magenta.bold(this.globalCommands.length)} global ${tag}`);
+      this.logger.info(` \u2192 ${this.globalCommands.map((command) => chalk6__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);
+      if (!guild) {
+        this.logger.warn(`Guild with ID ${guildId} not found, skipping command registration.`);
+        continue;
+      }
+      await guild.commands.set(commands);
+      const tag = commands.length === 1 ? "command" : "commands";
+      this.logger.info(`${chalk6__default.default.bold.green("Configured")} ${chalk6__default.default.magenta.bold(commands.length)} ${tag} for guild ${chalk6__default.default.bold.yellow(guild.name)}`);
+      this.logger.info(` \u2192 ${commands.map((command) => chalk6__default.default.bold.cyan(command.name)).join(", ")}`);
+    }
+  }
+};
+
+// src/interfaces/Handler.ts
+var BaseHandler = class BaseHandler2 {
+  static {
+    __name(this, "BaseHandler");
+  }
+  core;
+  checkable = false;
+  break = false;
+  errored = false;
+  event;
+  args = [];
+  constructor(event, core, args) {
+    this.core = core;
+    this.event = event;
+    this.args = args ?? [];
+  }
+  hasChecks() {
+    return this.checkable;
+  }
+  hasErrors() {
+    return this.errored;
+  }
+  setErrored() {
+    this.errored = true;
+  }
+  shouldBreak() {
+    return this.break;
+  }
+  getEvent() {
+    return this.event;
+  }
+  /**
+  * Get the arguments passed from the customId
+  * For example, if customId is "accept:user123-guild456", args will be ["user123", "guild456"]
+  */
+  getArgs() {
+    return this.args;
+  }
+  /**
+  * Get a specific argument by index
+  */
+  getArg(index) {
+    return this.args[index];
+  }
+};
+var InteractionHandler = class extends BaseHandler {
+  static {
+    __name(this, "InteractionHandler");
+  }
+  constructor(event, core, args) {
+    super(event, core, args);
+  }
+};
+var InteractionMiddleware = class extends BaseHandler {
+  static {
+    __name(this, "InteractionMiddleware");
+  }
+  constructor(event, core, args) {
+    super(event, core, args);
+  }
+};
+var AutocompleteHandler = class extends BaseHandler {
+  static {
+    __name(this, "AutocompleteHandler");
+  }
+  focused;
+  constructor(event, core, args) {
+    super(event, core, args);
+    this.focused = this.event.options.getFocused(true);
+  }
+};
+var EventHandler = class extends BaseHandler {
+  static {
+    __name(this, "EventHandler");
+  }
+  constructor(event, core, args) {
+    super(event, core, args);
+  }
+};
+
+// src/bot/decorators/EventRegisterable.ts
+var EventMetadataKey = Symbol("event:metadata");
+function RegisterEvent(eventName) {
+  return function(constructor) {
+    Reflect.defineMetadata(EventMetadataKey, eventName, constructor);
+  };
+}
+__name(RegisterEvent, "RegisterEvent");
+
+// src/bot/controllers/EventController.ts
+var EventController = class {
+  static {
+    __name(this, "EventController");
+  }
+  core;
+  logger = new Logger("Events");
+  isInitialized = false;
+  eventMap = /* @__PURE__ */ new Map();
+  constructor(core) {
+    this.core = core;
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.isInitialized = true;
+    const handlersDir = this.core.config.bot.events.path;
+    this.logger.info(chalk6__default.default.bold(handlersDir));
+    await this.loadHandlers(handlersDir);
+    this.attachToClient();
+    const loadedEventsArray = [];
+    this.eventMap.forEach((handlers, eventName) => {
+      loadedEventsArray.push(`${chalk6__default.default.magenta.bold(handlers.length)} ${eventName}`);
+    });
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${this.eventMap.size > 0 ? loadedEventsArray.join(", ") : "none"}`);
+  }
+  async loadHandlers(dir) {
+    await traverseDirectory(dir, (_fullPath, relativePath, imported) => {
+      for (const val of Object.values(imported)) {
+        if (this.isEventHandlerClass(val)) {
+          this.registerHandler(val);
+          this.logger.info(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(val.name)} from ${chalk6__default.default.gray(relativePath)}`);
+        }
+      }
+    });
+  }
+  isEventHandlerClass(obj) {
+    if (typeof obj !== "function") return false;
+    return obj.prototype instanceof EventHandler && Reflect.hasMetadata(EventMetadataKey, 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);
+    }
+    handlers.push(handlerClass);
+  }
+  attachToClient() {
+    for (const [eventName] of this.eventMap) {
+      this.logger.debug(`Attaching ${chalk6__default.default.bold.green(eventName)} to ${chalk6__default.default.bold.yellow(this.core.bot.client.user?.username)}`);
+      this.core.bot.client.on(eventName, (...args) => {
+        void (async () => {
+          await this.processEvent(eventName, args);
+        })();
+      });
+    }
+  }
+  async processEvent(eventName, args) {
+    const handlerCtors = this.eventMap.get(eventName);
+    if (!handlerCtors || handlerCtors.length === 0) return;
+    for (const HandlerCtor of handlerCtors) {
+      try {
+        this.logger.debug(`Processing ${chalk6__default.default.bold.green(eventName)} with ${chalk6__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);
+      }
+    }
+  }
+};
+
+// src/bot/decorators/InteractionConfigurable.ts
+var InteractionRoutes = /* @__PURE__ */ (function(InteractionRoutes2) {
+  InteractionRoutes2["Slash"] = "interaction:slash";
+  InteractionRoutes2["Button"] = "interaction:button";
+  InteractionRoutes2["Modal"] = "interaction:modal";
+  InteractionRoutes2["StringMenu"] = "interaction:stringMenu";
+  InteractionRoutes2["UserMenu"] = "interaction:userMenu";
+  InteractionRoutes2["RoleMenu"] = "interaction:roleMenu";
+  InteractionRoutes2["ChannelMenu"] = "interaction:channelMenu";
+  InteractionRoutes2["MentionableMenu"] = "interaction:mentionableMenu";
+  InteractionRoutes2["MessageContextMenu"] = "interaction:messageContextMenu";
+  InteractionRoutes2["UserContextMenu"] = "interaction:userContextMenu";
+  InteractionRoutes2["Autocomplete"] = "interaction:autocomplete";
+  return InteractionRoutes2;
+})({});
+var SelectMenuType = /* @__PURE__ */ (function(SelectMenuType2) {
+  SelectMenuType2["String"] = "string";
+  SelectMenuType2["User"] = "user";
+  SelectMenuType2["Role"] = "role";
+  SelectMenuType2["Channel"] = "channel";
+  SelectMenuType2["Mentionable"] = "mentionable";
+  return SelectMenuType2;
+})({});
+var InteractionMetadataKey = Symbol("interaction:metadata");
+function SlashRoute(routeOrRoutes) {
+  return function(constructor) {
+    storeMetadata("interaction:slash", routeOrRoutes, constructor);
+  };
+}
+__name(SlashRoute, "SlashRoute");
+function ButtonRoute(routeOrRoutes) {
+  return function(constructor) {
+    storeMetadata("interaction:button", routeOrRoutes, constructor);
+  };
+}
+__name(ButtonRoute, "ButtonRoute");
+function ModalRoute(routeOrRoutes) {
+  return function(constructor) {
+    storeMetadata("interaction:modal", routeOrRoutes, constructor);
+  };
+}
+__name(ModalRoute, "ModalRoute");
+function ContextMenuRoute(type, routeOrRoutes) {
+  return function(constructor) {
+    const routeType = type === "message" ? "interaction:messageContextMenu" : "interaction:userContextMenu";
+    storeMetadata(routeType, routeOrRoutes, constructor);
+  };
+}
+__name(ContextMenuRoute, "ContextMenuRoute");
+function AutocompleteRoute(commandRoutes, focusedFields) {
+  return function(constructor) {
+    const routes = Array.isArray(commandRoutes) ? commandRoutes : [
+      commandRoutes
+    ];
+    const fields = Array.isArray(focusedFields) ? focusedFields : [
+      focusedFields
+    ];
+    routes.forEach((route) => {
+      fields.forEach((field) => {
+        const autocompleteKey = `${route}:${field}`;
+        storeMetadata("interaction:autocomplete", autocompleteKey, constructor);
+      });
+    });
+  };
+}
+__name(AutocompleteRoute, "AutocompleteRoute");
+function SelectMenuRoute(type, routeOrRoutes) {
+  return function(constructor) {
+    const routeMap = {
+      ["string"]: "interaction:stringMenu",
+      ["user"]: "interaction:userMenu",
+      ["role"]: "interaction:roleMenu",
+      ["channel"]: "interaction:channelMenu",
+      ["mentionable"]: "interaction:mentionableMenu"
+    };
+    storeMetadata(routeMap[type], routeOrRoutes, constructor);
+  };
+}
+__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 : [
+    routes
+  ];
+  Reflect.defineMetadata(symbol, [
+    ...existing,
+    ...toStore
+  ], constructor);
+  Reflect.defineMetadata(InteractionMetadataKey, true, constructor);
+}
+__name(storeMetadata, "storeMetadata");
+var ErrorHandlingUtils = class {
+  static {
+    __name(this, "ErrorHandlingUtils");
+  }
+  static logger = new Logger("Errors");
+  static handleError(error, core, guild, user) {
+    const uuid = crypto2__namespace.randomUUID();
+    if (error instanceof CustomError) {
+      if (error instanceof DatabaseError) {
+        core.hooks.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 {
+        uuid,
+        response: error.response
+      };
+    }
+    this.logger.error(uuid, error);
+    core.hooks.emit("unknownException", {
+      uuid,
+      error,
+      guild,
+      user
+    });
+    return {
+      uuid,
+      response: new GenericError(uuid).response
+    };
+  }
+};
+var GenericError = class GenericError2 extends CustomError {
+  static {
+    __name(this, "GenericError");
+  }
+  uuid;
+  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:
+### UUID: \`${this.uuid}\``);
+  }
+};
+
+// src/bot/decorators/Catchable.ts
+function Catchable(options) {
+  return function(_target, _propertyKey, descriptor) {
+    const log = options?.log ?? false;
+    const forceFollowup = options?.forceFollowup ?? false;
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const interaction = this.getEvent();
+      if (!originalMethod) throw new Error("Method not found");
+      try {
+        await originalMethod.apply(this, args);
+      } catch (error) {
+        if (!(error instanceof Error)) throw error;
+        this.setErrored();
+        if (log) console.error(error);
+        const { response } = ErrorHandlingUtils.handleError(error, this.core, interaction.guild, interaction.user);
+        const res = {
+          embeds: [
+            response
+          ],
+          components: []
+        };
+        if (forceFollowup) {
+          await interaction.followUp({
+            flags: discord_js.MessageFlags.Ephemeral,
+            ...res
+          });
+          return;
+        }
+        if (interaction.replied) {
+          await interaction.followUp({
+            flags: discord_js.MessageFlags.Ephemeral,
+            ...res
+          });
+        } else if (interaction.deferred) {
+          await interaction.editReply(res);
+        } else {
+          await interaction.reply({
+            flags: discord_js.MessageFlags.Ephemeral,
+            ...res
+          });
+        }
+      }
+    };
+  };
+}
+__name(Catchable, "Catchable");
+
+// src/bot/defaults/UnhandledEvent.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 UnhandledEvent = class extends InteractionHandler {
+  static {
+    __name(this, "UnhandledEvent");
+  }
+  async execute() {
+    await this.event.reply({
+      content: `Feature not implemented yet.`,
+      flags: discord_js.MessageFlags.Ephemeral
+    });
+  }
+};
+_ts_decorate2([
+  Catchable(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", []),
+  _ts_metadata2("design:returntype", Promise)
+], UnhandledEvent.prototype, "execute", null);
+
+// src/bot/controllers/InteractionController.ts
+var InteractionController = class {
+  static {
+    __name(this, "InteractionController");
+  }
+  core;
+  logger = new Logger("Interactions");
+  isInitialized = false;
+  slashMap = /* @__PURE__ */ new Map();
+  buttonMap = /* @__PURE__ */ new Map();
+  modalMap = /* @__PURE__ */ new Map();
+  stringSelectMap = /* @__PURE__ */ new Map();
+  userSelectMap = /* @__PURE__ */ new Map();
+  roleSelectMap = /* @__PURE__ */ new Map();
+  channelSelectMap = /* @__PURE__ */ new Map();
+  mentionableSelectMap = /* @__PURE__ */ new Map();
+  messageContextMenuMap = /* @__PURE__ */ new Map();
+  userContextMenuMap = /* @__PURE__ */ new Map();
+  autocompleteMap = /* @__PURE__ */ new Map();
+  keysToIgnore = /* @__PURE__ */ new Set([
+    "confirm!confirmable",
+    "cancel!confirmable"
+  ]);
+  middlewares = [];
+  constructor(core) {
+    this.core = core;
+  }
+  async init() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    const handlersDir = this.core.config.bot.interactions.path;
+    this.logger.info(chalk6__default.default.bold(handlersDir));
+    await this.loadHandlers(handlersDir);
+    this.attachToClient();
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded interaction handlers:")}`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.slashMap.size)} slash commands`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.buttonMap.size)} buttons`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.modalMap.size)} modals`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.stringSelectMap.size)} string selects`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.userSelectMap.size)} user selects`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.roleSelectMap.size)} role selects`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.channelSelectMap.size)} channel selects`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.messageContextMenuMap.size)} message context menus`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.userContextMenuMap.size)} user context menus`);
+    this.logger.info(`\u2192 ${chalk6__default.default.magenta.bold(this.autocompleteMap.size)} autocomplete`);
+  }
+  async loadHandlers(dir) {
+    await traverseDirectory(dir, (_fullPath, relativePath, imported) => {
+      for (const val of Object.values(imported)) {
+        if (this.isHandlerClass(val)) {
+          this.registerHandler(val);
+          this.logger.info(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(val.name)} from ${chalk6__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);
+  }
+  registerHandler(handlerClass) {
+    const areRoutes = /* @__PURE__ */ __name((routes) => {
+      return Array.isArray(routes) && routes.every((r) => typeof r === "string");
+    }, "areRoutes");
+    const routeTypes = [
+      [
+        InteractionRoutes.Slash,
+        this.slashMap
+      ],
+      [
+        InteractionRoutes.Button,
+        this.buttonMap
+      ],
+      [
+        InteractionRoutes.Modal,
+        this.modalMap
+      ],
+      [
+        InteractionRoutes.StringMenu,
+        this.stringSelectMap
+      ],
+      [
+        InteractionRoutes.UserMenu,
+        this.userSelectMap
+      ],
+      [
+        InteractionRoutes.RoleMenu,
+        this.roleSelectMap
+      ],
+      [
+        InteractionRoutes.ChannelMenu,
+        this.channelSelectMap
+      ],
+      [
+        InteractionRoutes.MentionableMenu,
+        this.mentionableSelectMap
+      ],
+      [
+        InteractionRoutes.MessageContextMenu,
+        this.messageContextMenuMap
+      ],
+      [
+        InteractionRoutes.UserContextMenu,
+        this.userContextMenuMap
+      ],
+      [
+        InteractionRoutes.Autocomplete,
+        this.autocompleteMap
+      ]
+    ];
+    for (const [routeType, map] of routeTypes) {
+      const meta = Reflect.getMetadata(routeType, handlerClass);
+      if (!areRoutes(meta)) continue;
+      const routes = meta;
+      routes.forEach((route) => map.set(route, handlerClass));
+    }
+  }
+  attachToClient() {
+    this.core.bot.client.on(discord_js.Events.InteractionCreate, (interaction) => {
+      this.handleInteraction(interaction).catch((err) => {
+        this.logger.error(`[${chalk6__default.default.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+      });
+    });
+  }
+  parseCustomId(customId) {
+    const parts = customId.split(":");
+    const prefix = parts[0] ?? "";
+    const argString = parts[1] ?? "";
+    const args = argString ? argString.split("-") : [];
+    return {
+      prefix,
+      args
+    };
+  }
+  async handleCustomIdInteraction(interaction, getMap, interactionType) {
+    const { prefix, args } = this.parseCustomId(interaction.customId);
+    if (!prefix) return this.logger.warn(`${interactionType} has invalid customId: ${interaction.customId}`);
+    await this.processInteraction(interaction, () => prefix, (key) => getMap().get(key), args);
+  }
+  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);
+      await middleware.execute();
+      if (middleware.hasErrors()) return;
+    }
+    let HandlerCtor = getHandler(key);
+    if (!HandlerCtor) {
+      this.logger.warn(`No handler found for key ${chalk6__default.default.bold.cyan(key)}. Falling back to UnhandledEvent.`);
+      HandlerCtor = UnhandledEvent;
+    }
+    this.logger.debug(`Processing ${chalk6__default.default.bold.green(key)} with ${chalk6__default.default.gray(HandlerCtor.name)}`);
+    const handler = new HandlerCtor(interaction, this.core, args);
+    if (handler.hasChecks()) await handler.runChecks();
+    if (handler.shouldBreak()) return;
+    if (!handler.hasErrors()) await handler.execute();
+  }
+  async handleInteraction(interaction) {
+    switch (true) {
+      case interaction.isChatInputCommand():
+        await this.handleSlashCommand(interaction);
+        break;
+      case interaction.isButton():
+        await this.handleButton(interaction);
+        break;
+      case interaction.isModalSubmit():
+        await this.handleModal(interaction);
+        break;
+      case interaction.isStringSelectMenu():
+        await this.handleStringSelectMenu(interaction);
+        break;
+      case interaction.isUserSelectMenu():
+        await this.handleUserSelectMenu(interaction);
+        break;
+      case interaction.isRoleSelectMenu():
+        await this.handleRoleSelectMenu(interaction);
+        break;
+      case interaction.isChannelSelectMenu():
+        await this.handleChannelSelectMenu(interaction);
+        break;
+      case interaction.isMentionableSelectMenu():
+        await this.handleMentionableSelectMenu(interaction);
+        break;
+      case interaction.isMessageContextMenuCommand():
+        await this.handleMessageContextMenu(interaction);
+        break;
+      case interaction.isUserContextMenuCommand():
+        await this.handleUserContextMenu(interaction);
+        break;
+      case interaction.isAutocomplete():
+        await this.handleAutocomplete(interaction);
+        break;
+      default:
+        this.logger.warn(`Unhandled interaction type: ${interaction.type}`);
+        break;
+    }
+  }
+  async handleSlashCommand(interaction) {
+    const route = this.buildSlashRoute(interaction);
+    await this.processInteraction(interaction, () => route, (key) => this.slashMap.get(key));
+  }
+  async handleButton(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.buttonMap, "Button");
+  }
+  async handleModal(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.modalMap, "Modal");
+  }
+  async handleStringSelectMenu(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.stringSelectMap, "String select menu");
+  }
+  async handleUserSelectMenu(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.userSelectMap, "User select menu");
+  }
+  async handleRoleSelectMenu(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.roleSelectMap, "Role select menu");
+  }
+  async handleChannelSelectMenu(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.channelSelectMap, "Channel select menu");
+  }
+  async handleMentionableSelectMenu(interaction) {
+    await this.handleCustomIdInteraction(interaction, () => this.mentionableSelectMap, "Mentionable select menu");
+  }
+  async handleMessageContextMenu(interaction) {
+    await this.processInteraction(interaction, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
+  }
+  async handleUserContextMenu(interaction) {
+    await this.processInteraction(interaction, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
+  }
+  async handleAutocomplete(interaction) {
+    const route = this.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 {
+    __name(this, "EmojiInjector");
+  }
+  core;
+  logger = new Logger("Emojis");
+  constructor(core) {
+    this.core = core;
+  }
+  async init() {
+    if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
+      this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${chalk6__default.default.magenta.bold("0")} emojis`);
+      return;
+    }
+    const configEmojis = this.core.config.bot.emojis;
+    await this.core.bot.client.application?.emojis.fetch();
+    let foundCount = 0;
+    Object.entries(configEmojis).forEach(([key, emojiName]) => {
+      const emoji = this.core.bot.client.application?.emojis.cache.find((e) => e.name === emojiName);
+      if (emoji) {
+        configEmojis[key] = `<${emoji.identifier}>`;
+        foundCount++;
+      }
+    });
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${chalk6__default.default.magenta.bold(foundCount)} emojis`);
+  }
+};
+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;
+  }
+  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(chalk6__default.default.bold("Initializing"));
+      await instance.init();
+      instance.logger.info(chalk6__default.default.bold("Initialized"));
+    }, _Pluggable.PLUGIN_INIT_TIMEOUT_MS);
+    return Object.assign(this, entry);
+  }
+};
+var CoordinatedLifecycle = class {
+  static {
+    __name(this, "CoordinatedLifecycle");
+  }
+  phaseOrder;
+  phaseEnum;
+  logger;
+  events = new events.EventEmitter();
+  tasksMap = /* @__PURE__ */ new Map();
+  constructor(loggerName, phaseOrder, phaseEnum) {
+    this.phaseOrder = phaseOrder;
+    this.phaseEnum = phaseEnum;
+    this.logger = new Logger(loggerName);
+    this.phaseOrder.forEach((phase) => this.tasksMap.set(phase, []));
+  }
+  /**
+  * Add a task to a specific phase
+  */
+  addTask(phase, taskName, task, timeoutMs) {
+    if (!this.canAddTask()) return;
+    const tasks = this.tasksMap.get(phase);
+    if (!tasks) throw new Error(`Unknown phase: ${phase}`);
+    tasks.push({
+      name: taskName,
+      task,
+      timeout: timeoutMs
+    });
+    this.logger.debug(`${chalk6__default.default.italic("Added")} ${this.getTaskType()} task ${chalk6__default.default.bold.cyan(taskName)} to phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}`);
+  }
+  /**
+  * Remove a task by name from a specific phase
+  */
+  removeTask(phase, taskName) {
+    if (!this.canRemoveTask()) return false;
+    const tasks = this.tasksMap.get(phase);
+    if (!tasks) return false;
+    const initialLength = tasks.length;
+    const filteredTasks = tasks.filter((task) => task.name !== taskName);
+    this.tasksMap.set(phase, filteredTasks);
+    const removed = initialLength !== filteredTasks.length;
+    if (removed) {
+      this.logger.debug(`${chalk6__default.default.italic("Removed")} ${this.getTaskType()} task ${chalk6__default.default.bold.cyan(taskName)} from phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}`);
+    }
+    return removed;
+  }
+  /**
+  * Run all tasks in a specific phase
+  */
+  async runPhase(phase) {
+    const tasks = this.tasksMap.get(phase) ?? [];
+    if (tasks.length === 0) {
+      this.logger.warn(`No tasks to run in phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}`);
+      return;
+    }
+    this.logger.info(`${chalk6__default.default.bold.yellow("Running")} ${this.getTaskType()} phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])} with ${chalk6__default.default.bold.cyan(tasks.length)} tasks`);
+    this.emit(`phase:${phase}:start`);
+    const results = await this.executeTasksInPhase(phase, tasks);
+    const failures = results.filter((r) => r.status === "rejected").length;
+    if (failures > 0) {
+      const errorMessage = `Phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])} completed with ${chalk6__default.default.bold.red(failures)} failed tasks`;
+      throw new Error(errorMessage);
+    } else {
+      this.logger.info(`Phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])} ${chalk6__default.default.bold.green("completed successfully")}`);
+    }
+    this.emit(`phase:${phase}:complete`);
+  }
+  /**
+  * Run a single task with timeout
+  */
+  async runTaskWithTimeout(phase, task) {
+    this.logger.info(`${chalk6__default.default.italic("Starting")} task ${chalk6__default.default.bold.cyan(task.name)} in phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}`);
+    try {
+      await Promise.race([
+        task.task(),
+        new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`Task '${task.name}' timed out after ${task.timeout}ms`));
+          }, task.timeout);
+        })
+      ]);
+      this.logger.info(`${chalk6__default.default.italic("Completed")} task ${chalk6__default.default.bold.cyan(task.name)} in phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}`);
+    } catch (error) {
+      this.logger.error(`${chalk6__default.default.italic("Failed")} task ${chalk6__default.default.bold.cyan(task.name)} in phase ${chalk6__default.default.bold.magenta(this.phaseEnum[phase])}:`, error);
+      throw error;
+    }
+  }
+  /**
+  * Subscribe to lifecycle events
+  */
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  /**
+  * Unsubscribe from lifecycle events
+  */
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
+  emit(event, ...args) {
+    return this.events.emit(event, ...args);
+  }
+};
+
+// src/services/Lifecycle/CoordinatedShutdown.ts
+var ShutdownPhase = /* @__PURE__ */ (function(ShutdownPhase2) {
+  ShutdownPhase2[ShutdownPhase2["StopAcceptingRequests"] = 1] = "StopAcceptingRequests";
+  ShutdownPhase2[ShutdownPhase2["StopServices"] = 2] = "StopServices";
+  ShutdownPhase2[ShutdownPhase2["ExternalResources"] = 3] = "ExternalResources";
+  ShutdownPhase2[ShutdownPhase2["DiscordCleanup"] = 4] = "DiscordCleanup";
+  ShutdownPhase2[ShutdownPhase2["FinalCleanup"] = 5] = "FinalCleanup";
+  return ShutdownPhase2;
+})({});
+var PHASE_ORDER = [
+  1,
+  2,
+  3,
+  4,
+  5
+];
+var LOG_FLUSH_DELAY_MS = 500;
+var CoordinatedShutdown = class extends CoordinatedLifecycle {
+  static {
+    __name(this, "CoordinatedShutdown");
+  }
+  isShuttingDown = false;
+  exitCode = 0;
+  constructor() {
+    super("CoordinatedShutdown", PHASE_ORDER, ShutdownPhase);
+    this.registerSignalHandlers();
+  }
+  canAddTask() {
+    return Globals.shutdownIsEnabled;
+  }
+  canRemoveTask() {
+    return true;
+  }
+  getTaskType() {
+    return "shutdown";
+  }
+  async executeTasksInPhase(phase, tasks) {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await Promise.resolve().then(() => this.runTaskWithTimeout(phase, task)).then(() => ({
+        status: "fulfilled",
+        value: void 0
+      }), (reason) => ({
+        status: "rejected",
+        reason
+      })));
+    }
+    return results;
+  }
+  registerSignalHandlers() {
+    if (!Globals.shutdownIsEnabled) return;
+    process.on("SIGTERM", () => {
+      this.logger.info(`Received ${chalk6__default.default.yellow.bold("SIGTERM")} signal`);
+      void this.run(0);
+    });
+    process.on("SIGINT", () => {
+      this.logger.info(`Received ${chalk6__default.default.yellow.bold("SIGINT")} signal`);
+      void this.run(0);
+    });
+  }
+  /**
+  * Add a task to a specific shutdown phase
+  */
+  addTask(phase, taskName, task, timeoutMs = 5e3) {
+    super.addTask(phase, taskName, task, timeoutMs);
+  }
+  /**
+  * Remove a task by name from a specific phase
+  */
+  removeTask(phase, taskName) {
+    return super.removeTask(phase, taskName);
+  }
+  /**
+  * Start the coordinated shutdown sequence
+  */
+  async run(exitCode = 0) {
+    if (this.isShuttingDown) {
+      this.logger.warn("Shutdown sequence already in progress");
+      return;
+    }
+    this.isShuttingDown = true;
+    this.exitCode = exitCode;
+    this.logger.info(`${chalk6__default.default.bold.yellow("Starting")} coordinated shutdown with exit code ${chalk6__default.default.bold.cyan(exitCode)}`);
+    this.emit("shutdown:start");
+    try {
+      for (const phase of PHASE_ORDER) {
+        await this.runPhase(phase);
+      }
+      this.logger.info(`${chalk6__default.default.bold.green("Coordinated shutdown completed")} successfully`);
+      this.emit("shutdown:complete");
+    } catch (error) {
+      this.logger.error(`${chalk6__default.default.bold.red("Coordinated shutdown failed")}`);
+      this.emit("shutdown:error", error);
+    } finally {
+      this.logger.info(`${chalk6__default.default.bold.red("Exiting")} process with code ${chalk6__default.default.bold.cyan(this.exitCode)}`);
+      setTimeout(() => {
+        process.exit(this.exitCode);
+      }, LOG_FLUSH_DELAY_MS);
+    }
+  }
+  /**
+  * Subscribe to shutdown events
+  */
+  on(event, listener) {
+    super.on(event, listener);
+  }
+  /**
+  * Unsubscribe from shutdown events
+  */
+  off(event, listener) {
+    super.off(event, listener);
+  }
+};
+
+// src/bot/Bot.ts
+var Bot = class extends Plugin {
+  static {
+    __name(this, "Bot");
+  }
+  core;
+  logger = new Logger("Bot");
+  isInitialized = false;
+  _client;
+  interactions;
+  events;
+  commands;
+  emojiInjector;
+  constructor(core) {
+    super(core), this.core = core;
+    this._client = new discord_js.Client(core.config.bot.clientOptions);
+    this.interactions = new InteractionController(core);
+    this.events = new EventController(core);
+    this.commands = new CommandRegistry(this.core);
+    this.emojiInjector = new EmojiInjector(this.core);
+    this.core.shutdown.addTask(ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop());
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.isInitialized = true;
+    await this.login();
+    await this.interactions.init();
+    await this.events.init();
+    await this.commands.init();
+    await this.commands.setCommands();
+    await this.emojiInjector.init();
+  }
+  async stop() {
+    this._client.removeAllListeners();
+    await this.logout();
+  }
+  async login() {
+    await this._client.login(Globals.botToken);
+    this.logger.info(`Logged in as ${chalk6__default.default.bold.magenta(this._client.user?.username)}!`);
+    return this;
+  }
+  async logout() {
+    await this._client.destroy();
+    this.logger.info(chalk6__default.default.bold.red("Logged out of Discord!"));
+  }
+  get client() {
+    return this._client;
+  }
+};
+
+// src/hooks/decorators/RegisterHook.ts
+var HookMetadataKey = Symbol("hook:metadata");
+function RegisterHook(hook) {
+  return function(constructor) {
+    Reflect.defineMetadata(HookMetadataKey, hook, constructor);
+  };
+}
+__name(RegisterHook, "RegisterHook");
+
+// src/hooks/interfaces/HookHandler.ts
+var HookHandler = class {
+  static {
+    __name(this, "HookHandler");
+  }
+  data;
+  core;
+  constructor(data, core) {
+    this.data = data;
+    this.core = core;
+    this.data = data;
+    this.core = core;
+  }
+};
+
+// src/hooks/interfaces/abstracts/WebhookLog.ts
+var WebhookLog = class extends HookHandler {
+  static {
+    __name(this, "WebhookLog");
+  }
+  constructor(data, core) {
+    super(data, core);
+  }
+};
+
+// src/hooks/default/UnknownException.ts
+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_decorate3, "_ts_decorate");
+var UnknownException = class extends WebhookLog {
+  static {
+    __name(this, "UnknownException");
+  }
+  webhook = new discord_js.WebhookClient({
+    url: Globals.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
+      ]
+    });
+  }
+};
+UnknownException = _ts_decorate3([
+  RegisterHook("unknownException")
+], UnknownException);
+var UnhandledErrorEmbed = class UnhandledErrorEmbed2 extends BuilderComponent {
+  static {
+    __name(this, "UnhandledErrorEmbed");
+  }
+  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"}\`
+**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);
+  }
+  setTimestampsIfAvailable(error) {
+    if (!(error instanceof discord_js.DiscordAPIError)) return;
+    const now = Date.now();
+    const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
+    if (!snowflake) return void 0;
+    const interactionTs = Number(discord_js.SnowflakeUtil.deconstruct(snowflake).timestamp);
+    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})
+- **\`Error logged    \` :** ${new Date(now).toISOString()} (${now})
+- **\`Offset          \` :** ${seconds}s ${millis}ms`,
+        inline: true
+      }
+    ]);
+  }
+};
+var HookEmitter = class {
+  static {
+    __name(this, "HookEmitter");
+  }
+  emitter = new events.EventEmitter();
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  emit(event, data) {
+    return this.emitter.emit(event, data);
+  }
+};
+
+// src/hooks/HookController.ts
+var HookController = class extends Plugin {
+  static {
+    __name(this, "HookController");
+  }
+  core;
+  logger = new Logger("Hooks");
+  isInitialized = false;
+  hookMap = /* @__PURE__ */ new Map();
+  emitter = new HookEmitter();
+  constructor(core) {
+    super(core), this.core = core;
+  }
+  async init() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    const hooksDir = this.core.config.hooks.path;
+    this.logger.info(chalk6__default.default.bold(hooksDir));
+    this.registerHook("unknownException", UnknownException);
+    await this.loadHooks(hooksDir);
+    this.attachHooks();
+    const totalHooks = Array.from(this.hookMap.values()).reduce((acc, handlers) => acc + handlers.length, 0);
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${chalk6__default.default.bold.magenta(totalHooks)} hooks`);
+  }
+  async loadHooks(dir) {
+    await traverseDirectory(dir, (_fullPath, relativePath, imported) => {
+      for (const exportName of Object.keys(imported)) {
+        const val = imported[exportName];
+        if (this.isHookHandler(val)) {
+          const hookName = Reflect.getMetadata(HookMetadataKey, val);
+          if (hookName) {
+            this.registerHook(hookName, val);
+            this.logger.info(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(val.name)} from ${chalk6__default.default.gray(relativePath)}`);
+          }
+        }
+      }
+    });
+  }
+  registerHook(hookName, handler) {
+    let handlers = this.hookMap.get(hookName);
+    if (!handlers) {
+      handlers = [];
+      this.hookMap.set(hookName, handlers);
+    }
+    handlers.push(handler);
+  }
+  isHookHandler(obj) {
+    if (typeof obj !== "function") return false;
+    return obj.prototype instanceof HookHandler;
+  }
+  attachHooks() {
+    for (const [hookName, handlerCtors] of this.hookMap) {
+      this.emitter.on(hookName, (data) => {
+        for (const HandlerCtor of handlerCtors) {
+          try {
+            const instance = new HandlerCtor(data, this.core);
+            void instance.execute();
+          } catch (err) {
+            this.logger.error(`Error in hook ${String(hookName)} handler ${HandlerCtor.name}:`, err);
+          }
+        }
+      });
+    }
+  }
+  emit(event, data) {
+    return this.emitter.emit(event, data);
+  }
+};
+var HTTP_OK = 200;
+var HTTP_NOT_FOUND = 404;
+var HealthCheck = class extends Plugin {
+  static {
+    __name(this, "HealthCheck");
+  }
+  core;
+  logger = new Logger("HealthCheck");
+  port = Globals.healthCheckPort;
+  path = Globals.healthCheckPath;
+  server;
+  constructor(core) {
+    super(core), this.core = core;
+    this.core.shutdown.addTask(ShutdownPhase.StopServices, "stop-healthcheck-server", async () => await this.stop());
+  }
+  /**
+  * Starts the health check server.
+  * @returns Promise that resolves when the server is listening
+  */
+  async init() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        if (req.method === "GET" && req.url === this.path) {
+          res.writeHead(HTTP_OK, {
+            "Content-Type": "application/json"
+          });
+          res.end(JSON.stringify({
+            status: "ok",
+            timestamp: Date.now()
+          }));
+        } else {
+          res.writeHead(HTTP_NOT_FOUND, {
+            "Content-Type": "application/json"
+          });
+          res.end(JSON.stringify({
+            status: "not found"
+          }));
+        }
+      });
+      this.server.on("error", reject);
+      this.server.listen(this.port, () => {
+        this.logger.info(`${chalk6__default.default.green.bold("\u2713")} Health check server listening on ${chalk6__default.default.cyan(`http://localhost:${this.port}${this.path}`)}`);
+        resolve();
+      });
+    });
+  }
+  stop() {
+    return new Promise((shutdownResolve) => {
+      this.server?.close(() => {
+        this.logger.info(chalk6__default.default.bold.red("Health check server stopped"));
+        shutdownResolve();
+      });
+    });
+  }
+};
+var StartupPhase = /* @__PURE__ */ (function(StartupPhase2) {
+  StartupPhase2[StartupPhase2["Validation"] = 1] = "Validation";
+  StartupPhase2[StartupPhase2["Discovery"] = 2] = "Discovery";
+  StartupPhase2[StartupPhase2["Registration"] = 3] = "Registration";
+  StartupPhase2[StartupPhase2["Configuration"] = 4] = "Configuration";
+  StartupPhase2[StartupPhase2["Instantiation"] = 5] = "Instantiation";
+  StartupPhase2[StartupPhase2["Activation"] = 6] = "Activation";
+  StartupPhase2[StartupPhase2["Ready"] = 7] = "Ready";
+  return StartupPhase2;
+})({});
+var PHASE_ORDER2 = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7
+];
+var CoordinatedStartup = class extends CoordinatedLifecycle {
+  static {
+    __name(this, "CoordinatedStartup");
+  }
+  isStartingUp = false;
+  hasStarted = false;
+  constructor() {
+    super("CoordinatedStartup", PHASE_ORDER2, StartupPhase);
+  }
+  /**
+  * Add a task to a specific startup phase
+  */
+  addTask(phase, taskName, task, timeoutMs = 1e4) {
+    super.addTask(phase, taskName, task, timeoutMs);
+  }
+  canAddTask() {
+    if (this.hasStarted) {
+      throw new Error("Cannot add tasks after startup sequence has already completed");
+    }
+    if (this.isStartingUp) {
+      throw new Error("Cannot add tasks while startup sequence is in progress");
+    }
+    return true;
+  }
+  canRemoveTask() {
+    if (this.isStartingUp) {
+      throw new Error("Cannot remove tasks while startup sequence is in progress");
+    }
+    return true;
+  }
+  getTaskType() {
+    return "startup";
+  }
+  async executeTasksInPhase(phase, tasks) {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await Promise.resolve().then(() => this.runTaskWithTimeout(phase, task)).then(() => ({
+        status: "fulfilled",
+        value: void 0
+      }), (reason) => ({
+        status: "rejected",
+        reason
+      })));
+    }
+    return results;
+  }
+  /**
+  * Start the coordinated startup sequence
+  */
+  async run() {
+    if (this.hasStarted) {
+      this.logger.warn("Startup sequence has already completed");
+      return;
+    }
+    if (this.isStartingUp) {
+      this.logger.warn("Startup sequence already in progress");
+      return;
+    }
+    this.isStartingUp = true;
+    this.logger.info(`${chalk6__default.default.bold.green("Starting")} coordinated startup sequence`);
+    this.emit("startup:start");
+    try {
+      for (const phase of PHASE_ORDER2) await this.runPhase(phase);
+      this.hasStarted = true;
+      this.logger.info(`${chalk6__default.default.bold.green("Coordinated startup completed")} successfully`);
+      this.emit("startup:complete");
+    } catch (error) {
+      this.logger.error(`${chalk6__default.default.bold.red("Coordinated startup failed")}`);
+      this.emit("startup:error", error);
+      throw error;
+    } finally {
+      this.isStartingUp = false;
+    }
+  }
+  /**
+  * Subscribe to startup events
+  */
+  on(event, listener) {
+    super.on(event, listener);
+  }
+  /**
+  * Unsubscribe from startup events
+  */
+  off(event, listener) {
+    super.off(event, listener);
+  }
+  /**
+  * Check if startup has completed
+  */
+  get isReady() {
+    return this.hasStarted;
+  }
+  /**
+  * Check if startup is currently running
+  */
+  get isRunning() {
+    return this.isStartingUp;
+  }
+};
+
+// src/Seedcord.ts
+var Seedcord = class _Seedcord extends Pluggable {
+  static {
+    __name(this, "Seedcord");
+  }
+  config;
+  static isInstantiated = false;
+  shutdown;
+  startup;
+  hooks;
+  bot;
+  healthCheck;
+  constructor(config) {
+    const shutdown = new CoordinatedShutdown();
+    const startup = new CoordinatedStartup();
+    super(shutdown, startup), this.config = config;
+    this.shutdown = shutdown;
+    this.startup = startup;
+    if (_Seedcord.isInstantiated) {
+      throw new Error("Seedcord can only be instantiated once. Use the existing instance instead.");
+    }
+    _Seedcord.isInstantiated = true;
+    this.hooks = new HookController(this);
+    this.bot = new Bot(this);
+    this.healthCheck = new HealthCheck(this);
+    this.registerStartupTasks();
+  }
+  registerStartupTasks() {
+    this.startup.addTask(StartupPhase.Configuration, "Hook Initialization", async () => {
+      this.hooks.logger.info(chalk6__default.default.bold("Initializing"));
+      await this.hooks.init();
+      this.hooks.logger.info(chalk6__default.default.bold("Initialized"));
+    });
+    this.startup.addTask(StartupPhase.Instantiation, "Bot Initialization", async () => {
+      this.bot.logger.info(chalk6__default.default.bold("Initializing"));
+      await this.bot.init();
+      this.bot.logger.info(chalk6__default.default.bold("Initialized"));
+    });
+    this.startup.addTask(StartupPhase.Ready, "Health Check", async () => {
+      this.healthCheck.logger.info(chalk6__default.default.bold("Initializing"));
+      await this.healthCheck.init();
+      this.healthCheck.logger.info(chalk6__default.default.bold("Initialized"));
+    });
+  }
+  async start() {
+    await super.init();
+    return this;
+  }
+};
+
+// src/bot/decorators/Checkable.ts
+function Checkable(ctor) {
+  return class extends ctor {
+    static name = ctor.name;
+    checkable = true;
+  };
+}
+__name(Checkable, "Checkable");
+function EventCatchable(log) {
+  return function(_target, _prop, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = async function(...args) {
+      if (!original) throw new Error("Method not found");
+      try {
+        await original.apply(this, args);
+      } catch (err) {
+        if (!(err instanceof Error)) throw err;
+        this.setErrored();
+        if (log) console.error(err);
+        const eventArgs = Array.isArray(this.getEvent()) ? this.getEvent() : [
+          this.getEvent()
+        ];
+        const msg = eventArgs.find((x) => x instanceof discord_js.Message);
+        const result = ErrorHandlingUtils.handleError(err, this.core, msg?.guild ?? null, msg?.author ?? null);
+        if (!msg) return;
+        await msg.reply({
+          embeds: [
+            result.response
+          ],
+          components: []
+        });
+      }
+    };
+  };
+}
+__name(EventCatchable, "EventCatchable");
+
+// src/services/CooldownManager.ts
+var CooldownManager = class {
+  static {
+    __name(this, "CooldownManager");
+  }
+  window;
+  Err;
+  msg;
+  map = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.window = opts.cooldown ?? 1e3;
+    this.Err = opts.err ?? Error;
+    this.msg = opts.message ?? "Cooldown active";
+  }
+  /** Record usage without any checks. */
+  set(key) {
+    this.map.set(key, Date.now());
+  }
+  /**
+  * Verify cooldown for `key`.\
+  * If active → throws the custom error.\
+  * If not active → updates timestamp and returns void.
+  */
+  check(key) {
+    const now = Date.now();
+    const last = this.map.get(key);
+    const remaining = this.window - (now - (last ?? 0));
+    if (Globals.isDevelopment && remaining > 0) {
+      Logger.Debug("CooldownManager", `${key} - ${remaining}ms remaining`);
+    }
+    if (last !== void 0 && remaining > 0) {
+      throw new this.Err(this.msg, remaining);
+    }
+    this.map.set(key, now);
+  }
+  /** Returns true if the key is still cooling down (does not update timestamp). */
+  isActive(key) {
+    const last = this.map.get(key);
+    return last !== void 0 && Date.now() - last < this.window;
+  }
+  /** Remove a key from the map (useful for manual resets). */
+  clear(key) {
+    this.map.delete(key);
+  }
+};
+var ModelMetadataKey = Symbol("db:model");
+function DatabaseModel(collection) {
+  return (target, propertyKey) => {
+    const schema = target[propertyKey];
+    const name = String(collection);
+    const model = mongoose2__default.default.model(name, schema);
+    Reflect.defineMetadata(ModelMetadataKey, model, target);
+  };
+}
+__name(DatabaseModel, "DatabaseModel");
+
+// src/mongo/decorators/DatabaseService.ts
+var ServiceMetadataKey = Symbol("db:serviceKey");
+function DatabaseService(key) {
+  return (ctor) => {
+    Reflect.defineMetadata(ServiceMetadataKey, key, ctor);
+  };
+}
+__name(DatabaseService, "DatabaseService");
+
+// src/mongo/BaseService.ts
+var BaseService = class {
+  static {
+    __name(this, "BaseService");
+  }
+  db;
+  core;
+  model;
+  constructor(db, core) {
+    this.db = db;
+    this.core = core;
+    const ctor = this.constructor;
+    const key = Reflect.getMetadata(ServiceMetadataKey, ctor);
+    if (!key) throw new Error(`Missing @DatabaseService on ${ctor.name}`);
+    const model = Reflect.getMetadata(ModelMetadataKey, ctor);
+    if (!model) throw new Error(`Missing @DatabaseModel on ${ctor.name}`);
+    this.model = model;
+    db._register(key, this);
+  }
+};
+
+// src/mongo/Mongo.ts
+var Mongo = class extends Plugin {
+  static {
+    __name(this, "Mongo");
+  }
+  core;
+  options;
+  logger = new Logger("MongoDB");
+  isInitialised = false;
+  uri;
+  /**
+  * Map of all loaded services.
+  * Keys come from `@DatabaseService('key')`
+  */
+  services = {};
+  constructor(core, options) {
+    super(core), this.core = core, this.options = options;
+    this.uri = options.uri;
+    this.core.shutdown.addTask(ShutdownPhase.ExternalResources, "stop-database", async () => await this.stop());
+  }
+  async init() {
+    if (this.isInitialised) return;
+    this.isInitialised = true;
+    await this.connect();
+    await this.loadServices();
+  }
+  async stop() {
+    await this.disconnect();
+  }
+  async connect() {
+    await mongoose2__default.default.connect(this.uri, {
+      dbName: this.options.dbName,
+      ...Globals.isProduction && {
+        tls: true,
+        ssl: true
+      }
+    }).then((i) => this.logger.info(`Connected to MongoDB: ${chalk6__default.default.bold.magenta(i.connection.name)}`)).catch((err) => throwCustomError(err, "Could not connect to MongoDB", DatabaseConnectionFailure));
+  }
+  async disconnect() {
+    await mongoose2__default.default.disconnect().then(() => this.logger.info(chalk6__default.default.red.bold("Disconnected from MongoDB"))).catch((err) => this.logger.error(`Could not disconnect from MongoDB: ${err.message}`));
+  }
+  async loadServices() {
+    const servicesDir = this.options.servicesDir;
+    this.logger.info(chalk6__default.default.bold(servicesDir));
+    await traverseDirectory(servicesDir, (_full, rel, mod) => {
+      for (const Service of Object.values(mod)) {
+        if (this.isServiceClass(Service)) {
+          const instance = new Service(this, this.core);
+          this.logger.info(`${chalk6__default.default.italic("Registered")} ${chalk6__default.default.bold.yellow(instance.constructor.name)} from ${chalk6__default.default.gray(rel)}`);
+        }
+      }
+    });
+    this.logger.info(`${chalk6__default.default.bold.green("Loaded")}: ${chalk6__default.default.magenta(Object.keys(this.services).length)} services`);
+  }
+  isServiceClass(obj) {
+    return typeof obj === "function" && obj.prototype instanceof BaseService && Reflect.hasMetadata(ServiceMetadataKey, obj);
+  }
+  _register(key, instance) {
+    this.services[key] = instance;
+  }
+};
+
+// src/mongo/decorators/DBCatchable.ts
+function DBCatchable(errorMessage) {
+  return function(_target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      if (!originalMethod) {
+        throw new Error("Method not found");
+      }
+      try {
+        return await originalMethod.apply(this, args);
+      } catch (error) {
+        if (!(error instanceof CustomError)) {
+          throwCustomError(error, errorMessage, DatabaseError);
+        } else {
+          throw error;
+        }
+      }
+    };
+  };
+}
+__name(DBCatchable, "DBCatchable");
+
+exports.AutocompleteHandler = AutocompleteHandler;
+exports.AutocompleteRoute = AutocompleteRoute;
+exports.BaseErrorEmbed = BaseErrorEmbed;
+exports.BaseService = BaseService;
+exports.Bot = Bot;
+exports.BuilderComponent = BuilderComponent;
+exports.ButtonRoute = ButtonRoute;
+exports.Catchable = Catchable;
+exports.Checkable = Checkable;
+exports.CommandMetadataKey = CommandMetadataKey;
+exports.ContextMenuRoute = ContextMenuRoute;
+exports.CooldownManager = CooldownManager;
+exports.CoordinatedShutdown = CoordinatedShutdown;
+exports.CoordinatedStartup = CoordinatedStartup;
+exports.CustomError = CustomError;
+exports.DBCatchable = DBCatchable;
+exports.DatabaseModel = DatabaseModel;
+exports.DatabaseService = DatabaseService;
+exports.EventCatchable = EventCatchable;
+exports.EventHandler = EventHandler;
+exports.EventMetadataKey = EventMetadataKey;
+exports.Globals = Globals;
+exports.HealthCheck = HealthCheck;
+exports.HookController = HookController;
+exports.HookEmitter = HookEmitter;
+exports.HookHandler = HookHandler;
+exports.HookMetadataKey = HookMetadataKey;
+exports.InteractionHandler = InteractionHandler;
+exports.InteractionMetadataKey = InteractionMetadataKey;
+exports.InteractionMiddleware = InteractionMiddleware;
+exports.InteractionRoutes = InteractionRoutes;
+exports.Logger = Logger;
+exports.ModalComponent = ModalComponent;
+exports.ModalRoute = ModalRoute;
+exports.ModelMetadataKey = ModelMetadataKey;
+exports.Mongo = Mongo;
+exports.Pluggable = Pluggable;
+exports.Plugin = Plugin;
+exports.RegisterCommand = RegisterCommand;
+exports.RegisterEvent = RegisterEvent;
+exports.RegisterHook = RegisterHook;
+exports.RowComponent = RowComponent;
+exports.Seedcord = Seedcord;
+exports.SelectMenuRoute = SelectMenuRoute;
+exports.SelectMenuType = SelectMenuType;
+exports.ServiceMetadataKey = ServiceMetadataKey;
+exports.ShutdownPhase = ShutdownPhase;
+exports.SlashRoute = SlashRoute;
+exports.StartupPhase = StartupPhase;
+exports.WebhookLog = WebhookLog;
+exports.currentTime = currentTime;
+exports.formatWord = formatWord;
+exports.fyShuffle = fyShuffle;
+exports.generateAsciiTable = generateAsciiTable;
+exports.isTsOrJsFile = isTsOrJsFile;
+exports.longestStringLength = longestStringLength;
+exports.numberFixer = numberFixer;
+exports.ordinal = ordinal;
+exports.percentage = percentage;
+exports.prettify = prettify;
+exports.prettyDifference = prettyDifference;
+exports.throwCustomError = throwCustomError;
+exports.traverseDirectory = traverseDirectory;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map