vimcord 1.0.35 → 1.0.37

package/dist/index.js

@@ -5,6 +5,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/modules/validators/permissions.validator.ts
+import { BaseInteraction } from "discord.js";
+
 // src/types/command.base.ts
 var CommandType = /* @__PURE__ */ ((CommandType2) => {
   CommandType2[CommandType2["Slash"] = 0] = "Slash";
@@ -32,8 +35,7 @@ var RateLimitScope = /* @__PURE__ */ ((RateLimitScope2) => {
   return RateLimitScope2;
 })(RateLimitScope || {});
 
-// src/validators/permissions.validator.ts
-import { BaseInteraction } from "discord.js";
+// src/modules/validators/permissions.validator.ts
 function __existsAndTrue(value) {
   return value !== void 0 && value;
 }
@@ -132,8 +134,8 @@ function validateCommandPermissions(permissions, client, user, command) {
 }
 
 // src/builders/baseCommand.builder.ts
-import { randomUUID } from "crypto";
 import _ from "lodash";
+import { randomUUID } from "crypto";
 var BaseCommandBuilder = class {
   uuid = randomUUID();
   commandType;
@@ -423,55 +425,199 @@ var ContextCommandBuilder = class extends BaseCommandBuilder {
   }
 };
 
-// src/utils/dir.ts
-import path from "path";
-import { $ } from "qznt";
-function getCallerFileName() {
-  const stack = new Error().stack?.split("\n");
-  return stack?.at(4)?.split("at file")?.at(1)?.split("/").at(-1)?.split(":").at(0)?.split(".").at(0);
-}
-function getProcessDir() {
-  const mainPath = process.argv[1];
-  if (!mainPath) return "";
-  return path.dirname(mainPath);
-}
-async function importModulesFromDir(dir, suffix) {
-  const cwd = getProcessDir();
-  const MODULE_RELATIVE_PATH = path.join(cwd, dir);
-  const MODULE_LOG_PATH = dir;
-  const files = $.fs.readDir(MODULE_RELATIVE_PATH).filter((fn) => fn.endsWith(`${suffix ? `.${suffix}` : ""}.js`) || fn.endsWith(`${suffix ? `.${suffix}` : ""}.ts`));
-  if (!files.length) {
-    return [];
+// src/builders/event.builder.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import _3 from "lodash";
+
+// src/tools/Logger.ts
+import chalk from "chalk";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["SUCCESS"] = 2] = "SUCCESS";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var LOGGER_COLORS = {
+  primary: "#5865F2",
+  success: "#57F287",
+  warn: "#FEE75C",
+  danger: "#ED4245",
+  muted: "#747F8D",
+  text: "#FFFFFF"
+};
+var Logger = class {
+  logPrefixEmoji;
+  logPrefix;
+  minLevel;
+  showTimestamp;
+  colorScheme;
+  constructor(options) {
+    const { prefixEmoji = null, prefix = null, minLevel = 0 /* DEBUG */, showTimestamp = true } = options || {};
+    this.logPrefixEmoji = prefixEmoji;
+    this.logPrefix = prefix;
+    this.minLevel = minLevel;
+    this.showTimestamp = showTimestamp;
+    this.colorScheme = {
+      ...LOGGER_COLORS,
+      ...options?.colors
+    };
   }
-  const modules = await Promise.all(
-    files.map(async (fn) => {
-      let _path = path.join(MODULE_RELATIVE_PATH, fn);
-      let _logPath = `./${path.join(MODULE_LOG_PATH, fn)}`;
-      let _module;
-      try {
-        delete __require.cache[__require.resolve(_path)];
-        _module = __require(_path);
-      } catch (err) {
-        console.warn(`Failed to import module at '${_logPath}'`, err);
-        _module = null;
+  formatTimestamp() {
+    if (!this.showTimestamp) return "";
+    const now = /* @__PURE__ */ new Date();
+    const time = now.toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    return chalk.hex(this.colorScheme.muted)(`[${time}]`);
+  }
+  formatPrefix() {
+    if (!this.logPrefix) return "";
+    return chalk.bold.hex(this.colorScheme.primary)(
+      `${this.logPrefixEmoji ? `${this.logPrefixEmoji} ` : ""}${this.logPrefix}`
+    );
+  }
+  shouldLog(level) {
+    return level >= this.minLevel;
+  }
+  get prefixEmoji() {
+    return this.logPrefixEmoji;
+  }
+  get prefix() {
+    return this.logPrefix;
+  }
+  get colors() {
+    return this.colorScheme;
+  }
+  extend(extras) {
+    for (const [key, fn] of Object.entries(extras)) {
+      if (typeof fn === "function") {
+        this[key] = function(...args) {
+          return fn.call(this, ...args);
+        };
       }
-      return { module: _module, path: _logPath };
-    })
-  );
-  const filteredModules = modules.filter((m) => m.module);
-  if (!filteredModules.length) {
-    console.warn(`No valid modules were found in directory '${dir}'`);
+    }
+    return this;
   }
-  return filteredModules;
-}
+  setPrefix(prefix) {
+    this.logPrefix = prefix;
+    return this;
+  }
+  setPrefixEmoji(prefixEmoji) {
+    this.logPrefixEmoji = prefixEmoji;
+    return this;
+  }
+  setMinLevel(minLevel) {
+    this.minLevel = minLevel;
+    return this;
+  }
+  setShowTimestamp(show) {
+    this.showTimestamp = show;
+    return this;
+  }
+  setColors(colors) {
+    this.colorScheme = {
+      ...LOGGER_COLORS,
+      ...colors
+    };
+    return this;
+  }
+  log(message, ...args) {
+    console.log(this.formatTimestamp(), this.formatPrefix(), message, ...args);
+  }
+  debug(message, ...args) {
+    if (!this.shouldLog(0 /* DEBUG */)) return;
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk.hex(this.colorScheme.muted)("DEBUG"),
+      chalk.dim(message),
+      ...args
+    );
+  }
+  info(message, ...args) {
+    if (!this.shouldLog(1 /* INFO */)) return;
+    console.log(this.formatTimestamp(), this.formatPrefix(), chalk.hex("#87CEEB")("INFO"), message, ...args);
+  }
+  success(message, ...args) {
+    if (!this.shouldLog(2 /* SUCCESS */)) return;
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk.bold.hex(this.colorScheme.success)("\u2713 SUCCESS"),
+      chalk.hex(this.colorScheme.success)(message),
+      ...args
+    );
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog(3 /* WARN */)) return;
+    console.warn(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk.bold.hex(this.colorScheme.warn)("\u26A0 WARN"),
+      chalk.hex(this.colorScheme.warn)(message),
+      ...args
+    );
+  }
+  error(message, error, ...args) {
+    if (!this.shouldLog(4 /* ERROR */)) return;
+    console.error(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk.bold.hex(this.colorScheme.danger)("\u2715 ERROR"),
+      chalk.hex(this.colorScheme.danger)(message),
+      ...args
+    );
+    if (error && error.stack) {
+      console.error(chalk.dim(error.stack));
+    }
+  }
+  loader(message) {
+    const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    let i = 0;
+    const interval = setInterval(() => {
+      process.stdout.write(
+        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${chalk.hex(this.colorScheme.warn)(frames[i])} ${message}`
+      );
+      i = (i + 1) % frames.length;
+    }, 100);
+    return (newMessage) => {
+      clearInterval(interval);
+      process.stdout.write(
+        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${chalk.hex(this.colorScheme.success)("\u2713")} ${newMessage || message}
+`
+      );
+    };
+  }
+  table(title, data) {
+    console.log(this.formatTimestamp(), this.formatPrefix(), chalk.bold(title));
+    Object.entries(data).forEach(([key, value]) => {
+      const formattedKey = chalk.hex(this.colorScheme.warn)(`  ${key}`);
+      const formattedValue = chalk.hex(this.colorScheme.muted)(value);
+      console.log(`${formattedKey.padEnd(25)} ${formattedValue}`);
+    });
+  }
+  section(title) {
+    const line = "\u2500".repeat(Math.max(30, title.length + 4));
+    console.log(chalk.hex(this.colorScheme.muted)(`
+\u250C\u2500${line}\u2500\u2510`));
+    console.log(
+      chalk.hex(this.colorScheme.muted)("\u2502  ") + chalk.bold.hex(this.colorScheme.text)(title.padEnd(line.length)) + chalk.hex(this.colorScheme.muted)("  \u2502")
+    );
+    console.log(chalk.hex(this.colorScheme.muted)(`\u2514\u2500${line}\u2500\u2518`));
+  }
+};
+var logger = new Logger();
 
 // src/builders/event.builder.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import _3 from "lodash";
 var EventBuilder = class _EventBuilder {
   uuid = randomUUID2();
   event;
-  name = getCallerFileName() || this.uuid;
+  name = this.uuid;
   enabled;
   once;
   priority;
@@ -636,6 +782,7 @@ var EventBuilder = class _EventBuilder {
         return;
       }
       if (this.isRateLimited()) {
+        logger.warn(`Event '${this.name}' (${this.event}) is rate limited`);
         if (this.rateLimit?.onRateLimit) {
           return await this.rateLimit.onRateLimit(...args);
         }
@@ -656,7 +803,7 @@ var EventBuilder = class _EventBuilder {
       if (this.onError) {
         return await this.onError(err, ...args);
       }
-      console.error(`Error in event '${this.name}':`, err);
+      logger.error(`Event execution error '${this.name}' (${this.event}):`, err);
       throw err;
     }
   }
@@ -759,7 +906,11 @@ var SlashCommandBuilder = class extends BaseCommandBuilder {
     if (subCommand) {
       const handler = this.routes.get(subCommand.toLowerCase());
       if (handler) return await handler(client, interaction);
-      if (config.onUnknownRouteHandler) return await config.onUnknownRouteHandler(client, interaction);
+      if (config.onUnknownRouteHandler) {
+        return await config.onUnknownRouteHandler(client, interaction);
+      } else {
+        return await interaction.reply({ content: `Unknown subcommand: ${subCommand}`, flags: "Ephemeral" });
+      }
     }
     return await originalExecute?.(client, interaction);
   }
@@ -818,21 +969,119 @@ var SlashCommandBuilder = class extends BaseCommandBuilder {
   }
 };
 
-// src/client.ts
-import { Client as Client2 } from "discord.js";
-import dotEnv from "dotenv";
+// src/modules/builtins/context-command.builtins.ts
+var contextCommandHandler = new EventBuilder({
+  event: "interactionCreate",
+  name: "ContextCommandHandler",
+  async execute(client, interaction) {
+    if (!interaction.isContextMenuCommand()) return;
+    const command = client.commands.context.get(interaction.commandName);
+    if (!command) {
+      const content = `**${interaction.commandName}** is not a registered context command.`;
+      if (interaction.replied || interaction.deferred) {
+        return interaction.followUp({ content, flags: "Ephemeral" });
+      }
+      return interaction.reply({ content, flags: "Ephemeral" });
+    }
+    try {
+      return await command.run(client, client, interaction);
+    } catch (err) {
+      await client.error.handleCommandError(err, interaction.guild, interaction);
+    }
+  }
+});
 
-// src/configs/tools.config.ts
-import _5 from "lodash";
-var globalVimcordToolsConfig = {
-  devMode: false,
-  embedColor: [],
-  embedColorDev: [],
-  timeouts: {
-    collectorTimeout: 6e4,
-    collectorIdle: 6e4,
-    pagination: 6e4,
-    prompt: 3e4,
+// src/modules/builtins/prefix-command.builtins.ts
+import { userMention } from "discord.js";
+var prefixCommandHandler = new EventBuilder({
+  event: "messageCreate",
+  name: "PrefixCommandHandler",
+  async execute(client, message) {
+    if (message.author.bot || !message.guild) return;
+    const config = client.config.prefixCommands;
+    let activePrefix = config.defaultPrefix;
+    if (config.guildPrefixResolver) {
+      try {
+        const customPrefix = await config.guildPrefixResolver(client, message.guild.id);
+        if (customPrefix) activePrefix = customPrefix;
+      } catch (err) {
+        client.logger.error(`Error in guildPrefixResolver for guild ${message.guild.id}:`, err);
+      }
+    }
+    let prefixUsed;
+    if (message.content.startsWith(activePrefix)) {
+      prefixUsed = activePrefix;
+    } else if (config.allowMentionAsPrefix) {
+      const mention = userMention(client.user.id);
+      if (message.content.startsWith(mention)) {
+        prefixUsed = message.content.startsWith(`${mention} `) ? `${mention} ` : mention;
+      }
+    }
+    if (!prefixUsed) return;
+    const contentWithoutPrefix = message.content.slice(prefixUsed.length).trim();
+    const args = contentWithoutPrefix.split(/\s+/);
+    const trigger = args.shift();
+    if (!trigger) return;
+    const command = client.commands.prefix.get(trigger);
+    if (!command) return;
+    message.content = args.join(" ");
+    try {
+      return await command.run(client, client, message);
+    } catch (err) {
+      await client.error.handleCommandError(err, message.guild, message);
+    }
+  }
+});
+
+// src/modules/builtins/slash-command.builtins.ts
+var slashCommandHandler = new EventBuilder({
+  event: "interactionCreate",
+  name: "SlashCommandHandler",
+  async execute(client, interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    const command = client.commands.slash.get(interaction.commandName);
+    if (!command) {
+      const content = `**/\`${interaction.commandName}\`** is not a registered command.`;
+      if (interaction.replied || interaction.deferred) {
+        return interaction.followUp({ content, flags: "Ephemeral" });
+      }
+      return interaction.reply({ content, flags: "Ephemeral" });
+    }
+    try {
+      return await command.run(client, client, interaction);
+    } catch (err) {
+      await client.error.handleCommandError(err, interaction.guild, interaction);
+    }
+  }
+});
+
+// src/tools/BetterEmbed.ts
+import {
+  EmbedBuilder,
+  GuildMember as GuildMember3,
+  User as User3
+} from "discord.js";
+
+// src/utils/config.factory.ts
+import _5 from "lodash";
+function createConfigFactory(defaultConfig6, validate) {
+  return (options = {}, existing) => {
+    const result = _5.merge({}, defaultConfig6, existing, options);
+    validate?.(result);
+    return result;
+  };
+}
+
+// src/configs/tools.config.ts
+var globalToolsConfig = {
+  devMode: false,
+  embedColor: [],
+  embedColorDev: [],
+  timeouts: {
+    collectorTimeout: 6e4,
+    collectorIdle: 6e4,
+    pagination: 6e4,
+    prompt: 3e4,
     modalSubmit: 6e4
   },
   collector: {
@@ -859,103 +1108,10 @@ var globalVimcordToolsConfig = {
     rejectLabel: "Cancel"
   }
 };
-function defineGlobalToolsConfig(options) {
-  Object.assign(globalVimcordToolsConfig, _5.merge(globalVimcordToolsConfig, options));
-}
-function createToolsConfig(options) {
-  return _5.merge(globalVimcordToolsConfig, options);
-}
-
-// src/configs/app.config.ts
-import _6 from "lodash";
-var defaultConfig = {
-  devMode: process.argv.includes("--dev"),
-  name: "Discord Bot",
-  appVersion: "1.0.0",
-  verbose: false,
-  disableBanner: false,
-  moduleSuffixes: {
-    slashCommand: "slash",
-    contextCommand: "ctx",
-    prefixCommand: "prefix",
-    event: "event"
-  }
-};
-function createVimcordAppConfig(options = {}) {
-  return _6.merge(defaultConfig, options);
-}
-
-// src/configs/staff.config.ts
-import _7 from "lodash";
-var defaultConfig2 = {
-  ownerId: null,
-  superUsers: [],
-  superUserRoles: [],
-  bypassers: [],
-  bypassesGuildAdmin: {
-    allBotStaff: false,
-    botOwner: false,
-    superUsers: false,
-    bypassers: false
-  },
-  guild: {
-    id: null,
-    inviteUrl: null,
-    channels: {}
-  }
-};
-function createVimcordStaffConfig(options = {}) {
-  return _7.merge(defaultConfig2, options);
-}
-
-// src/configs/slashCommand.config.ts
-import _8 from "lodash";
-var defaultConfig3 = {
-  logExecution: true
-};
-function createVimcordSlashCommandConfig(options = {}) {
-  return _8.merge(defaultConfig3, options);
-}
-
-// src/configs/prefixCommand.config.ts
-import _9 from "lodash";
-var defaultConfig4 = {
-  enabled: true,
-  defaultPrefix: "!",
-  allowMentionAsPrefix: true,
-  allowCaseInsensitiveCommandNames: true,
-  logExecution: true
-};
-function createVimcordPrefixCommandConfig(options = {}) {
-  return _9.merge(defaultConfig4, options);
-}
-
-// src/configs/contextCommand.config.ts
-import _10 from "lodash";
-var defaultConfig5 = {
-  enabled: true,
-  logExecution: true
+var createToolsConfig = createConfigFactory(globalToolsConfig);
+var defineGlobalToolsConfig = (options) => {
+  Object.assign(globalToolsConfig, createToolsConfig(options, globalToolsConfig));
 };
-function createVimcordContextCommandConfig(options = {}) {
-  return _10.merge(defaultConfig5, options);
-}
-
-// src/utils/sendCommandErrorEmbed.ts
-import {
-  ActionRowBuilder as ActionRowBuilder2,
-  AttachmentBuilder,
-  ButtonBuilder,
-  ButtonStyle,
-  ComponentType,
-  Message as Message3
-} from "discord.js";
-
-// src/tools/BetterEmbed.ts
-import {
-  EmbedBuilder,
-  GuildMember as GuildMember3,
-  User as User3
-} from "discord.js";
 
 // src/tools/dynaSend.ts
 import {
@@ -1172,7 +1328,7 @@ var BetterEmbed = class _BetterEmbed {
    * - __`$month`__: _M or MM_
    * - __`$day`__: _D or DD_ */
   constructor(data = {}) {
-    this.config = data.config || globalVimcordToolsConfig;
+    this.config = data.config ? createToolsConfig(data.config) : globalToolsConfig;
     this.data = {
       context: data.context || null,
       author: data.author || null,
@@ -1411,7 +1567,15 @@ var BetterEmbed = class _BetterEmbed {
   }
 };
 
-// src/utils/sendCommandErrorEmbed.ts
+// src/utils/command-error.utils.ts
+import {
+  ActionRowBuilder as ActionRowBuilder2,
+  AttachmentBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ComponentType,
+  Message as Message3
+} from "discord.js";
 async function sendCommandErrorEmbed(client, error, guild, messageOrInteraction) {
   if (!client.features.enableCommandErrorMessage) return null;
   const config = typeof client.features.enableCommandErrorMessage !== "boolean" ? client.features.enableCommandErrorMessage : void 0;
@@ -1436,7 +1600,8 @@ async function sendCommandErrorEmbed(client, error, guild, messageOrInteraction)
     title: "Something went wrong",
     description: "If you keep encountering this error, please report it."
   });
-  const msg = await embed_error.send(messageOrInteraction, {
+  const msg = await dynaSend(messageOrInteraction, {
+    embeds: [embed_error],
     components: [actionRow],
     flags: config?.ephemeral ? "Ephemeral" : void 0,
     deleteAfter: config?.deleteAfter
@@ -1457,7 +1622,8 @@ ${error.stack}`), {
   });
   collector.on("end", () => {
     buttons.details.setDisabled(true);
-    embed_error.send(messageOrInteraction, {
+    dynaSend(messageOrInteraction, {
+      embeds: [embed_error],
       sendMethod: messageOrInteraction instanceof Message3 ? 5 /* MessageEdit */ : void 0,
       components: [actionRow]
     });
@@ -1465,529 +1631,326 @@ ${error.stack}`), {
   return msg;
 }
 
-// src/modules/builtins/builtin.slashCommandHandler.ts
-var BUILTIN_SlashCommandHandler = new EventBuilder({
-  event: "interactionCreate",
-  name: "SlashCommandHandler",
-  async execute(client, interaction) {
-    if (!interaction.isChatInputCommand()) return;
-    const command = client.commands.slash.get(interaction.commandName);
-    if (!command) {
-      const content = `**/\`${interaction.commandName}\`** is not a registered command.`;
-      if (interaction.replied || interaction.deferred) {
-        return interaction.followUp({ content, flags: "Ephemeral" });
-      }
-      return interaction.reply({ content, flags: "Ephemeral" });
-    }
-    try {
-      return await command.run(client, client, interaction);
-    } catch (err) {
-      await sendCommandErrorEmbed(client, err, interaction.guild, interaction);
-      throw err;
-    }
+// src/client/error-handler.ts
+var ErrorHandler = class {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-});
+  /** Handles command errors - sends error embed to user, then rethrows. */
+  async handleCommandError(error, guild, messageOrInteraction) {
+    await sendCommandErrorEmbed(this.client, error, guild, messageOrInteraction);
+    throw error;
+  }
+  /** Handles internal Vimcord errors - logs with [Vimcord] prefix. */
+  handleVimcordError(error, context) {
+    this.client.logger.error(`[Vimcord] [${context}]`, error);
+  }
+  /** Sets up global process error handlers. */
+  setupGlobalHandlers() {
+    process.on("uncaughtException", (err) => this.handleVimcordError(err, "Uncaught Exception"));
+    process.on("unhandledRejection", (err) => this.handleVimcordError(err, "Unhandled Rejection"));
+    process.on("exit", (code) => this.client.logger.debug(`Process exited with code ${code}`));
+    this.client.on("error", (err) => this.handleVimcordError(err, "Client Error"));
+    this.client.on("shardError", (err) => this.handleVimcordError(err, "Client Shard Error"));
+  }
+};
 
-// src/modules/builtins/builtin.prefixCommandHandler.ts
-import { userMention } from "discord.js";
-var BUILTIN_PrefixCommandHandler = new EventBuilder({
-  event: "messageCreate",
-  name: "PrefixCommandHandler",
-  async execute(client, message) {
-    if (message.author.bot || !message.guild) return;
-    const config = client.config.prefixCommands;
-    let activePrefix = config.defaultPrefix;
-    if (config.guildPrefixResolver) {
-      try {
-        const customPrefix = await config.guildPrefixResolver(client, message.guild.id);
-        if (customPrefix) activePrefix = customPrefix;
-      } catch (err) {
-        client.logger.error(`Error in guildPrefixResolver for guild ${message.guild.id}:`, err);
-      }
-    }
-    let prefixUsed;
-    if (message.content.startsWith(activePrefix)) {
-      prefixUsed = activePrefix;
-    } else if (config.allowMentionAsPrefix) {
-      const mention = userMention(client.user.id);
-      if (message.content.startsWith(mention)) {
-        prefixUsed = message.content.startsWith(`${mention} `) ? `${mention} ` : mention;
-      }
-    }
-    if (!prefixUsed) return;
-    const contentWithoutPrefix = message.content.slice(prefixUsed.length).trim();
-    const args = contentWithoutPrefix.split(/\s+/);
-    const trigger = args.shift();
-    if (!trigger) return;
-    const command = client.commands.prefix.get(trigger);
-    if (!command) return;
-    message.content = args.join(" ");
-    try {
-      return await command.run(client, client, message);
-    } catch (err) {
-      await sendCommandErrorEmbed(client, err, message.guild, message);
-      throw err;
-    }
+// src/client/vimcord.logger.ts
+import chalk2 from "chalk";
+
+// package.json
+var version = "1.0.37";
+
+// src/client/vimcord.logger.ts
+var clientLoggerFactory = (client) => new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${client.clientId})` }).extend({
+  clientBanner(client2) {
+    if (client2.config.app.disableBanner) return;
+    const border = "\u2550".repeat(50);
+    console.log(chalk2.hex(this.colors.primary)(`
+\u2554${border}\u2557`));
+    console.log(
+      chalk2.hex(this.colors.primary)("\u2551") + chalk2.bold.hex(this.colors.text)(
+        `  \u{1F680} ${client2.config.app.name} v${client2.$version}`.padEnd(50 - (client2.$devMode ? 12 : 0))
+      ) + chalk2.hex(this.colors.primary)(`${client2.$devMode ? chalk2.hex(this.colors.warn)("devMode \u26A0\uFE0F   ") : ""}\u2551`)
+    );
+    console.log(chalk2.hex(this.colors.primary)(`\u2551${"".padEnd(50)}\u2551`));
+    console.log(
+      chalk2.hex(this.colors.primary)("\u2551") + chalk2.hex(this.colors.muted)(
+        `  # Powered by Vimcord v${version}`.padEnd(50 - 3 - `${client2.clientId}`.length)
+      ) + chalk2.hex(this.colors.primary)(`${chalk2.hex(this.colors.muted)(`i${client2.clientId}`)}  \u2551`)
+    );
+    console.log(chalk2.hex(this.colors.primary)(`\u255A${border}\u255D
+`));
+  },
+  clientReady(clientTag, guildCount) {
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk2.hex(this.colors.success)("\u{1F916} READY"),
+      chalk2.white(`Connected as ${chalk2.bold.hex(this.colors.primary)(clientTag)}`),
+      chalk2.hex(this.colors.muted)(`\u2022 ${guildCount} guilds`)
+    );
+  },
+  moduleLoaded(moduleName, count, ignoredCount) {
+    const countText = count ? chalk2.hex(this.colors.muted)(`(${count} items)`) : "";
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk2.hex("#9B59B6")("\u{1F4E6} MODULE"),
+      chalk2.hex(this.colors.warn)(`${moduleName} loaded`),
+      ignoredCount ? chalk2.hex(this.colors.muted)(`(${ignoredCount} ignored)`) : "",
+      countText
+    );
+  },
+  commandExecuted(commandName, username, guildName) {
+    const location = guildName ? `in ${chalk2.hex(this.colors.muted)(guildName)}` : "in DMs";
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk2.hex("#87CEEB")("\u{1F4DD} COMMAND"),
+      chalk2.hex(this.colors.warn)(`/${commandName}`),
+      chalk2.white(`used by ${chalk2.bold(username)}`),
+      chalk2.hex(this.colors.muted)(location)
+    );
+  },
+  database(action, details) {
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      chalk2.hex("#FF6B9D")("\u{1F5C4}\uFE0F  DATABASE"),
+      chalk2.white(action),
+      details ? chalk2.hex(this.colors.muted)(details) : ""
+    );
   }
 });
 
-// src/modules/builtins/builtin.contextCommandHandler.ts
-var BUILTIN_ContextCommandHandler = new EventBuilder({
-  event: "interactionCreate",
-  name: "ContextCommandHandler",
-  async execute(client, interaction) {
-    if (!interaction.isContextMenuCommand()) return;
-    const command = client.commands.context.get(interaction.commandName);
-    if (!command) {
-      const content = `**${interaction.commandName}** is not a registered context command.`;
-      if (interaction.replied || interaction.deferred) {
-        return interaction.followUp({ content, flags: "Ephemeral" });
-      }
-      return interaction.reply({ content, flags: "Ephemeral" });
-    }
-    try {
-      return await command.run(client, client, interaction);
-    } catch (err) {
-      await sendCommandErrorEmbed(client, err, interaction.guild, interaction);
-      throw err;
-    }
-  }
+// src/utils/process.utils.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function getPackageJson() {
+  return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8"));
+}
+function getDevMode() {
+  return process.argv.includes("--dev");
+}
+
+// src/configs/app.config.ts
+var defaultConfig = {
+  name: "Discord Bot",
+  version: getPackageJson()?.version ?? "1.0.0",
+  devMode: getDevMode(),
+  verbose: false,
+  enableCLI: false,
+  disableBanner: false
+};
+var createAppConfig = createConfigFactory(defaultConfig, (config) => {
+  if (!config.name) throw new Error("App name is required");
+  defineGlobalToolsConfig({ devMode: config.devMode });
 });
 
-// src/tools/Logger.ts
-import chalk from "chalk";
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["SUCCESS"] = 2] = "SUCCESS";
-  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
-  return LogLevel2;
-})(LogLevel || {});
-var LOGGER_COLORS = {
-  primary: "#5865F2",
-  success: "#57F287",
-  warn: "#FEE75C",
-  danger: "#ED4245",
-  muted: "#747F8D",
-  text: "#FFFFFF"
+// src/configs/contextCommand.config.ts
+var defaultConfig2 = {
+  enabled: true,
+  logExecution: true
 };
-var Logger = class {
-  logPrefixEmoji;
-  logPrefix;
-  minLevel;
-  showTimestamp;
-  colorScheme;
-  constructor(options) {
-    const { prefixEmoji = null, prefix = null, minLevel = 0 /* DEBUG */, showTimestamp = true } = options || {};
-    this.logPrefixEmoji = prefixEmoji;
-    this.logPrefix = prefix;
-    this.minLevel = minLevel;
-    this.showTimestamp = showTimestamp;
-    this.colorScheme = {
-      ...LOGGER_COLORS,
-      ...options?.colors
-    };
-  }
-  formatTimestamp() {
-    if (!this.showTimestamp) return "";
-    const now = /* @__PURE__ */ new Date();
-    const time = now.toLocaleTimeString("en-US", {
-      hour12: false,
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit"
-    });
-    return chalk.hex(this.colorScheme.muted)(`[${time}]`);
-  }
-  formatPrefix() {
-    if (!this.logPrefix) return "";
-    return chalk.bold.hex(this.colorScheme.primary)(
-      `${this.logPrefixEmoji ? `${this.logPrefixEmoji} ` : ""}${this.logPrefix}`
-    );
-  }
-  shouldLog(level) {
-    return level >= this.minLevel;
-  }
-  get prefixEmoji() {
-    return this.logPrefixEmoji;
-  }
-  get prefix() {
-    return this.logPrefix;
-  }
-  get colors() {
-    return this.colorScheme;
-  }
-  extend(extras) {
-    for (const [key, fn] of Object.entries(extras)) {
-      if (typeof fn === "function") {
-        this[key] = function(...args) {
-          return fn.call(this, ...args);
-        };
-      }
-    }
-    return this;
-  }
-  setPrefix(prefix) {
-    this.logPrefix = prefix;
-    return this;
-  }
-  setPrefixEmoji(prefixEmoji) {
-    this.logPrefixEmoji = prefixEmoji;
-    return this;
-  }
-  setMinLevel(minLevel) {
-    this.minLevel = minLevel;
-    return this;
-  }
-  setShowTimestamp(show) {
-    this.showTimestamp = show;
-    return this;
-  }
-  setColors(colors) {
-    this.colorScheme = {
-      ...LOGGER_COLORS,
-      ...colors
-    };
-    return this;
-  }
-  log(message, ...args) {
-    console.log(this.formatTimestamp(), this.formatPrefix(), message, ...args);
-  }
-  debug(message, ...args) {
-    if (!this.shouldLog(0 /* DEBUG */)) return;
-    console.log(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      chalk.hex(this.colorScheme.muted)("DEBUG"),
-      chalk.dim(message),
-      ...args
-    );
-  }
-  info(message, ...args) {
-    if (!this.shouldLog(1 /* INFO */)) return;
-    console.log(this.formatTimestamp(), this.formatPrefix(), chalk.hex("#87CEEB")("INFO"), message, ...args);
-  }
-  success(message, ...args) {
-    if (!this.shouldLog(2 /* SUCCESS */)) return;
-    console.log(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      chalk.bold.hex(this.colorScheme.success)("\u2713 SUCCESS"),
-      chalk.hex(this.colorScheme.success)(message),
-      ...args
-    );
-  }
-  warn(message, ...args) {
-    if (!this.shouldLog(3 /* WARN */)) return;
-    console.warn(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      chalk.bold.hex(this.colorScheme.warn)("\u26A0 WARN"),
-      chalk.hex(this.colorScheme.warn)(message),
-      ...args
-    );
-  }
-  error(message, error, ...args) {
-    if (!this.shouldLog(4 /* ERROR */)) return;
-    console.error(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      chalk.bold.hex(this.colorScheme.danger)("\u2715 ERROR"),
-      chalk.hex(this.colorScheme.danger)(message),
-      ...args
-    );
-    if (error && error.stack) {
-      console.error(chalk.dim(error.stack));
-    }
-  }
-  loader(message) {
-    const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-    let i = 0;
-    const interval = setInterval(() => {
-      process.stdout.write(
-        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${chalk.hex(this.colorScheme.warn)(frames[i])} ${message}`
-      );
-      i = (i + 1) % frames.length;
-    }, 100);
-    return (newMessage) => {
-      clearInterval(interval);
-      process.stdout.write(
-        `\r${this.formatTimestamp()} ${this.formatPrefix()} ${chalk.hex(this.colorScheme.success)("\u2713")} ${newMessage || message}
-`
-      );
-    };
-  }
-  table(title, data) {
-    console.log(this.formatTimestamp(), this.formatPrefix(), chalk.bold(title));
-    Object.entries(data).forEach(([key, value]) => {
-      const formattedKey = chalk.hex(this.colorScheme.warn)(`  ${key}`);
-      const formattedValue = chalk.hex(this.colorScheme.muted)(value);
-      console.log(`${formattedKey.padEnd(25)} ${formattedValue}`);
-    });
-  }
-  section(title) {
-    const line = "\u2500".repeat(Math.max(30, title.length + 4));
-    console.log(chalk.hex(this.colorScheme.muted)(`
-\u250C\u2500${line}\u2500\u2510`));
-    console.log(
-      chalk.hex(this.colorScheme.muted)("\u2502  ") + chalk.bold.hex(this.colorScheme.text)(title.padEnd(line.length)) + chalk.hex(this.colorScheme.muted)("  \u2502")
-    );
-    console.log(chalk.hex(this.colorScheme.muted)(`\u2514\u2500${line}\u2500\u2518`));
-  }
+var createContextCommandConfig = createConfigFactory(defaultConfig2);
+
+// src/configs/prefixCommand.config.ts
+var defaultConfig3 = {
+  enabled: true,
+  defaultPrefix: "!",
+  allowMentionAsPrefix: true,
+  allowCaseInsensitiveCommandNames: true,
+  logExecution: true
 };
-var logger = new Logger();
+var createPrefixCommandConfig = createConfigFactory(defaultConfig3);
 
-// src/tools/utils.ts
-function __zero(str) {
-  return str?.length ? str : "0";
-}
-function isMentionOrSnowflake(str) {
-  return str ? str.match(/<@[#&]?[\d]{6,}>/) || str.match(/\d{6,}/) ? true : false : false;
-}
-function cleanMention(str) {
-  return str ? str.replaceAll(/[<@#&>]/g, "").trim() : void 0;
-}
-async function getMessageMention(message, content, type, index = 0, idOnly) {
-  const args = content?.split(" ");
-  const arg = isMentionOrSnowflake(args?.[index]) ? cleanMention(args?.[index]) : void 0;
-  switch (type) {
-    case "user":
-      const userMention2 = message.mentions.users.at(index) || null;
-      if (!userMention2 && arg) {
-        return idOnly ? arg : await fetchUser(message.client, arg);
-      } else {
-        return idOnly ? userMention2?.id || null : userMention2;
-      }
-    case "member":
-      if (!message.guild) return null;
-      const member = await fetchMember(message.guild, message.mentions.users.at(index)?.id ?? arg);
-      return idOnly ? member?.id || null : member;
-    case "channel":
-      const channelMention = message.mentions.channels.at(index) || null;
-      if (!channelMention && arg) {
-        return idOnly ? arg : message.guild ? await fetchChannel(message.guild, arg) : message.client.channels.cache.get(__zero(arg)) ?? message.client.channels.fetch(__zero(arg));
-      } else {
-        return idOnly ? channelMention?.id || null : channelMention;
-      }
-    case "role":
-      const roleMention = message.mentions.roles.at(index) || null;
-      if (!roleMention && arg) {
-        return idOnly ? arg : message.guild ? await fetchRole(message.guild, arg) : null;
-      } else {
-        return idOnly ? roleMention?.id || null : roleMention;
-      }
-    default:
-      return null;
-  }
-}
-function getFirstMentionId(options) {
-  let mentionId = "";
-  if (options.message) {
-    switch (options.type) {
-      case "user":
-        mentionId = options.message.mentions.users.first()?.id || "";
-        break;
-      case "channel":
-        mentionId = options.message.mentions.channels.first()?.id || "";
-        break;
-      case "role":
-        mentionId = options.message.mentions.roles.first()?.id || "";
-        break;
-    }
+// src/configs/slashCommand.config.ts
+var defaultConfig4 = {
+  logExecution: true
+};
+var createSlashCommandConfig = createConfigFactory(defaultConfig4);
+
+// src/configs/staff.config.ts
+var defaultConfig5 = {
+  ownerId: null,
+  superUsers: [],
+  superUserRoles: [],
+  bypassers: [],
+  bypassesGuildAdmin: {
+    allBotStaff: false,
+    botOwner: false,
+    superUsers: false,
+    bypassers: false
+  },
+  guild: {
+    id: null,
+    inviteUrl: null,
+    channels: {}
   }
-  const firstArg = options.content?.split(" ")[0] || "";
-  return mentionId || isMentionOrSnowflake(firstArg) ? cleanMention(firstArg) : "";
-}
-async function fetchUser(client, userId) {
-  if (!userId) return null;
-  return client.users.cache.get(__zero(userId)) || await client.users.fetch(__zero(userId)).catch(() => null);
-}
-async function fetchGuild(client, guildId) {
-  if (!guildId) return null;
-  return client.guilds.cache.get(__zero(guildId)) || await client.guilds.fetch(__zero(guildId)).catch(() => null);
-}
-async function fetchMember(guild, memberId) {
-  if (!memberId) return null;
-  return guild.members.cache.get(__zero(memberId)) || await guild.members.fetch(__zero(memberId)).catch(() => null);
-}
-async function fetchChannel(guild, channelId, type) {
-  if (!channelId) return null;
-  const channel = guild.channels.cache.get(__zero(channelId)) || await guild.channels.fetch(__zero(channelId)).catch(() => null);
-  if (type && channel?.type !== type) return null;
-  return channel;
-}
-async function fetchRole(guild, roleId) {
-  if (!roleId) return null;
-  return guild.roles.cache.get(__zero(roleId)) || await guild.roles.fetch(__zero(roleId)).catch(() => null) || null;
-}
-async function fetchMessage(channel, messageId) {
-  if (!messageId) return null;
-  return channel.messages.cache.get(__zero(messageId)) || await channel.messages.fetch(__zero(messageId)).catch(() => null) || null;
-}
+};
+var createStaffConfig = createConfigFactory(defaultConfig5);
 
-// src/types/status.ts
-import { ActivityType } from "discord.js";
-import _11 from "lodash";
-var StatusType = /* @__PURE__ */ ((StatusType2) => {
-  StatusType2["DND"] = "dnd";
-  StatusType2["Idle"] = "idle";
-  StatusType2["Online"] = "online";
-  StatusType2["Invisible"] = "invisible";
-  return StatusType2;
-})(StatusType || {});
-var defaultPresence = {
-  production: {
-    interval: 6e4,
-    randomize: false,
-    activity: [
-      { status: "online" /* Online */, type: ActivityType.Custom, name: "Need help? Use /help or !help" },
-      { status: "online" /* Online */, type: ActivityType.Custom, name: "Join our community!" },
-      { status: "online" /* Online */, type: ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
-    ]
+// src/client/vimcord.utils.ts
+var DEFAULT_MODULE_SUFFIXES = {
+  slashCommands: ".slash",
+  contextCommands: ".ctx",
+  prefixCommands: ".prefix",
+  events: ".event"
+};
+var configSetters = {
+  app: createAppConfig,
+  staff: createStaffConfig,
+  slashCommands: createSlashCommandConfig,
+  prefixCommands: createPrefixCommandConfig,
+  contextCommands: createContextCommandConfig
+};
+var moduleImporters = {
+  slashCommands: (client, options, set) => {
+    const opt = options;
+    const dir = Array.isArray(options) ? options : opt?.dir ?? [];
+    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.slashCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.slashCommands;
+    return client.commands.slash.importFrom(dir, set, suffix);
   },
-  development: {
-    activity: { status: "dnd" /* DND */, type: ActivityType.Custom, name: "In development!" }
+  contextCommands: (client, options, set) => {
+    const opt = options;
+    const dir = Array.isArray(options) ? options : opt?.dir ?? [];
+    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.contextCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.contextCommands;
+    return client.commands.context.importFrom(dir, set, suffix);
+  },
+  prefixCommands: (client, options, set) => {
+    const opt = options;
+    const dir = Array.isArray(options) ? options : opt?.dir ?? [];
+    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.prefixCommands : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.prefixCommands;
+    return client.commands.prefix.importFrom(dir, set, suffix);
+  },
+  events: (client, options, set) => {
+    const opt = options;
+    const dir = Array.isArray(options) ? options : opt?.dir ?? [];
+    const suffix = Array.isArray(options) ? DEFAULT_MODULE_SUFFIXES.events : opt?.suffix ?? DEFAULT_MODULE_SUFFIXES.events;
+    return client.events.importFrom(dir, set, suffix);
   }
 };
-function createVimcordStatusConfig(options = {}) {
-  return _11.merge(defaultPresence, options);
+function defineClientOptions(options) {
+  return options;
+}
+function defineVimcordFeatures(features) {
+  return features;
+}
+function defineVimcordConfig(config) {
+  return {
+    app: createAppConfig(config.app),
+    staff: createStaffConfig(config.staff),
+    slashCommands: createSlashCommandConfig(config.slashCommands),
+    prefixCommands: createPrefixCommandConfig(config.prefixCommands),
+    contextCommands: createContextCommandConfig(config.contextCommands)
+  };
 }
+var useClient = Vimcord.getInstance;
+var useReadyClient = Vimcord.getReadyInstance;
+var createClient = Vimcord.create;
 
-// src/modules/status.manager.ts
-import EventEmitter from "events";
-import { $ as $2 } from "qznt";
-var StatusManager = class {
-  client;
-  logger;
-  emitter = new EventEmitter();
-  lastActivity = null;
-  lastActivityIndex = 0;
-  task = null;
-  constructor(client) {
-    this.client = client;
-    this.logger = new Logger({ prefixEmoji: "\u{1F4AC}", prefix: `StatusManager (i${this.client.clientId})` });
-    this.emitter.on("changed", (activity) => {
-      if (this.client.config.app.verbose) {
-        this.logger.debug(`Status changed to '${activity.name}'`);
-      }
-    });
-    this.emitter.on("cleared", () => {
-      if (this.client.config.app.verbose) {
-        this.logger.debug("Status cleared");
-      }
-    });
-  }
-  clearData() {
-    this.task?.stop();
-    this.task = null;
-    this.lastActivity = null;
-    this.lastActivityIndex = 0;
-    return this;
-  }
-  async getReadyClient() {
-    const client = await this.client.waitForReady();
-    if (!client.user) throw new Error("Cannot manage the client's activity when its user is not hydrated");
-    return client;
-  }
-  async formatActivityName(name) {
-    name = name.replace("$USER_COUNT", $2.format.number(this.client.users.cache.size)).replace("$GUILD_COUNT", $2.format.number(this.client.guilds.cache.size)).replace(
-      "$INVITE",
-      this.client.config.staff.guild.inviteUrl ? this.client.config.staff.guild.inviteUrl : "<STAFF_INVITE_URL_NOT_SET>"
-    );
-    if (name.includes("$STAFF_GUILD_MEMBER_COUNT")) {
-      await fetchGuild(this.client, this.client.config.staff.guild.id).then((guild) => {
-        if (!guild) return name = name.replace("$STAFF_GUILD_MEMBER_COUNT", "<STAFF_GUILD_NOT_FOUND>");
-        name = name.replace("$STAFF_GUILD_MEMBER_COUNT", $2.format.number(guild.members.cache.size));
-      }).catch((err) => this.logger.error("Failed to fetch the staff guild", err));
-    }
-    return name;
-  }
-  async setActivity(activity) {
-    const client = await this.getReadyClient();
-    activity.name = await this.formatActivityName(activity.name);
-    client.user.setStatus(activity.status);
-    client.user.setActivity({ name: activity.name, type: activity.type, url: activity.streamUrl });
-    this.emitter.emit("changed", activity);
-  }
-  async statusRotationTask(clientStatus) {
-    let activity;
-    if (clientStatus.randomize && Array.isArray(clientStatus.activity)) {
-      activity = $2.rnd.choice(clientStatus.activity, { not: this.lastActivity });
-      this.lastActivity = activity;
-    } else {
-      const activityIndex = (this.lastActivityIndex + 1) % clientStatus.activity.length;
-      this.lastActivityIndex = activityIndex;
-      activity = clientStatus.activity[activityIndex];
-    }
-    await this.setActivity(activity);
-    this.emitter.emit("rotation", activity);
-  }
-  async scheduleStatusRotation(clientStatus) {
-    if (!clientStatus.interval) throw new Error("Cannot create client activity interval without interval time");
-    this.task?.stop();
-    this.task = null;
-    this.task = new $2.Loop(() => this.statusRotationTask(clientStatus), $2.math.ms(clientStatus.interval), true);
-    this.start();
-  }
-  start() {
-    if (this.task) {
-      this.task.start();
-      this.emitter.emit("started", this.task);
-    }
-    return this;
-  }
-  pause() {
-    if (this.task) {
-      this.task.stop();
-      this.emitter.emit("paused", this.task);
-    }
-    return this;
+// src/modules/command.manager.ts
+import { Routes } from "discord.js";
+
+// src/utils/import.utils.ts
+import path from "path";
+import { $ } from "qznt";
+function getProcessDir() {
+  const mainPath = process.argv[1];
+  if (!mainPath) return "";
+  return path.dirname(mainPath);
+}
+async function importModulesFromDir(dir, suffix) {
+  const cwd = getProcessDir();
+  const MODULE_RELATIVE_PATH = path.join(cwd, dir);
+  const MODULE_LOG_PATH = dir;
+  const files = $.fs.readDir(MODULE_RELATIVE_PATH).filter((fn) => fn.endsWith(`${suffix ? `.${suffix}` : ""}.js`) || fn.endsWith(`${suffix ? `.${suffix}` : ""}.ts`));
+  if (!files.length) {
+    return [];
   }
-  async set(status) {
-    const statusConfig = createVimcordStatusConfig(status);
-    let clientStatus;
-    if (this.client.config.app.devMode) {
-      clientStatus = statusConfig.development;
-    } else {
-      clientStatus = statusConfig.production;
-    }
-    if (!clientStatus.interval) {
-      await this.setActivity(Array.isArray(clientStatus.activity) ? clientStatus.activity[0] : clientStatus.activity);
-    } else {
-      await this.scheduleStatusRotation(clientStatus);
-    }
-    return this;
+  const modules = await Promise.all(
+    files.map(async (fn) => {
+      let _path = path.join(MODULE_RELATIVE_PATH, fn);
+      let _logPath = `./${path.join(MODULE_LOG_PATH, fn)}`;
+      let _module;
+      try {
+        delete __require.cache[__require.resolve(_path)];
+        _module = __require(_path);
+      } catch (err) {
+        console.warn(`Failed to import module at '${_logPath}'`, err);
+        _module = null;
+      }
+      return { module: _module, path: _logPath };
+    })
+  );
+  const filteredModules = modules.filter((m) => m.module);
+  if (!filteredModules.length) {
+    console.warn(`No valid modules were found in directory '${dir}'`);
   }
-  async destroy() {
-    if (this.task) {
-      this.task.stop();
-      this.task = null;
-      this.emitter.emit("destroyed");
-      await this.clear();
-    }
-    return this;
+  return filteredModules;
+}
+
+// src/modules/base-module.importer.ts
+var ModuleImporter = class {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async clear() {
-    const client = await this.getReadyClient();
-    this.clearData();
-    client.user.setActivity({ name: "" });
-    this.emitter.emit("cleared");
-    return this;
+  async importFrom(dir, set = false, suffix) {
+    if (set) this.items.clear();
+    const dirs = Array.isArray(dir) ? dir : [dir];
+    const modules = [];
+    const effectiveSuffix = Array.isArray(suffix) ? suffix[0] : suffix ?? this.itemSuffix;
+    for (const _dir of dirs) {
+      const results = await importModulesFromDir(_dir, effectiveSuffix ?? void 0);
+      modules.push(...results.map(({ module }) => module.default));
+    }
+    for (const module of modules) {
+      const name = this.getName(module);
+      this.items.set(name, module);
+    }
+    this.client.logger.moduleLoaded(this.itemName, modules.length);
+    return this.items;
   }
 };
 
 // src/modules/command.manager.ts
-import { Routes } from "discord.js";
-var BaseCommandManager = class {
+var BaseCommandManager = class extends ModuleImporter {
   type;
-  client;
-  commands = /* @__PURE__ */ new Map();
-  moduleSuffix;
-  constructor(client, type, moduleSuffix) {
+  items = /* @__PURE__ */ new Map();
+  itemSuffix;
+  constructor(client, type, itemSuffix) {
+    super(client);
     this.type = type;
-    this.client = client;
-    this.moduleSuffix = moduleSuffix;
+    switch (type) {
+      case 0 /* Slash */:
+        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.slashCommands;
+        break;
+      case 2 /* Context */:
+        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.contextCommands;
+        break;
+      case 1 /* Prefix */:
+        this.itemSuffix = itemSuffix ?? DEFAULT_MODULE_SUFFIXES.prefixCommands;
+        break;
+    }
+  }
+  get commands() {
+    return this.items;
+  }
+  get itemName() {
+    switch (this.type) {
+      case 0 /* Slash */:
+        return "Slash Commands";
+      case 2 /* Context */:
+        return "Context Commands";
+      case 1 /* Prefix */:
+        return "Prefix Commands";
+    }
+  }
+  getName(module) {
+    return "builder" in module ? module.builder.name : module.options.name;
   }
   /**
    * Gets a command by name.
@@ -1996,7 +1959,7 @@ var BaseCommandManager = class {
     if (this.type === 1 /* Prefix */) {
       const config = this.client.config.prefixCommands;
       const search = config.allowCaseInsensitiveCommandNames ? name.toLowerCase() : name;
-      return Array.from(this.commands.values()).find((cmd) => {
+      return Array.from(this.items.values()).find((cmd) => {
         const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
         const trigger = config.allowCaseInsensitiveCommandNames ? commandName.toLowerCase() : commandName;
         if (trigger === search) return true;
@@ -2007,7 +1970,7 @@ var BaseCommandManager = class {
         }
       });
     } else {
-      return this.commands.get(name);
+      return this.items.get(name);
     }
   }
   /**
@@ -2016,7 +1979,7 @@ var BaseCommandManager = class {
   getAll(options = {}) {
     const matchedCommands = /* @__PURE__ */ new Map();
     const isDev = this.client.config.app.devMode;
-    for (const cmd of this.commands.values()) {
+    for (const cmd of this.items.values()) {
       const commandName = "builder" in cmd ? cmd.builder.name : cmd.options.name;
       if (options.names || options.fuzzyNames) {
         const nameMatched = options.names?.includes(commandName) || options.fuzzyNames?.some((fuzzy) => commandName.includes(fuzzy));
@@ -2043,7 +2006,7 @@ var BaseCommandManager = class {
    */
   sortByCategory() {
     const categories = /* @__PURE__ */ new Map();
-    for (const cmd of this.commands.values()) {
+    for (const cmd of this.items.values()) {
       const metadata = cmd.options.metadata;
       if (!metadata?.category) continue;
       let entry = categories.get(metadata.category);
@@ -2066,52 +2029,20 @@ var BaseCommandManager = class {
       return cat;
     });
   }
-  /**
-   * Imports command modules from a directory.
-   * @param dir Path of one or more folders.
-   * @param set Replaces imported command modules with the ones found.
-   */
-  async importFrom(dir, set = false) {
-    if (set) this.commands.clear();
-    const dirs = Array.isArray(dir) ? dir : [dir];
-    const modules = [];
-    for (const _dir of dirs) {
-      const results = await importModulesFromDir(_dir, this.moduleSuffix);
-      modules.push(...results.map(({ module }) => module.default));
-    }
-    for (const module of modules) {
-      const commandName = "builder" in module ? module.builder.name : module.options.name;
-      this.commands.set(commandName, module);
-    }
-    let moduleType;
-    switch (this.type) {
-      case 0 /* Slash */:
-        moduleType = "Slash Commands";
-        break;
-      case 2 /* Context */:
-        moduleType = "Context Commands";
-        break;
-      case 1 /* Prefix */:
-        moduleType = "Prefix Commands";
-        break;
-    }
-    this.client.logger.moduleLoaded(moduleType, modules.length);
-    return this.commands;
-  }
 };
 var SlashCommandManager = class extends BaseCommandManager {
   constructor(client) {
-    super(client, 0 /* Slash */, client.config.app.moduleSuffixes.slashCommand);
+    super(client, 0 /* Slash */);
   }
 };
 var ContextCommandManager = class extends BaseCommandManager {
   constructor(client) {
-    super(client, 2 /* Context */, client.config.app.moduleSuffixes.contextCommand);
+    super(client, 2 /* Context */);
   }
 };
 var PrefixCommandManager = class extends BaseCommandManager {
   constructor(client) {
-    super(client, 1 /* Prefix */, client.config.app.moduleSuffixes.prefixCommand);
+    super(client, 1 /* Prefix */);
   }
 };
 var CommandManager = class {
@@ -2129,7 +2060,7 @@ var CommandManager = class {
     return [...this.slash.getAll(options), ...this.context.getAll(options)];
   }
   async registerGlobal(options = {}) {
-    const client = await this.client.waitForReady();
+    const client = await Vimcord.getReadyInstance(this.client.clientId);
     if (!client.rest) {
       console.error(`[CommandManager] \u2716 Failed to register app commands globally: REST is not initialized`);
       return;
@@ -2139,16 +2070,21 @@ var CommandManager = class {
       console.log("[CommandManager] No commands to register globally");
       return;
     }
-    console.log(`[CommandManager] Registering (${commands.length}) commands globally...`);
+    console.log(
+      `[CommandManager] Registering (${commands.length}) ${commands.length === 1 ? "command" : "commands"} globally...`
+    );
     try {
       await client.rest.put(Routes.applicationCommands(client.user.id), { body: commands });
-      console.log(`[CommandManager] \u2714 Registered app commands globally`);
+      console.log(`[CommandManager] \u2714 Registered app ${commands.length === 1 ? "command" : "commands"} globally`);
     } catch (err) {
-      console.error(`[CommandManager] \u2716 Failed to register app commands globally`, err);
+      console.error(
+        `[CommandManager] \u2716 Failed to register app ${commands.length === 1 ? "command" : "commands"} globally`,
+        err
+      );
     }
   }
   async unregisterGlobal() {
-    const client = await this.client.waitForReady();
+    const client = await Vimcord.getReadyInstance(this.client.clientId);
     if (!client.rest) {
       console.error(`[CommandManager] \u2716 Failed to remove app commands globally: REST is not initialized`);
       return;
@@ -2161,7 +2097,7 @@ var CommandManager = class {
     }
   }
   async registerGuild(options = {}) {
-    const client = await this.client.waitForReady();
+    const client = await Vimcord.getReadyInstance(this.client.clientId);
     if (!client.rest) {
       console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
       return;
@@ -2172,21 +2108,28 @@ var CommandManager = class {
       return;
     }
     const guildIds = options.guilds || client.guilds.cache.map((g) => g.id);
-    console.log(`[CommandManager] Registering (${commands.length}) commands for ${guildIds.length} guilds...`);
+    console.log(
+      `[CommandManager] Registering (${commands.length}) ${commands.length === 1 ? "command" : "commands"} for ${guildIds.length} guilds...`
+    );
     await Promise.all(
       guildIds.map(
         (guildId) => client.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
           const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(`[CommandManager] \u2714 Set app commands in guild: ${guildId} (${gName})`);
+          console.log(
+            `[CommandManager] \u2714 Set app ${commands.length === 1 ? "command" : "commands"} in guild: ${guildId} (${gName})`
+          );
         }).catch((err) => {
           const gName = client.guilds.cache.get(guildId)?.name || "n/a";
-          console.log(`[CommandManager] \u2716 Failed to set app commands in guild: ${guildId} (${gName})`, err);
+          console.log(
+            `[CommandManager] \u2716 Failed to set app ${commands.length === 1 ? "command" : "commands"} in guild: ${guildId} (${gName})`,
+            err
+          );
         })
       )
     );
   }
   async unregisterGuild(options = {}) {
-    const client = await this.client.waitForReady();
+    const client = await Vimcord.getReadyInstance(this.client.clientId);
     if (!client.rest) {
       console.error(`[CommandManager] \u2716 Failed to register app commands by guild: REST is not initialized`);
       return;
@@ -2203,12 +2146,13 @@ var CommandManager = class {
 
 // src/modules/event.manager.ts
 import { Events } from "discord.js";
-var EventManager = class {
-  client;
-  events = /* @__PURE__ */ new Map();
+var EventManager = class extends ModuleImporter {
+  items = /* @__PURE__ */ new Map();
+  itemSuffix = "event";
+  itemName = "Event Handlers";
   logger;
   constructor(client) {
-    this.client = client;
+    super(client);
     this.logger = new Logger({ prefixEmoji: "\u{1F4CB}", prefix: `EventManager (i${this.client.clientId})` });
     for (const event of Object.values(Events)) {
       client.on(
@@ -2217,9 +2161,12 @@ var EventManager = class {
       );
     }
   }
+  getName(module) {
+    return module.name;
+  }
   register(...events) {
     for (const event of events) {
-      this.events.set(event.name, event);
+      this.items.set(event.name, event);
       if (this.client.config.app.verbose) {
         this.logger.debug(`'${event.name}' registered for EventType '${event.event}'`);
       }
@@ -2227,95 +2174,348 @@ var EventManager = class {
   }
   unregister(...names) {
     for (const name of names) {
-      const event = this.events.get(name);
+      const event = this.items.get(name);
       if (!event) continue;
-      this.events.delete(name);
+      this.items.delete(name);
       if (this.client.config.app.verbose) {
         this.logger.debug(`'${event.name}' unregistered for EventType '${event.event}'`);
       }
     }
   }
-  clear() {
-    this.events.forEach((e) => this.unregister(e.name));
-    this.events.clear();
+  clear() {
+    this.items.forEach((e) => this.unregister(e.name));
+    this.items.clear();
+  }
+  get(name) {
+    return this.items.get(name);
+  }
+  getByTag(tag) {
+    return Array.from(this.items.values()).filter((event) => event.metadata?.tags?.includes(tag));
+  }
+  getByCategory(category) {
+    return Array.from(this.items.values()).filter((event) => event.metadata?.category?.includes(category));
+  }
+  getByEvent(eventType) {
+    return Array.from(this.items.values()).filter((event) => event.event === eventType);
+  }
+  async executeEvents(eventType, ...args) {
+    const events = this.getByEvent(eventType);
+    if (!events.length) return;
+    const sortedEvents = events.sort((a, b) => b.priority - a.priority);
+    await Promise.all(
+      sortedEvents.map(async (event) => {
+        try {
+          await event.execute?.(this.client, ...args);
+          if (event.once) {
+            this.unregister(event.name);
+          }
+        } catch (err) {
+          this.logger.error(`'${event.name}' failed to execute`, err);
+        }
+      })
+    );
+  }
+};
+
+// src/tools/utils.ts
+var MENTION_OR_SNOWFLAKE_REGEX = /<@[#&]?[\d]{6,}>|[\d]{6,}/;
+var fetchUserPromises = /* @__PURE__ */ new Map();
+var fetchGuildPromises = /* @__PURE__ */ new Map();
+var fetchMemberPromises = /* @__PURE__ */ new Map();
+var fetchChannelPromises = /* @__PURE__ */ new Map();
+var fetchMessagePromises = /* @__PURE__ */ new Map();
+var fetchRolePromises = /* @__PURE__ */ new Map();
+function createCachedFetch(cache, fetchFn, cacheKey) {
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+  const promise = fetchFn().finally(() => cache.delete(cacheKey));
+  cache.set(cacheKey, promise);
+  return promise;
+}
+function __zero(str) {
+  return str?.length ? str : "0";
+}
+function isMentionOrSnowflake(str) {
+  return str ? MENTION_OR_SNOWFLAKE_REGEX.test(str) : false;
+}
+function cleanMention(str) {
+  return str ? str.replaceAll(/[<@#&>]/g, "").trim() : void 0;
+}
+async function getMessageMention(message, content, type, index = 0, idOnly) {
+  const args = content?.split(" ");
+  const arg = isMentionOrSnowflake(args?.[index]) ? cleanMention(args?.[index]) : void 0;
+  switch (type) {
+    case "user": {
+      const userMention2 = message.mentions.users.at(index) || null;
+      if (!userMention2 && arg) {
+        return idOnly ? arg : await fetchUser(message.client, arg);
+      }
+      return idOnly ? userMention2?.id || null : userMention2;
+    }
+    case "member": {
+      if (!message.guild) return null;
+      const member = await fetchMember(message.guild, message.mentions.users.at(index)?.id ?? arg);
+      return idOnly ? member?.id || null : member;
+    }
+    case "channel": {
+      const channelMention = message.mentions.channels.at(index) || null;
+      if (!channelMention && arg) {
+        if (idOnly) return arg;
+        const channel = message.guild ? await fetchChannel(message.guild, arg) : message.client.channels.cache.get(__zero(arg)) ?? message.client.channels.fetch(__zero(arg));
+        return channel;
+      }
+      return idOnly ? channelMention?.id || null : channelMention;
+    }
+    case "role": {
+      const roleMention = message.mentions.roles.at(index) || null;
+      if (!roleMention && arg) {
+        if (idOnly) return arg;
+        return message.guild ? await fetchRole(message.guild, arg) : null;
+      }
+      return idOnly ? roleMention?.id || null : roleMention;
+    }
+    default:
+      return null;
+  }
+}
+function getFirstMentionId(options) {
+  let mentionId = "";
+  if (options.message) {
+    switch (options.type) {
+      case "user":
+        mentionId = options.message.mentions.users.first()?.id || "";
+        break;
+      case "member":
+        mentionId = options.message.mentions.members?.first()?.id || "";
+        break;
+      case "channel":
+        mentionId = options.message.mentions.channels.first()?.id || "";
+        break;
+      case "role":
+        mentionId = options.message.mentions.roles.first()?.id || "";
+        break;
+    }
+  }
+  const firstArg = options.content?.split(" ")[0] || "";
+  return mentionId || isMentionOrSnowflake(firstArg) ? cleanMention(firstArg) : "";
+}
+async function fetchUser(client, userId) {
+  if (!userId) return null;
+  const key = `${client.user.id}-${userId}`;
+  const cached = client.users.cache.get(__zero(userId));
+  if (cached) return cached;
+  return createCachedFetch(fetchUserPromises, () => client.users.fetch(__zero(userId)).catch(() => null), key);
+}
+async function fetchGuild(client, guildId) {
+  if (!guildId) return null;
+  const key = `${client.user.id}-${guildId}`;
+  const cached = client.guilds.cache.get(__zero(guildId));
+  if (cached) return cached;
+  return createCachedFetch(fetchGuildPromises, () => client.guilds.fetch(__zero(guildId)).catch(() => null), key);
+}
+async function fetchMember(guild, memberId) {
+  if (!memberId) return null;
+  const key = `${guild.id}-${memberId}`;
+  const cached = guild.members.cache.get(__zero(memberId));
+  if (cached) return cached;
+  return createCachedFetch(fetchMemberPromises, () => guild.members.fetch(__zero(memberId)).catch(() => null), key);
+}
+async function fetchChannel(guild, channelId, type) {
+  if (!channelId) return null;
+  const key = `${guild.id}-${channelId}`;
+  const cached = guild.channels.cache.get(__zero(channelId)) ?? null;
+  if (cached) {
+    if (type && cached.type !== type) return null;
+    return cached;
+  }
+  const channel = await createCachedFetch(
+    fetchChannelPromises,
+    () => guild.channels.fetch(__zero(channelId)).catch(() => null),
+    key
+  );
+  if (type && channel?.type !== type) return null;
+  return channel;
+}
+async function fetchMessage(channel, messageId) {
+  if (!messageId) return null;
+  const key = `${channel.guild.id}-${messageId}`;
+  const cached = channel.messages.cache.get(__zero(messageId));
+  if (cached) return cached;
+  return createCachedFetch(fetchMessagePromises, () => channel.messages.fetch(__zero(messageId)).catch(() => null), key);
+}
+async function fetchRole(guild, roleId) {
+  if (!roleId) return null;
+  const key = `${guild.id}-${roleId}`;
+  const cached = guild.roles.cache.get(__zero(roleId));
+  if (cached) return cached;
+  return createCachedFetch(fetchRolePromises, () => guild.roles.fetch(__zero(roleId)).catch(() => null), key);
+}
+
+// src/types/status.ts
+import { ActivityType } from "discord.js";
+import _6 from "lodash";
+var StatusType = /* @__PURE__ */ ((StatusType2) => {
+  StatusType2["DND"] = "dnd";
+  StatusType2["Idle"] = "idle";
+  StatusType2["Online"] = "online";
+  StatusType2["Invisible"] = "invisible";
+  return StatusType2;
+})(StatusType || {});
+var defaultPresence = {
+  production: {
+    interval: 6e4,
+    randomize: false,
+    activity: [
+      { status: "online" /* Online */, type: ActivityType.Custom, name: "Need help? Use /help or !help" },
+      { status: "online" /* Online */, type: ActivityType.Custom, name: "Join our community!" },
+      { status: "online" /* Online */, type: ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
+    ]
+  },
+  development: {
+    activity: { status: "dnd" /* DND */, type: ActivityType.Custom, name: "In development!" }
+  }
+};
+function createVimcordStatusConfig(options = {}) {
+  return _6.merge(defaultPresence, options);
+}
+
+// src/modules/status.manager.ts
+import EventEmitter from "events";
+import { $ as $2 } from "qznt";
+var StatusManager = class {
+  client;
+  logger;
+  emitter = new EventEmitter();
+  lastActivity = null;
+  lastActivityIndex = 0;
+  task = null;
+  constructor(client) {
+    this.client = client;
+    this.logger = new Logger({ prefixEmoji: "\u{1F4AC}", prefix: `StatusManager (i${this.client.clientId})` });
+    this.emitter.on("changed", (activity) => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug(`Status changed to '${activity.name}'`);
+      }
+    });
+    this.emitter.on("cleared", () => {
+      if (this.client.config.app.verbose) {
+        this.logger.debug("Status cleared");
+      }
+    });
+  }
+  clearData() {
+    this.task?.stop();
+    this.task = null;
+    this.lastActivity = null;
+    this.lastActivityIndex = 0;
+    return this;
+  }
+  async getReadyClient() {
+    const client = await Vimcord.getReadyInstance(this.client.clientId);
+    if (!client.user) throw new Error("Cannot manage the client's activity when its user is not hydrated");
+    return client;
+  }
+  async formatActivityName(name) {
+    name = name.replace("$USER_COUNT", $2.format.number(this.client.users.cache.size)).replace("$GUILD_COUNT", $2.format.number(this.client.guilds.cache.size)).replace(
+      "$INVITE",
+      this.client.config.staff.guild.inviteUrl ? this.client.config.staff.guild.inviteUrl : "<STAFF_INVITE_URL_NOT_SET>"
+    );
+    if (name.includes("$STAFF_GUILD_MEMBER_COUNT")) {
+      await fetchGuild(this.client, this.client.config.staff.guild.id).then((guild) => {
+        if (!guild) return name = name.replace("$STAFF_GUILD_MEMBER_COUNT", "<STAFF_GUILD_NOT_FOUND>");
+        name = name.replace("$STAFF_GUILD_MEMBER_COUNT", $2.format.number(guild.members.cache.size));
+      }).catch((err) => this.logger.error("Failed to fetch the staff guild", err));
+    }
+    return name;
+  }
+  async setActivity(activity) {
+    const client = await this.getReadyClient();
+    activity.name = await this.formatActivityName(activity.name);
+    client.user.setStatus(activity.status);
+    client.user.setActivity({ name: activity.name, type: activity.type, url: activity.streamUrl });
+    this.emitter.emit("changed", activity);
   }
-  get(name) {
-    return this.events.get(name);
+  async statusRotationTask(clientStatus) {
+    let activity;
+    if (clientStatus.randomize && Array.isArray(clientStatus.activity)) {
+      activity = $2.rnd.choice(clientStatus.activity, { not: this.lastActivity });
+      this.lastActivity = activity;
+    } else {
+      const activityIndex = (this.lastActivityIndex + 1) % clientStatus.activity.length;
+      this.lastActivityIndex = activityIndex;
+      activity = clientStatus.activity[activityIndex];
+    }
+    await this.setActivity(activity);
+    this.emitter.emit("rotation", activity);
   }
-  getByTag(tag) {
-    return Array.from(this.events.values()).filter((event) => event.metadata?.tags?.includes(tag));
+  async scheduleStatusRotation(clientStatus) {
+    if (!clientStatus.interval) throw new Error("Cannot create client activity interval without interval time");
+    this.task?.stop();
+    this.task = null;
+    this.task = new $2.Loop(() => this.statusRotationTask(clientStatus), $2.math.ms(clientStatus.interval), true);
+    this.start();
   }
-  getByCategory(category) {
-    return Array.from(this.events.values()).filter((event) => event.metadata?.category?.includes(category));
+  start() {
+    if (this.task) {
+      this.task.start();
+      this.emitter.emit("started", this.task);
+    }
+    return this;
   }
-  getByEvent(eventType) {
-    return Array.from(this.events.values()).filter((event) => event.event === eventType);
+  pause() {
+    if (this.task) {
+      this.task.stop();
+      this.emitter.emit("paused", this.task);
+    }
+    return this;
   }
-  async executeEvents(eventType, ...args) {
-    const events = this.getByEvent(eventType);
-    if (!events.length) return;
-    const sortedEvents = events.sort((a, b) => b.priority - a.priority);
-    await Promise.all(
-      sortedEvents.map(async (event) => {
-        try {
-          await event.execute?.(this.client, ...args);
-          if (event.once) {
-            this.unregister(event.name);
-          }
-        } catch (err) {
-          this.logger.error(`'${event.name}' failed to execute`, err);
-        }
-      })
-    );
+  async set(status) {
+    const statusConfig = createVimcordStatusConfig(status);
+    let clientStatus;
+    if (this.client.config.app.devMode) {
+      clientStatus = statusConfig.development;
+    } else {
+      clientStatus = statusConfig.production;
+    }
+    if (!clientStatus.interval) {
+      await this.setActivity(Array.isArray(clientStatus.activity) ? clientStatus.activity[0] : clientStatus.activity);
+    } else {
+      await this.scheduleStatusRotation(clientStatus);
+    }
+    return this;
   }
-  /** Import event modules that end with `.event` */
-  async importFrom(dir, replaceAll) {
-    dir = Array.isArray(dir) ? dir : [dir];
-    const eventModules = await Promise.all(
-      dir.map((dir2) => importModulesFromDir(dir2, "event"))
-    );
-    if (replaceAll) {
-      this.clear();
-    }
-    let importedEvents = 0;
-    let ignoredEvents = 0;
-    for (const event of eventModules.flat()) {
-      if (!event.module.default.enabled) {
-        ignoredEvents++;
-      } else {
-        importedEvents++;
-      }
-      this.register(event.module.default);
+  async destroy() {
+    if (this.task) {
+      this.task.stop();
+      this.task = null;
+      this.emitter.emit("destroyed");
+      await this.clear();
     }
-    this.client.logger.moduleLoaded("Event Handlers", importedEvents, ignoredEvents);
-    return this.events;
+    return this;
+  }
+  async clear() {
+    const client = await this.getReadyClient();
+    this.clearData();
+    client.user.setActivity({ name: "" });
+    this.emitter.emit("cleared");
+    return this;
   }
 };
 
-// package.json
-var version = "1.0.35";
-
-// src/client.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { $ as $4 } from "qznt";
-
-// src/utils/VimcordCLI.ts
+// src/utils/vimcord.cli.ts
 import { createInterface } from "readline";
 import { $ as $3 } from "qznt";
-
-// src/utils/clientUtils.ts
-function useClient(clientId = 0) {
-  return Vimcord.instances.get(clientId);
-}
-async function useReadyClient(clientId = 0) {
-  return useClient(clientId)?.waitForReady();
-}
-function createClient(options, features = {}, config = {}) {
-  return new Vimcord(options, features, config);
-}
-
-// src/utils/VimcordCLI.ts
-var VimcordCLI = class {
+var VimcordCLI = class _VimcordCLI {
+  static mode = "off";
+  static setMode(mode) {
+    if (_VimcordCLI.mode === mode) return;
+    _VimcordCLI.mode = mode;
+    if (mode === "on") {
+      CLI.logger.log(`~ Type ${CLI.options.prefix}help to view available commands`);
+    } else {
+      CLI.logger.log(`~ [MODE] Now set to "${mode}"`);
+    }
+  }
   rl;
   options;
   commands = /* @__PURE__ */ new Map();
@@ -2328,6 +2528,7 @@ var VimcordCLI = class {
       terminal: false
     });
     this.rl.on("line", (line) => {
+      if (_VimcordCLI.mode !== "on") return;
       const { isCommand, commandName, content, args } = this.parseLine(line);
       if (!isCommand) return;
       const command = this.commands.get(commandName);
@@ -2384,7 +2585,6 @@ var VimcordCLI = class {
     return true;
   }
 };
-var initCalled = false;
 var CLI = new VimcordCLI({ prefix: "/" });
 CLI.addCommand("help", "View information about a command, or the available CLI options", (args) => {
   const prefix = CLI.options.prefix;
@@ -2491,16 +2691,81 @@ CLI.addCommand("cmds", "List the loaded commands", async (args, content) => {
       return CLI.logger.error(`'${mode}' is not a valid option. Valid options: [slash|prefix|ctx]`);
   }
 });
-function initCLI() {
-  if (initCalled) return;
-  CLI.logger.log(`~ Type ${CLI.options.prefix}help to view available commands`);
-  initCalled = true;
-}
 
-// src/client.ts
-import chalk2 from "chalk";
+// src/client/Vimcord.ts
+import { Client as Client2 } from "discord.js";
+import { configDotenv } from "dotenv";
+import { randomUUID as randomUUID3 } from "crypto";
+import EventEmitter2 from "events";
+import { $ as $4 } from "qznt";
 var Vimcord = class _Vimcord extends Client2 {
   static instances = /* @__PURE__ */ new Map();
+  static emitter = new EventEmitter2();
+  clientStartingPromise = null;
+  static create(optionsOrConfig, features, config) {
+    if ("options" in optionsOrConfig) {
+      const { options, features: features2, config: config2 } = optionsOrConfig;
+      return new _Vimcord(options, features2, config2);
+    } else {
+      return new _Vimcord(optionsOrConfig, features, config);
+    }
+  }
+  /**
+   * Returns an instance of Vimcord.
+   * @param clientId [default: 0]
+   */
+  static getInstance(clientId) {
+    if (clientId === void 0) {
+      return _Vimcord.instances.values().next().value;
+    }
+    return _Vimcord.instances.get(clientId);
+  }
+  /**
+   * Waits for a Vimcord instance to be ready.
+   * @param clientId [default: 0]
+   * @param timeoutMs [default: 60000]
+   */
+  static async getReadyInstance(clientId, timeoutMs = 6e4) {
+    const client = _Vimcord.getInstance(clientId);
+    if (client?.isReady()) {
+      _Vimcord.emitter.emit("ready", client);
+      return client;
+    }
+    if (client) {
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          _Vimcord.emitter.off("ready", listener);
+          reject(new Error(`Client (i${clientId ?? 0}) timed out waiting for ready`));
+        }, timeoutMs);
+        const listener = (c) => {
+          if (c.clientId === (clientId ?? 0)) {
+            clearTimeout(timeout);
+            _Vimcord.emitter.off("ready", listener);
+            resolve(c);
+          }
+        };
+        client.once("clientReady", () => {
+          clearTimeout(timeout);
+          _Vimcord.emitter.emit("ready", client);
+          resolve(client);
+        });
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        _Vimcord.emitter.off("ready", listener);
+        reject(new Error(`Vimcord instance (i${clientId ?? 0}) failed to initialize within ${timeoutMs / 1e3}s.`));
+      }, timeoutMs);
+      const listener = (c) => {
+        if (c.clientId === (clientId ?? 0)) {
+          clearTimeout(timeout);
+          _Vimcord.emitter.off("ready", listener);
+          resolve(c);
+        }
+      };
+      _Vimcord.emitter.on("ready", listener);
+    });
+  }
   uuid = randomUUID3();
   clientId = _Vimcord.instances.size;
   clientOptions;
@@ -2510,229 +2775,181 @@ var Vimcord = class _Vimcord extends Client2 {
   events;
   commands;
   db;
-  // Configure custom logger
-  logger = new Logger({ prefixEmoji: "\u26A1", prefix: `vimcord (i${this.clientId})` }).extend({
-    clientBanner(client) {
-      if (client.config.app.disableBanner) return;
-      const border = "\u2550".repeat(50);
-      console.log(chalk2.hex(this.colors.primary)(`
-\u2554${border}\u2557`));
-      console.log(
-        chalk2.hex(this.colors.primary)("\u2551") + chalk2.bold.hex(this.colors.text)(
-          `  \u{1F680} ${client.config.app.name} v${client.config.app.appVersion}`.padEnd(
-            50 - (client.config.app.devMode ? 12 : 0)
-          )
-        ) + chalk2.hex(this.colors.primary)(
-          `${client.config.app.devMode ? chalk2.hex(this.colors.warn)("devMode \u26A0\uFE0F   ") : ""}\u2551`
-        )
-      );
-      console.log(chalk2.hex(this.colors.primary)(`\u2551${"".padEnd(50)}\u2551`));
-      console.log(
-        chalk2.hex(this.colors.primary)("\u2551") + chalk2.hex(this.colors.muted)(
-          `  # Powered by Vimcord v${version}`.padEnd(50 - 3 - `${client.clientId}`.length)
-        ) + chalk2.hex(this.colors.primary)(`${chalk2.hex(this.colors.muted)(`i${client.clientId}`)}  \u2551`)
-      );
-      console.log(chalk2.hex(this.colors.primary)(`\u255A${border}\u255D
-`));
-    },
-    clientReady(clientTag, guildCount) {
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        chalk2.hex(this.colors.success)("\u{1F916} READY"),
-        chalk2.white(`Connected as ${chalk2.bold.hex(this.colors.primary)(clientTag)}`),
-        chalk2.hex(this.colors.muted)(`\u2022 ${guildCount} guilds`)
-      );
-    },
-    moduleLoaded(moduleName, count, ignoredCount) {
-      const countText = count ? chalk2.hex(this.colors.muted)(`(${count} items)`) : "";
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        chalk2.hex("#9B59B6")("\u{1F4E6} MODULE"),
-        chalk2.hex(this.colors.warn)(`${moduleName} loaded`),
-        ignoredCount ? chalk2.hex(this.colors.muted)(`(${ignoredCount} ignored)`) : "",
-        countText
-      );
-    },
-    commandExecuted(commandName, username, guildName) {
-      const location = guildName ? `in ${chalk2.hex(this.colors.muted)(guildName)}` : "in DMs";
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        chalk2.hex("#87CEEB")("\u{1F4DD} COMMAND"),
-        chalk2.hex(this.colors.warn)(`/${commandName}`),
-        chalk2.white(`used by ${chalk2.bold(username)}`),
-        chalk2.hex(this.colors.muted)(location)
-      );
-    },
-    database(action, details) {
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        chalk2.hex("#FF6B9D")("\u{1F5C4}\uFE0F  DATABASE"),
-        chalk2.white(action),
-        details ? chalk2.hex(this.colors.muted)(details) : ""
-      );
-    }
-  });
-  clientStartingPromise = null;
+  logger = clientLoggerFactory(this);
+  error;
   constructor(options, features = {}, config = {}) {
     super(options);
     this.clientOptions = options;
     this.features = features;
-    this.config = {
-      app: createVimcordAppConfig(config.app),
-      staff: createVimcordStaffConfig(config.staff),
-      slashCommands: createVimcordSlashCommandConfig(config.slashCommands),
-      prefixCommands: createVimcordPrefixCommandConfig(config.prefixCommands),
-      contextCommands: createVimcordContextCommandConfig(config.contextCommands)
-    };
+    this.config = defineVimcordConfig(config);
+    this.error = new ErrorHandler(this);
+    if (this.features.useGlobalErrorHandlers) {
+      this.error.setupGlobalHandlers();
+    }
     this.status = new StatusManager(this);
     this.events = new EventManager(this);
     this.commands = new CommandManager(this);
-    if (this.features.useEnv) {
-      if (typeof this.features.useEnv === "object") {
-        dotEnv.config({ quiet: true, ...this.features.useEnv });
-      } else {
-        dotEnv.config({ quiet: true });
-      }
-    }
-    if (this.features.useGlobalErrorHandlers) {
-      process.on("uncaughtException", (err) => this.logger.error("Uncaught Exception", err));
-      process.on("unhandledRejection", (err) => this.logger.error("Unhandled Rejection", err));
-      process.on("exit", (code) => this.logger.debug(`Process exited with code ${code}`));
-      this.on("error", (err) => this.logger.error("Client Error", err));
-      this.on("shardError", (err) => this.logger.error("Client Shard Error", err));
-    }
     this.logger.clientBanner(this);
-    this.once("clientReady", (client) => {
-      this.logger.clientReady(client.user.tag, client.guilds.cache.size);
-    });
+    this.once("clientReady", (client) => this.logger.clientReady(client.user.tag, client.guilds.cache.size));
     _Vimcord.instances.set(this.clientId, this);
-    initCLI();
+    if (this.config.app.enableCLI) {
+      VimcordCLI.setMode("on");
+    }
   }
-  /** Returns the options, features, and config of this client. */
-  toJSON() {
-    return {
-      options: this.clientOptions,
-      features: this.features,
-      config: this.config
-    };
+  /** Current app name */
+  // prettier-ignore
+  get $name() {
+    return this.config.app.name;
   }
-  /** Makes a clone of this client. */
-  clone() {
-    const { options, features, config } = this.toJSON();
-    return new _Vimcord(options, features, config);
+  // prettier-ignore
+  set $name(name) {
+    this.config.app.name = name;
   }
-  configureApp(options = {}) {
-    this.config.app = createVimcordAppConfig(options);
-    if (this.features.hookToolsDevMode) {
-      globalVimcordToolsConfig.devMode = this.config.app.devMode;
-    }
-    return this;
+  /** Current app version */
+  // prettier-ignore
+  get $version() {
+    return this.config.app.version;
   }
-  configureStaff(options = {}) {
-    this.config.staff = createVimcordStaffConfig(options);
-    return this;
+  // prettier-ignore
+  set $version(version2) {
+    this.config.app.version = version2;
   }
-  configureSlashCommands(options = {}) {
-    this.config.slashCommands = createVimcordSlashCommandConfig(options);
-    return this;
+  /** Current dev mode state */
+  // prettier-ignore
+  get $devMode() {
+    return this.config.app.devMode;
   }
-  configurePrefixCommands(options = {}) {
-    this.config.prefixCommands = createVimcordPrefixCommandConfig(options);
-    return this;
+  // prettier-ignore
+  set $devMode(mode) {
+    this.config.app.devMode = mode;
   }
-  configureContextCommands(options = {}) {
-    this.config.contextCommands = createVimcordContextCommandConfig(options);
-    return this;
+  /** Current verbose mode state */
+  // prettier-ignore
+  get $verboseMode() {
+    return this.config.app.verbose;
   }
-  async importEventModules(dir, replaceAll) {
-    await this.events.importFrom(dir, replaceAll);
-    return this;
+  // prettier-ignore
+  set $verboseMode(mode) {
+    this.config.app.verbose = mode;
   }
-  async importSlashCommandModules(dir, replaceAll) {
-    await this.commands.slash.importFrom(dir, replaceAll);
-    return this;
+  /** Returns the options, features, and config of this client. */
+  toJSON() {
+    return { options: this.clientOptions, features: this.features, config: this.config };
   }
-  async importPrefixCommandModules(dir, replaceAll) {
-    await this.commands.prefix.importFrom(dir, replaceAll);
-    return this;
+  /** Makes a clone of this client. */
+  clone() {
+    const { options, features, config } = this.toJSON();
+    return new _Vimcord(options, features, config);
   }
-  async importContextCommandModules(dir, replaceAll) {
-    await this.commands.context.importFrom(dir, replaceAll);
+  /**
+   * Modifies a client config.
+   * @param type The type of config to modify.
+   * @param options The options to set for the config.
+   */
+  configure(type, options = {}) {
+    this.config[type] = configSetters[type](options, this.config[type]);
     return this;
   }
-  async useDatabase(db) {
-    this.db = db;
-    this.logger.database("Using", db.moduleName);
-    return this.db.connect();
-  }
-  async waitForReady() {
-    if (this.isReady()) return this;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(
-        () => reject(new Error(`Client (i${this.clientId}) timed out waiting for ready`)),
-        6e4
-      );
-      this.once("clientReady", () => {
-        clearTimeout(timeout);
-        resolve(this);
-      });
-    });
-  }
+  /** Builds the client by importing modules and registering builtin handlers. */
   async build() {
-    this.configureApp(this.config.app);
-    this.configureStaff(this.config.staff);
-    this.configureSlashCommands(this.config.slashCommands);
-    this.configurePrefixCommands(this.config.prefixCommands);
-    this.configureContextCommands(this.config.contextCommands);
+    this.configure("app", this.config.app);
+    this.configure("staff", this.config.staff);
+    this.configure("slashCommands", this.config.slashCommands);
+    this.configure("prefixCommands", this.config.prefixCommands);
+    this.configure("contextCommands", this.config.contextCommands);
     if (this.features.importModules) {
       const importModules = this.features.importModules;
       await Promise.all([
-        importModules.events && this.importEventModules(importModules.events),
-        importModules.slashCommands && this.importSlashCommandModules(importModules.slashCommands),
-        importModules.prefixCommands && this.importPrefixCommandModules(importModules.prefixCommands),
-        importModules.contextCommands && this.importContextCommandModules(importModules.contextCommands)
+        importModules.events && this.importModules("events", importModules.events),
+        importModules.slashCommands && this.importModules("slashCommands", importModules.slashCommands),
+        importModules.prefixCommands && this.importModules("prefixCommands", importModules.prefixCommands),
+        importModules.contextCommands && this.importModules("contextCommands", importModules.contextCommands)
       ]);
     }
     if (this.features.useDefaultSlashCommandHandler) {
-      this.events.register(BUILTIN_SlashCommandHandler);
+      this.events.register(slashCommandHandler);
     }
     if (this.features.useDefaultContextCommandHandler) {
-      this.events.register(BUILTIN_ContextCommandHandler);
+      this.events.register(contextCommandHandler);
     }
     if (this.features.useDefaultPrefixCommandHandler) {
-      this.events.register(BUILTIN_PrefixCommandHandler);
+      this.events.register(prefixCommandHandler);
     }
     return this;
   }
-  async start(tokenOrPreHook, preHook) {
+  /**
+   * Imports modules into the client.
+   * @param type The type of modules to import.
+   * @param options The options to import the module with.
+   * @param set Replaces already imported modules with the ones found.
+   */
+  async importModules(type, options, set) {
+    await moduleImporters[type](this, options, set);
+    return this;
+  }
+  /**
+   * Allows Vimcord to handle environment variables using [dotenv](https://www.npmjs.com/package/dotenv).
+   * @param options Options for dotenv
+   * @see https://www.npmjs.com/package/dotenv
+   */
+  useEnv(options) {
+    this.logger.database("Using", "dotenv");
+    configDotenv({ quiet: true, ...options });
+    return this;
+  }
+  /**
+   * Connects to a database.
+   * @param db The database manager to use.
+   */
+  async useDatabase(db) {
+    this.db = db;
+    this.logger.database("Using", db.moduleName);
+    return this.db.connect();
+  }
+  /**
+   * Fetches a user from the client, checking the cache first.
+   * @param userId The ID of the user to fetch.
+   */
+  async fetchUser(userId) {
+    const client = await _Vimcord.getReadyInstance(this.clientId);
+    return fetchUser(client, userId);
+  }
+  /**
+   * Fetches a guild from the client, checking the cache first.
+   * @param guildId The ID of the guild to fetch.
+   */
+  async fetchGuild(guildId) {
+    const client = await _Vimcord.getReadyInstance(this.clientId);
+    return fetchGuild(client, guildId);
+  }
+  async start(tokenOrPreHook, callback) {
     if (this.clientStartingPromise) return this.clientStartingPromise;
-    const main = async () => {
+    const execute = async () => {
       let token = typeof tokenOrPreHook === "string" ? tokenOrPreHook : void 0;
-      token ??= this.config.app.devMode ? process.env.TOKEN_DEV : process.env.TOKEN;
+      token ??= this.$devMode ? process.env.TOKEN_DEV : process.env.TOKEN;
       if (!token) {
         throw new Error(
-          `TOKEN Missing: ${this.config.app.devMode ? "devMode is enabled, but TOKEN_DEV is not set" : "TOKEN not set"}`
+          `TOKEN Missing: ${this.$devMode ? "devMode is enabled, but TOKEN_DEV is not set" : "TOKEN not set"}`
         );
       }
       await this.build();
       try {
+        const stopLoader = this.logger.loader("Connecting to Discord...");
+        const loginResult = await $4.async.retry(() => super.login(token), {
+          retries: this.features.maxLoginAttempts ?? 3,
+          delay: 1e3
+        });
+        stopLoader("Connected to Discord    ");
+        this.$verboseMode && this.logger.debug("Waiting for ready...");
         if (typeof tokenOrPreHook === "function") {
           await tokenOrPreHook(this);
         } else {
-          await preHook?.(this);
+          await callback?.(this);
         }
-        const stopLoader = this.logger.loader("Connecting to Discord...");
-        const loginResult = await $4.async.retry(() => super.login(token), this.features.loginAttempts ?? 3, 1e3);
-        stopLoader("Connected to Discord    ");
-        this.config.app.verbose && this.logger.debug("\u23F3 Waiting for ready...");
         return loginResult;
       } catch (err) {
         this.logger.error(
-          `Failed to log into Discord after ${this.features.loginAttempts} attempt(s))`,
+          `Failed to log into Discord after ${this.features.maxLoginAttempts} attempt(s)`,
           err
         );
         return null;
@@ -2740,29 +2957,27 @@ var Vimcord = class _Vimcord extends Client2 {
         this.clientStartingPromise = null;
       }
     };
-    this.clientStartingPromise = main();
+    this.clientStartingPromise = execute();
     return this.clientStartingPromise;
   }
+  /** Destroys the client and disconnects from Discord. */
   async kill() {
     await super.destroy();
     _Vimcord.instances.delete(this.clientId);
-    this.logger.debug("\u{1F6AA} Logged out of Discord");
-  }
-  /** Shortcut for {@link fetchUser tools.fetchUser} */
-  async fetchUser(id) {
-    const client = await this.waitForReady();
-    return fetchUser(client, id);
-  }
-  /** Shortcut for {@link fetchGuild tools.fetchGuild} */
-  async fetchGuild(id) {
-    const client = await this.waitForReady();
-    return fetchGuild(client, id);
+    this.logger.debug("Logged out of Discord");
   }
 };
 
-// src/modules/db/mongo/mongo.ts
+// src/db/mongo/mongo-schema.builder.ts
+import {
+  Schema
+} from "mongoose";
+import { randomBytes } from "crypto";
+import { $ as $6 } from "qznt";
+
+// src/db/mongo/mongo.database.ts
 import mongoose, { ConnectionStates } from "mongoose";
-import EventEmitter2 from "events";
+import EventEmitter3 from "events";
 import { $ as $5 } from "qznt";
 try {
   import("mongoose");
@@ -2771,7 +2986,7 @@ try {
 }
 var MongoDatabase = class _MongoDatabase {
   static instances = /* @__PURE__ */ new Map();
-  static emitter = new EventEmitter2();
+  static emitter = new EventEmitter3();
   moduleName = "MongoDatabase";
   clientId;
   client;
@@ -2856,10 +3071,9 @@ var MongoDatabase = class _MongoDatabase {
     this.isConnecting = true;
     try {
       const stopLoader = this.client.logger.loader("Connecting to MongoDB...");
-      await $5.async.retry(
-        () => this.mongoose.connect(connectionUri, { autoIndex: true, ...connectionOptions }),
-        maxRetries
-      );
+      await $5.async.retry(() => this.mongoose.connect(connectionUri, { autoIndex: true, ...connectionOptions }), {
+        retries: maxRetries
+      });
       _MongoDatabase.emitter.emit("ready", this);
       stopLoader("Connected to MongoDB    ");
     } catch (err) {
@@ -2890,12 +3104,7 @@ var MongoDatabase = class _MongoDatabase {
   }
 };
 
-// src/modules/db/mongo/mongoSchema.builder.ts
-import {
-  Schema
-} from "mongoose";
-import { randomBytes } from "crypto";
-import { $ as $6 } from "qznt";
+// src/db/mongo/mongo-schema.builder.ts
 try {
   import("mongoose");
 } catch {
@@ -2981,10 +3190,13 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
    * @param maxRetries [default: 3]
    */
   async execute(fn, maxRetries = 3) {
-    return await $6.async.retry(async () => {
-      const model = await this.getModel();
-      return await fn(model);
-    }, maxRetries);
+    return await $6.async.retry(
+      async () => {
+        const model = await this.getModel();
+        return await fn(model);
+      },
+      { retries: maxRetries }
+    );
   }
   async startSession(options) {
     return await this.execute(async () => {
@@ -3058,6 +3270,12 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
       return result?.length ? result : [];
     });
   }
+  async bulkWrite(ops, options) {
+    return await this.execute(async (model) => model.bulkWrite(ops, options));
+  }
+  async bulkSave(docs, options) {
+    return await this.execute(async (model) => model.bulkSave(docs, options));
+  }
 };
 
 // src/tools/BetterCollector.ts
@@ -3229,8 +3447,8 @@ var BetterCollector = class _BetterCollector {
   handleListenerError(err) {
     console.error("[BetterCollector] Listener Error:", err);
   }
-  constructor(message, options) {
-    this.config = options?.config || globalVimcordToolsConfig;
+  constructor(message, options = {}) {
+    this.config = options.config ? createToolsConfig(options.config) : globalToolsConfig;
     this.message = message || void 0;
     this.options = options;
     this.build();
@@ -3280,7 +3498,7 @@ var BetterContainer = class {
   data;
   config;
   constructor(data = {}) {
-    this.config = data.config || globalVimcordToolsConfig;
+    this.config = data.config ? createToolsConfig(data.config) : globalToolsConfig;
     this.data = {
       color: data.color ?? (this.config.devMode ? this.config.embedColorDev : this.config.embedColor),
       ...data
@@ -3288,7 +3506,7 @@ var BetterContainer = class {
     this.build();
   }
   configure() {
-    if (this.data.color) {
+    if (this.data.color !== void 0) {
       try {
         const color = Array.isArray(this.data.color) ? this.data.color[Math.floor(Math.random() * this.data.color.length)] ?? null : this.data.color;
         if (color) {
@@ -3304,6 +3522,14 @@ var BetterContainer = class {
   build() {
     this.configure();
   }
+  setColor(color) {
+    this.data.color = color;
+    return this;
+  }
+  clearColor() {
+    this.data.color = null;
+    return this;
+  }
   addSeparator(options) {
     this.container.addSeparatorComponents((sb) => {
       if (options?.divider !== void 0) sb.setDivider(options.divider);
@@ -3392,7 +3618,7 @@ var BetterModal = class {
     this.id = options.id || this.createModalId();
     this.options = options;
     this.modal = new ModalBuilder().setCustomId(this.id);
-    this.config = options.config || globalVimcordToolsConfig;
+    this.config = options.config || globalToolsConfig;
     if (options.title) {
       this.setTitle(options.title);
     }
@@ -3572,7 +3798,8 @@ var BetterModal = class {
         values,
         interaction: modalSubmit,
         reply: (options2) => dynaSend(modalSubmit, options2),
-        deferUpdate: async (options2) => await modalSubmit.deferUpdate(options2)
+        deferUpdate: async (options2) => await modalSubmit.deferUpdate(options2),
+        followUp: async (options2) => await modalSubmit.followUp(options2)
       };
     } catch (error) {
       return null;
@@ -3599,7 +3826,7 @@ import {
   EmbedBuilder as EmbedBuilder2,
   StringSelectMenuBuilder as StringSelectMenuBuilder2
 } from "discord.js";
-import EventEmitter3 from "events";
+import EventEmitter4 from "events";
 var PaginationType = /* @__PURE__ */ ((PaginationType2) => {
   PaginationType2[PaginationType2["Short"] = 0] = "Short";
   PaginationType2[PaginationType2["ShortJump"] = 1] = "ShortJump";
@@ -3644,9 +3871,9 @@ var Paginator = class {
   config;
   data;
   events;
-  eventEmitter = new EventEmitter3();
+  eventEmitter = new EventEmitter4();
   constructor(options = {}) {
-    this.config = options.config || globalVimcordToolsConfig;
+    this.config = options.config ? createToolsConfig(options.config) : globalToolsConfig;
     this.options = {
       type: options.type ?? 0 /* Short */,
       participants: options.participants ?? [],
@@ -4079,7 +4306,7 @@ var Prompt = class {
   config;
   message = null;
   constructor(options = {}) {
-    this.config = options.config ?? globalVimcordToolsConfig;
+    this.config = options.config ? createToolsConfig(options.config) : globalToolsConfig;
     this.participants = options.participants ?? [];
     this.timeout = options.timeout ?? this.config.timeouts.prompt;
     this.content = options.content;
@@ -4260,9 +4487,6 @@ async function prompt(handler, options, sendOptions) {
   return await p.awaitResponse();
 }
 export {
-  BUILTIN_ContextCommandHandler,
-  BUILTIN_PrefixCommandHandler,
-  BUILTIN_SlashCommandHandler,
   BaseCommandBuilder,
   BaseCommandManager,
   BetterCollector,
@@ -4275,13 +4499,16 @@ export {
   CommandType,
   ContextCommandBuilder,
   ContextCommandManager,
+  DEFAULT_MODULE_SUFFIXES,
   DynaSend,
+  ErrorHandler,
   EventBuilder,
   EventManager,
   LOGGER_COLORS,
   LogLevel,
   Logger,
   MissingPermissionReason,
+  ModuleImporter,
   MongoDatabase,
   MongoSchemaBuilder,
   PaginationTimeoutType,
@@ -4301,17 +4528,24 @@ export {
   VimcordCLI,
   __zero,
   cleanMention,
+  clientLoggerFactory,
+  configSetters,
+  contextCommandHandler,
+  createAppConfig,
   createClient,
+  createConfigFactory,
+  createContextCommandConfig,
   createMongoPlugin,
   createMongoSchema,
+  createPrefixCommandConfig,
+  createSlashCommandConfig,
+  createStaffConfig,
   createToolsConfig,
-  createVimcordAppConfig,
-  createVimcordContextCommandConfig,
-  createVimcordPrefixCommandConfig,
-  createVimcordSlashCommandConfig,
-  createVimcordStaffConfig,
   createVimcordStatusConfig,
+  defineClientOptions,
   defineGlobalToolsConfig,
+  defineVimcordConfig,
+  defineVimcordFeatures,
   dynaSend,
   fetchChannel,
   fetchGuild,
@@ -4319,17 +4553,20 @@ export {
   fetchMessage,
   fetchRole,
   fetchUser,
-  getCallerFileName,
+  getDevMode,
   getFirstMentionId,
   getMessageMention,
+  getPackageJson,
   getProcessDir,
-  globalVimcordToolsConfig,
+  globalToolsConfig,
   importModulesFromDir,
-  initCLI,
   isMentionOrSnowflake,
   logger,
+  moduleImporters,
+  prefixCommandHandler,
   prompt,
   sendCommandErrorEmbed,
+  slashCommandHandler,
   useClient,
   useReadyClient,
   validateCommandPermissions