vimcord 1.0.35 → 1.0.37

package/dist/index.cjs

@@ -30,9 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BUILTIN_ContextCommandHandler: () => BUILTIN_ContextCommandHandler,
-  BUILTIN_PrefixCommandHandler: () => BUILTIN_PrefixCommandHandler,
-  BUILTIN_SlashCommandHandler: () => BUILTIN_SlashCommandHandler,
   BaseCommandBuilder: () => BaseCommandBuilder,
   BaseCommandManager: () => BaseCommandManager,
   BetterCollector: () => BetterCollector,
@@ -45,13 +42,16 @@ __export(index_exports, {
   CommandType: () => CommandType,
   ContextCommandBuilder: () => ContextCommandBuilder,
   ContextCommandManager: () => ContextCommandManager,
+  DEFAULT_MODULE_SUFFIXES: () => DEFAULT_MODULE_SUFFIXES,
   DynaSend: () => DynaSend,
+  ErrorHandler: () => ErrorHandler,
   EventBuilder: () => EventBuilder,
   EventManager: () => EventManager,
   LOGGER_COLORS: () => LOGGER_COLORS,
   LogLevel: () => LogLevel,
   Logger: () => Logger,
   MissingPermissionReason: () => MissingPermissionReason,
+  ModuleImporter: () => ModuleImporter,
   MongoDatabase: () => MongoDatabase,
   MongoSchemaBuilder: () => MongoSchemaBuilder,
   PaginationTimeoutType: () => PaginationTimeoutType,
@@ -71,17 +71,24 @@ __export(index_exports, {
   VimcordCLI: () => VimcordCLI,
   __zero: () => __zero,
   cleanMention: () => cleanMention,
+  clientLoggerFactory: () => clientLoggerFactory,
+  configSetters: () => configSetters,
+  contextCommandHandler: () => contextCommandHandler,
+  createAppConfig: () => createAppConfig,
   createClient: () => createClient,
+  createConfigFactory: () => createConfigFactory,
+  createContextCommandConfig: () => createContextCommandConfig,
   createMongoPlugin: () => createMongoPlugin,
   createMongoSchema: () => createMongoSchema,
+  createPrefixCommandConfig: () => createPrefixCommandConfig,
+  createSlashCommandConfig: () => createSlashCommandConfig,
+  createStaffConfig: () => createStaffConfig,
   createToolsConfig: () => createToolsConfig,
-  createVimcordAppConfig: () => createVimcordAppConfig,
-  createVimcordContextCommandConfig: () => createVimcordContextCommandConfig,
-  createVimcordPrefixCommandConfig: () => createVimcordPrefixCommandConfig,
-  createVimcordSlashCommandConfig: () => createVimcordSlashCommandConfig,
-  createVimcordStaffConfig: () => createVimcordStaffConfig,
   createVimcordStatusConfig: () => createVimcordStatusConfig,
+  defineClientOptions: () => defineClientOptions,
   defineGlobalToolsConfig: () => defineGlobalToolsConfig,
+  defineVimcordConfig: () => defineVimcordConfig,
+  defineVimcordFeatures: () => defineVimcordFeatures,
   dynaSend: () => dynaSend,
   fetchChannel: () => fetchChannel,
   fetchGuild: () => fetchGuild,
@@ -89,23 +96,29 @@ __export(index_exports, {
   fetchMessage: () => fetchMessage,
   fetchRole: () => fetchRole,
   fetchUser: () => fetchUser,
-  getCallerFileName: () => getCallerFileName,
+  getDevMode: () => getDevMode,
   getFirstMentionId: () => getFirstMentionId,
   getMessageMention: () => getMessageMention,
+  getPackageJson: () => getPackageJson,
   getProcessDir: () => getProcessDir,
-  globalVimcordToolsConfig: () => globalVimcordToolsConfig,
+  globalToolsConfig: () => globalToolsConfig,
   importModulesFromDir: () => importModulesFromDir,
-  initCLI: () => initCLI,
   isMentionOrSnowflake: () => isMentionOrSnowflake,
   logger: () => logger,
+  moduleImporters: () => moduleImporters,
+  prefixCommandHandler: () => prefixCommandHandler,
   prompt: () => prompt,
   sendCommandErrorEmbed: () => sendCommandErrorEmbed,
+  slashCommandHandler: () => slashCommandHandler,
   useClient: () => useClient,
   useReadyClient: () => useReadyClient,
   validateCommandPermissions: () => validateCommandPermissions
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/modules/validators/permissions.validator.ts
+var import_discord = require("discord.js");
+
 // src/types/command.base.ts
 var CommandType = /* @__PURE__ */ ((CommandType2) => {
   CommandType2[CommandType2["Slash"] = 0] = "Slash";
@@ -133,8 +146,7 @@ var RateLimitScope = /* @__PURE__ */ ((RateLimitScope2) => {
   return RateLimitScope2;
 })(RateLimitScope || {});
 
-// src/validators/permissions.validator.ts
-var import_discord = require("discord.js");
+// src/modules/validators/permissions.validator.ts
 function __existsAndTrue(value) {
   return value !== void 0 && value;
 }
@@ -233,8 +245,8 @@ function validateCommandPermissions(permissions, client, user, command) {
 }
 
 // src/builders/baseCommand.builder.ts
-var import_node_crypto = require("crypto");
 var import_lodash = __toESM(require("lodash"));
+var import_node_crypto = require("crypto");
 var BaseCommandBuilder = class {
   uuid = (0, import_node_crypto.randomUUID)();
   commandType;
@@ -524,55 +536,199 @@ var ContextCommandBuilder = class extends BaseCommandBuilder {
   }
 };
 
-// src/utils/dir.ts
-var import_node_path = __toESM(require("path"));
-var import_qznt = require("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 import_node_path.default.dirname(mainPath);
-}
-async function importModulesFromDir(dir, suffix) {
-  const cwd = getProcessDir();
-  const MODULE_RELATIVE_PATH = import_node_path.default.join(cwd, dir);
-  const MODULE_LOG_PATH = dir;
-  const files = import_qznt.$.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
+var import_node_crypto2 = require("crypto");
+var import_lodash3 = __toESM(require("lodash"));
+
+// src/tools/Logger.ts
+var import_chalk = __toESM(require("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 = import_node_path.default.join(MODULE_RELATIVE_PATH, fn);
-      let _logPath = `./${import_node_path.default.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 import_chalk.default.hex(this.colorScheme.muted)(`[${time}]`);
+  }
+  formatPrefix() {
+    if (!this.logPrefix) return "";
+    return import_chalk.default.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(),
+      import_chalk.default.hex(this.colorScheme.muted)("DEBUG"),
+      import_chalk.default.dim(message),
+      ...args
+    );
+  }
+  info(message, ...args) {
+    if (!this.shouldLog(1 /* INFO */)) return;
+    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.hex("#87CEEB")("INFO"), message, ...args);
+  }
+  success(message, ...args) {
+    if (!this.shouldLog(2 /* SUCCESS */)) return;
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.success)("\u2713 SUCCESS"),
+      import_chalk.default.hex(this.colorScheme.success)(message),
+      ...args
+    );
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog(3 /* WARN */)) return;
+    console.warn(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.warn)("\u26A0 WARN"),
+      import_chalk.default.hex(this.colorScheme.warn)(message),
+      ...args
+    );
+  }
+  error(message, error, ...args) {
+    if (!this.shouldLog(4 /* ERROR */)) return;
+    console.error(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk.default.bold.hex(this.colorScheme.danger)("\u2715 ERROR"),
+      import_chalk.default.hex(this.colorScheme.danger)(message),
+      ...args
+    );
+    if (error && error.stack) {
+      console.error(import_chalk.default.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()} ${import_chalk.default.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()} ${import_chalk.default.hex(this.colorScheme.success)("\u2713")} ${newMessage || message}
+`
+      );
+    };
+  }
+  table(title, data) {
+    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.bold(title));
+    Object.entries(data).forEach(([key, value]) => {
+      const formattedKey = import_chalk.default.hex(this.colorScheme.warn)(`  ${key}`);
+      const formattedValue = import_chalk.default.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(import_chalk.default.hex(this.colorScheme.muted)(`
+\u250C\u2500${line}\u2500\u2510`));
+    console.log(
+      import_chalk.default.hex(this.colorScheme.muted)("\u2502  ") + import_chalk.default.bold.hex(this.colorScheme.text)(title.padEnd(line.length)) + import_chalk.default.hex(this.colorScheme.muted)("  \u2502")
+    );
+    console.log(import_chalk.default.hex(this.colorScheme.muted)(`\u2514\u2500${line}\u2500\u2518`));
+  }
+};
+var logger = new Logger();
 
 // src/builders/event.builder.ts
-var import_node_crypto2 = require("crypto");
-var import_lodash3 = __toESM(require("lodash"));
 var EventBuilder = class _EventBuilder {
   uuid = (0, import_node_crypto2.randomUUID)();
   event;
-  name = getCallerFileName() || this.uuid;
+  name = this.uuid;
   enabled;
   once;
   priority;
@@ -737,6 +893,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);
         }
@@ -757,7 +914,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;
     }
   }
@@ -860,7 +1017,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);
   }
@@ -919,26 +1080,120 @@ var SlashCommandBuilder = class extends BaseCommandBuilder {
   }
 };
 
-// src/client.ts
-var import_discord11 = require("discord.js");
-var import_dotenv = __toESM(require("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
-var import_lodash5 = __toESM(require("lodash"));
-var globalVimcordToolsConfig = {
-  devMode: false,
-  embedColor: [],
-  embedColorDev: [],
-  timeouts: {
-    collectorTimeout: 6e4,
-    collectorIdle: 6e4,
-    pagination: 6e4,
-    prompt: 3e4,
-    modalSubmit: 6e4
-  },
-  collector: {
-    notAParticipantMessage: "You are not allowed to use this.",
-    userLockMessage: "Please wait until your current action is finished.",
+// src/modules/builtins/prefix-command.builtins.ts
+var import_discord4 = require("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 = (0, import_discord4.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
+var import_discord6 = require("discord.js");
+
+// src/utils/config.factory.ts
+var import_lodash5 = __toESM(require("lodash"));
+function createConfigFactory(defaultConfig6, validate) {
+  return (options = {}, existing) => {
+    const result = import_lodash5.default.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: {
+    notAParticipantMessage: "You are not allowed to use this.",
+    userLockMessage: "Please wait until your current action is finished.",
     notAParticipantWarningCooldown: 5e3
   },
   paginator: {
@@ -960,95 +1215,13 @@ var globalVimcordToolsConfig = {
     rejectLabel: "Cancel"
   }
 };
-function defineGlobalToolsConfig(options) {
-  Object.assign(globalVimcordToolsConfig, import_lodash5.default.merge(globalVimcordToolsConfig, options));
-}
-function createToolsConfig(options) {
-  return import_lodash5.default.merge(globalVimcordToolsConfig, options);
-}
-
-// src/configs/app.config.ts
-var import_lodash6 = __toESM(require("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 import_lodash6.default.merge(defaultConfig, options);
-}
-
-// src/configs/staff.config.ts
-var import_lodash7 = __toESM(require("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 import_lodash7.default.merge(defaultConfig2, options);
-}
-
-// src/configs/slashCommand.config.ts
-var import_lodash8 = __toESM(require("lodash"));
-var defaultConfig3 = {
-  logExecution: true
-};
-function createVimcordSlashCommandConfig(options = {}) {
-  return import_lodash8.default.merge(defaultConfig3, options);
-}
-
-// src/configs/prefixCommand.config.ts
-var import_lodash9 = __toESM(require("lodash"));
-var defaultConfig4 = {
-  enabled: true,
-  defaultPrefix: "!",
-  allowMentionAsPrefix: true,
-  allowCaseInsensitiveCommandNames: true,
-  logExecution: true
-};
-function createVimcordPrefixCommandConfig(options = {}) {
-  return import_lodash9.default.merge(defaultConfig4, options);
-}
-
-// src/configs/contextCommand.config.ts
-var import_lodash10 = __toESM(require("lodash"));
-var defaultConfig5 = {
-  enabled: true,
-  logExecution: true
+var createToolsConfig = createConfigFactory(globalToolsConfig);
+var defineGlobalToolsConfig = (options) => {
+  Object.assign(globalToolsConfig, createToolsConfig(options, globalToolsConfig));
 };
-function createVimcordContextCommandConfig(options = {}) {
-  return import_lodash10.default.merge(defaultConfig5, options);
-}
-
-// src/utils/sendCommandErrorEmbed.ts
-var import_discord6 = require("discord.js");
-
-// src/tools/BetterEmbed.ts
-var import_discord5 = require("discord.js");
 
 // src/tools/dynaSend.ts
-var import_discord4 = require("discord.js");
+var import_discord5 = require("discord.js");
 
 // src/tools/types.ts
 var SendMethod = /* @__PURE__ */ ((SendMethod2) => {
@@ -1068,7 +1241,7 @@ var DynaSend = class {
     return Array.isArray(value) ? value : [value];
   }
   static isInteractionCallback(obj) {
-    return obj instanceof import_discord4.InteractionCallbackResponse;
+    return obj instanceof import_discord5.InteractionCallbackResponse;
   }
   static filterFlags(flags, excludeFlags) {
     if (!flags) return void 0;
@@ -1076,26 +1249,26 @@ var DynaSend = class {
     return flagArray.filter((flag) => !excludeFlags.includes(flag));
   }
   static detectSendMethod(handler) {
-    if (handler instanceof import_discord4.BaseInteraction) {
+    if (handler instanceof import_discord5.BaseInteraction) {
       return handler.replied || handler.deferred ? 1 /* EditReply */ : 0 /* Reply */;
     }
-    if (handler instanceof import_discord4.BaseChannel) return 3 /* Channel */;
-    if (handler instanceof import_discord4.Message) return 4 /* MessageReply */;
-    if (handler instanceof import_discord4.GuildMember || handler instanceof import_discord4.User) return 6 /* User */;
+    if (handler instanceof import_discord5.BaseChannel) return 3 /* Channel */;
+    if (handler instanceof import_discord5.Message) return 4 /* MessageReply */;
+    if (handler instanceof import_discord5.GuildMember || handler instanceof import_discord5.User) return 6 /* User */;
     throw new Error("[DynaSend] Unable to determine send method for handler type");
   }
   static validateSendMethod(handler, method) {
     const interactionMethods = [0 /* Reply */, 1 /* EditReply */, 2 /* FollowUp */];
-    if (interactionMethods.includes(method) && !(handler instanceof import_discord4.BaseInteraction)) {
+    if (interactionMethods.includes(method) && !(handler instanceof import_discord5.BaseInteraction)) {
       throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseInteraction handler`);
     }
-    if (method === 3 /* Channel */ && !(handler instanceof import_discord4.BaseChannel)) {
+    if (method === 3 /* Channel */ && !(handler instanceof import_discord5.BaseChannel)) {
       throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires BaseChannel handler`);
     }
-    if ([4 /* MessageReply */, 5 /* MessageEdit */].includes(method) && !(handler instanceof import_discord4.Message)) {
+    if ([4 /* MessageReply */, 5 /* MessageEdit */].includes(method) && !(handler instanceof import_discord5.Message)) {
       throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires Message handler`);
     }
-    if (method === 6 /* User */ && !(handler instanceof import_discord4.GuildMember || handler instanceof import_discord4.User)) {
+    if (method === 6 /* User */ && !(handler instanceof import_discord5.GuildMember || handler instanceof import_discord5.User)) {
       throw new TypeError(`[DynaSend] SendMethod '${SendMethod[method]}' requires User or GuildMember handler`);
     }
   }
@@ -1226,7 +1399,7 @@ async function dynaSend(handler, options) {
 
 // src/tools/BetterEmbed.ts
 var BetterEmbed = class _BetterEmbed {
-  embed = new import_discord5.EmbedBuilder();
+  embed = new import_discord6.EmbedBuilder();
   data;
   config;
   /** A powerful wrapper for `EmbedBuilder` that introduces useful features
@@ -1255,7 +1428,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,
@@ -1303,8 +1476,8 @@ var BetterEmbed = class _BetterEmbed {
   applyContextFormatting(str) {
     if (!this.data.acf) return;
     const user = this.getContextUser();
-    const guildMember = user instanceof import_discord5.GuildMember ? user : null;
-    const actualUser = guildMember?.user || (user instanceof import_discord5.User ? user : null);
+    const guildMember = user instanceof import_discord6.GuildMember ? user : null;
+    const actualUser = guildMember?.user || (user instanceof import_discord6.User ? user : null);
     const client = this.getContextClient();
     const formatString = (str2) => {
       if (!str2 || !str2.includes("$")) return str2;
@@ -1494,24 +1667,25 @@ var BetterEmbed = class _BetterEmbed {
   }
 };
 
-// src/utils/sendCommandErrorEmbed.ts
+// src/utils/command-error.utils.ts
+var import_discord7 = require("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;
   const buttons = {
-    supportServer: new import_discord6.ButtonBuilder({
+    supportServer: new import_discord7.ButtonBuilder({
       url: config?.inviteUrl || client.config.staff.guild.inviteUrl || "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
       // may or may not be a rickroll
       label: config?.inviteButtonLabel || "Support Support",
-      style: import_discord6.ButtonStyle.Link
+      style: import_discord7.ButtonStyle.Link
     }),
-    details: new import_discord6.ButtonBuilder({
+    details: new import_discord7.ButtonBuilder({
       customId: "btn_details",
       label: config?.detailButtonLabel || "Details",
-      style: import_discord6.ButtonStyle.Secondary
+      style: import_discord7.ButtonStyle.Secondary
     })
   };
-  const actionRow = new import_discord6.ActionRowBuilder({
+  const actionRow = new import_discord7.ActionRowBuilder({
     components: config?.inviteUrl && guild?.id !== (config.inviteUrl || client.config.staff.guild.id) ? [buttons.supportServer, buttons.details] : [buttons.details]
   });
   const embed_error = config?.embed?.(new BetterEmbed(), error, guild) || new BetterEmbed({
@@ -1519,19 +1693,20 @@ 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
   });
   if (!msg) return null;
   const collector = msg.createMessageComponentCollector({
-    componentType: import_discord6.ComponentType.Button,
+    componentType: import_discord7.ComponentType.Button,
     idle: config?.detailButtonIdleTimeout ?? 3e4,
     filter: (i) => i.customId === "btn_details"
   });
   collector.on("collect", (i) => {
-    const attachment = new import_discord6.AttachmentBuilder(Buffer.from(`${error.message}
+    const attachment = new import_discord7.AttachmentBuilder(Buffer.from(`${error.message}
 
 ${error.stack}`), {
       name: "error.txt"
@@ -1540,537 +1715,335 @@ ${error.stack}`), {
   });
   collector.on("end", () => {
     buttons.details.setDisabled(true);
-    embed_error.send(messageOrInteraction, {
-      sendMethod: messageOrInteraction instanceof import_discord6.Message ? 5 /* MessageEdit */ : void 0,
+    dynaSend(messageOrInteraction, {
+      embeds: [embed_error],
+      sendMethod: messageOrInteraction instanceof import_discord7.Message ? 5 /* MessageEdit */ : void 0,
       components: [actionRow]
     });
   });
   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
-var import_discord7 = require("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 = (0, import_discord7.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
+var import_chalk2 = __toESM(require("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(import_chalk2.default.hex(this.colors.primary)(`
+\u2554${border}\u2557`));
+    console.log(
+      import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.bold.hex(this.colors.text)(
+        `  \u{1F680} ${client2.config.app.name} v${client2.$version}`.padEnd(50 - (client2.$devMode ? 12 : 0))
+      ) + import_chalk2.default.hex(this.colors.primary)(`${client2.$devMode ? import_chalk2.default.hex(this.colors.warn)("devMode \u26A0\uFE0F   ") : ""}\u2551`)
+    );
+    console.log(import_chalk2.default.hex(this.colors.primary)(`\u2551${"".padEnd(50)}\u2551`));
+    console.log(
+      import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.hex(this.colors.muted)(
+        `  # Powered by Vimcord v${version}`.padEnd(50 - 3 - `${client2.clientId}`.length)
+      ) + import_chalk2.default.hex(this.colors.primary)(`${import_chalk2.default.hex(this.colors.muted)(`i${client2.clientId}`)}  \u2551`)
+    );
+    console.log(import_chalk2.default.hex(this.colors.primary)(`\u255A${border}\u255D
+`));
+  },
+  clientReady(clientTag, guildCount) {
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk2.default.hex(this.colors.success)("\u{1F916} READY"),
+      import_chalk2.default.white(`Connected as ${import_chalk2.default.bold.hex(this.colors.primary)(clientTag)}`),
+      import_chalk2.default.hex(this.colors.muted)(`\u2022 ${guildCount} guilds`)
+    );
+  },
+  moduleLoaded(moduleName, count, ignoredCount) {
+    const countText = count ? import_chalk2.default.hex(this.colors.muted)(`(${count} items)`) : "";
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk2.default.hex("#9B59B6")("\u{1F4E6} MODULE"),
+      import_chalk2.default.hex(this.colors.warn)(`${moduleName} loaded`),
+      ignoredCount ? import_chalk2.default.hex(this.colors.muted)(`(${ignoredCount} ignored)`) : "",
+      countText
+    );
+  },
+  commandExecuted(commandName, username, guildName) {
+    const location = guildName ? `in ${import_chalk2.default.hex(this.colors.muted)(guildName)}` : "in DMs";
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk2.default.hex("#87CEEB")("\u{1F4DD} COMMAND"),
+      import_chalk2.default.hex(this.colors.warn)(`/${commandName}`),
+      import_chalk2.default.white(`used by ${import_chalk2.default.bold(username)}`),
+      import_chalk2.default.hex(this.colors.muted)(location)
+    );
+  },
+  database(action, details) {
+    console.log(
+      this.formatTimestamp(),
+      this.formatPrefix(),
+      import_chalk2.default.hex("#FF6B9D")("\u{1F5C4}\uFE0F  DATABASE"),
+      import_chalk2.default.white(action),
+      details ? import_chalk2.default.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
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function getPackageJson() {
+  return JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.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
-var import_chalk = __toESM(require("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 import_chalk.default.hex(this.colorScheme.muted)(`[${time}]`);
-  }
-  formatPrefix() {
-    if (!this.logPrefix) return "";
-    return import_chalk.default.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(),
-      import_chalk.default.hex(this.colorScheme.muted)("DEBUG"),
-      import_chalk.default.dim(message),
-      ...args
-    );
-  }
-  info(message, ...args) {
-    if (!this.shouldLog(1 /* INFO */)) return;
-    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.hex("#87CEEB")("INFO"), message, ...args);
-  }
-  success(message, ...args) {
-    if (!this.shouldLog(2 /* SUCCESS */)) return;
-    console.log(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      import_chalk.default.bold.hex(this.colorScheme.success)("\u2713 SUCCESS"),
-      import_chalk.default.hex(this.colorScheme.success)(message),
-      ...args
-    );
-  }
-  warn(message, ...args) {
-    if (!this.shouldLog(3 /* WARN */)) return;
-    console.warn(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      import_chalk.default.bold.hex(this.colorScheme.warn)("\u26A0 WARN"),
-      import_chalk.default.hex(this.colorScheme.warn)(message),
-      ...args
-    );
-  }
-  error(message, error, ...args) {
-    if (!this.shouldLog(4 /* ERROR */)) return;
-    console.error(
-      this.formatTimestamp(),
-      this.formatPrefix(),
-      import_chalk.default.bold.hex(this.colorScheme.danger)("\u2715 ERROR"),
-      import_chalk.default.hex(this.colorScheme.danger)(message),
-      ...args
-    );
-    if (error && error.stack) {
-      console.error(import_chalk.default.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()} ${import_chalk.default.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()} ${import_chalk.default.hex(this.colorScheme.success)("\u2713")} ${newMessage || message}
-`
-      );
-    };
-  }
-  table(title, data) {
-    console.log(this.formatTimestamp(), this.formatPrefix(), import_chalk.default.bold(title));
-    Object.entries(data).forEach(([key, value]) => {
-      const formattedKey = import_chalk.default.hex(this.colorScheme.warn)(`  ${key}`);
-      const formattedValue = import_chalk.default.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(import_chalk.default.hex(this.colorScheme.muted)(`
-\u250C\u2500${line}\u2500\u2510`));
-    console.log(
-      import_chalk.default.hex(this.colorScheme.muted)("\u2502  ") + import_chalk.default.bold.hex(this.colorScheme.text)(title.padEnd(line.length)) + import_chalk.default.hex(this.colorScheme.muted)("  \u2502")
-    );
-    console.log(import_chalk.default.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;
+// 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: {}
   }
-}
-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;
-    }
+};
+var createStaffConfig = createConfigFactory(defaultConfig5);
+
+// 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);
+  },
+  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);
   }
-  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;
+};
+function defineClientOptions(options) {
+  return options;
 }
-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;
+function defineVimcordFeatures(features) {
+  return features;
 }
-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;
+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/types/status.ts
+// src/modules/command.manager.ts
 var import_discord8 = require("discord.js");
-var import_lodash11 = __toESM(require("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: import_discord8.ActivityType.Custom, name: "Need help? Use /help or !help" },
-      { status: "online" /* Online */, type: import_discord8.ActivityType.Custom, name: "Join our community!" },
-      { status: "online" /* Online */, type: import_discord8.ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
-    ]
-  },
-  development: {
-    activity: { status: "dnd" /* DND */, type: import_discord8.ActivityType.Custom, name: "In development!" }
-  }
-};
-function createVimcordStatusConfig(options = {}) {
-  return import_lodash11.default.merge(defaultPresence, options);
-}
 
-// src/modules/status.manager.ts
-var import_node_events = __toESM(require("events"));
-var import_qznt2 = require("qznt");
-var StatusManager = class {
-  client;
-  logger;
-  emitter = new import_node_events.default();
-  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", import_qznt2.$.format.number(this.client.users.cache.size)).replace("$GUILD_COUNT", import_qznt2.$.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", import_qznt2.$.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 = import_qznt2.$.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 import_qznt2.$.Loop(() => this.statusRotationTask(clientStatus), import_qznt2.$.math.ms(clientStatus.interval), true);
-    this.start();
+// src/utils/import.utils.ts
+var import_node_path2 = __toESM(require("path"));
+var import_qznt = require("qznt");
+function getProcessDir() {
+  const mainPath = process.argv[1];
+  if (!mainPath) return "";
+  return import_node_path2.default.dirname(mainPath);
+}
+async function importModulesFromDir(dir, suffix) {
+  const cwd = getProcessDir();
+  const MODULE_RELATIVE_PATH = import_node_path2.default.join(cwd, dir);
+  const MODULE_LOG_PATH = dir;
+  const files = import_qznt.$.fs.readDir(MODULE_RELATIVE_PATH).filter((fn) => fn.endsWith(`${suffix ? `.${suffix}` : ""}.js`) || fn.endsWith(`${suffix ? `.${suffix}` : ""}.ts`));
+  if (!files.length) {
+    return [];
   }
-  start() {
-    if (this.task) {
-      this.task.start();
-      this.emitter.emit("started", this.task);
-    }
-    return this;
+  const modules = await Promise.all(
+    files.map(async (fn) => {
+      let _path = import_node_path2.default.join(MODULE_RELATIVE_PATH, fn);
+      let _logPath = `./${import_node_path2.default.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}'`);
   }
-  pause() {
-    if (this.task) {
-      this.task.stop();
-      this.emitter.emit("paused", this.task);
-    }
-    return this;
+  return filteredModules;
+}
+
+// src/modules/base-module.importer.ts
+var ModuleImporter = class {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  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);
+  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: module2 }) => module2.default));
     }
-    return this;
-  }
-  async destroy() {
-    if (this.task) {
-      this.task.stop();
-      this.task = null;
-      this.emitter.emit("destroyed");
-      await this.clear();
+    for (const module2 of modules) {
+      const name = this.getName(module2);
+      this.items.set(name, module2);
     }
-    return this;
-  }
-  async clear() {
-    const client = await this.getReadyClient();
-    this.clearData();
-    client.user.setActivity({ name: "" });
-    this.emitter.emit("cleared");
-    return this;
+    this.client.logger.moduleLoaded(this.itemName, modules.length);
+    return this.items;
   }
 };
 
 // src/modules/command.manager.ts
-var import_discord9 = require("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(module2) {
+    return "builder" in module2 ? module2.builder.name : module2.options.name;
   }
   /**
    * Gets a command by name.
@@ -2079,7 +2052,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;
@@ -2090,7 +2063,7 @@ var BaseCommandManager = class {
         }
       });
     } else {
-      return this.commands.get(name);
+      return this.items.get(name);
     }
   }
   /**
@@ -2099,7 +2072,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));
@@ -2126,7 +2099,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);
@@ -2149,52 +2122,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: module2 }) => module2.default));
-    }
-    for (const module2 of modules) {
-      const commandName = "builder" in module2 ? module2.builder.name : module2.options.name;
-      this.commands.set(commandName, module2);
-    }
-    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 {
@@ -2212,7 +2153,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;
@@ -2222,29 +2163,34 @@ 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(import_discord9.Routes.applicationCommands(client.user.id), { body: commands });
-      console.log(`[CommandManager] \u2714 Registered app commands globally`);
+      await client.rest.put(import_discord8.Routes.applicationCommands(client.user.id), { body: commands });
+      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;
     }
     try {
-      await client.rest.put(import_discord9.Routes.applicationCommands(client.user.id), { body: [] });
+      await client.rest.put(import_discord8.Routes.applicationCommands(client.user.id), { body: [] });
       console.log(`[CommandManager] \u2714 Removed app commands globally`);
     } catch (err) {
       console.error(`[CommandManager] \u2716 Failed to remove app commands globally`, err);
     }
   }
   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;
@@ -2255,21 +2201,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(import_discord9.Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
+        (guildId) => client.rest.put(import_discord8.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;
@@ -2278,31 +2231,35 @@ var CommandManager = class {
     console.log(`[CommandManager] Unregistering commands from ${guildIds.length} guilds...`);
     await Promise.all(
       guildIds.map(
-        (guildId) => client.rest.put(import_discord9.Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[CommandManager] \u2714 Removed app commands in guild: ${guildId}`)).catch((err) => console.log(`[CommandManager] \u2716 Failed to remove app commands in guild: ${guildId}`, err))
+        (guildId) => client.rest.put(import_discord8.Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[CommandManager] \u2714 Removed app commands in guild: ${guildId}`)).catch((err) => console.log(`[CommandManager] \u2716 Failed to remove app commands in guild: ${guildId}`, err))
       )
     );
   }
 };
 
 // src/modules/event.manager.ts
-var import_discord10 = require("discord.js");
-var EventManager = class {
-  client;
-  events = /* @__PURE__ */ new Map();
+var import_discord9 = require("discord.js");
+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(import_discord10.Events)) {
+    for (const event of Object.values(import_discord9.Events)) {
       client.on(
         event.toString(),
         async (...args) => this.executeEvents.apply(this, [event, ...args])
       );
     }
   }
+  getName(module2) {
+    return module2.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}'`);
       }
@@ -2310,95 +2267,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
+var import_discord10 = require("discord.js");
+var import_lodash6 = __toESM(require("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: import_discord10.ActivityType.Custom, name: "Need help? Use /help or !help" },
+      { status: "online" /* Online */, type: import_discord10.ActivityType.Custom, name: "Join our community!" },
+      { status: "online" /* Online */, type: import_discord10.ActivityType.Watching, name: "\u2728 $GUILD_COUNT servers" }
+    ]
+  },
+  development: {
+    activity: { status: "dnd" /* DND */, type: import_discord10.ActivityType.Custom, name: "In development!" }
+  }
+};
+function createVimcordStatusConfig(options = {}) {
+  return import_lodash6.default.merge(defaultPresence, options);
+}
+
+// src/modules/status.manager.ts
+var import_node_events = __toESM(require("events"));
+var import_qznt2 = require("qznt");
+var StatusManager = class {
+  client;
+  logger;
+  emitter = new import_node_events.default();
+  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", import_qznt2.$.format.number(this.client.users.cache.size)).replace("$GUILD_COUNT", import_qznt2.$.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", import_qznt2.$.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 = import_qznt2.$.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 import_qznt2.$.Loop(() => this.statusRotationTask(clientStatus), import_qznt2.$.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
-var import_node_crypto3 = require("crypto");
-var import_qznt4 = require("qznt");
-
-// src/utils/VimcordCLI.ts
+// src/utils/vimcord.cli.ts
 var import_node_readline = require("readline");
 var import_qznt3 = require("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();
@@ -2411,6 +2621,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);
@@ -2467,7 +2678,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;
@@ -2574,16 +2784,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
-var import_chalk2 = __toESM(require("chalk"));
+// src/client/Vimcord.ts
+var import_discord11 = require("discord.js");
+var import_dotenv = require("dotenv");
+var import_node_crypto3 = require("crypto");
+var import_node_events2 = __toESM(require("events"));
+var import_qznt4 = require("qznt");
 var Vimcord = class _Vimcord extends import_discord11.Client {
   static instances = /* @__PURE__ */ new Map();
+  static emitter = new import_node_events2.default();
+  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 = (0, import_node_crypto3.randomUUID)();
   clientId = _Vimcord.instances.size;
   clientOptions;
@@ -2593,229 +2868,181 @@ var Vimcord = class _Vimcord extends import_discord11.Client {
   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(import_chalk2.default.hex(this.colors.primary)(`
-\u2554${border}\u2557`));
-      console.log(
-        import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.bold.hex(this.colors.text)(
-          `  \u{1F680} ${client.config.app.name} v${client.config.app.appVersion}`.padEnd(
-            50 - (client.config.app.devMode ? 12 : 0)
-          )
-        ) + import_chalk2.default.hex(this.colors.primary)(
-          `${client.config.app.devMode ? import_chalk2.default.hex(this.colors.warn)("devMode \u26A0\uFE0F   ") : ""}\u2551`
-        )
-      );
-      console.log(import_chalk2.default.hex(this.colors.primary)(`\u2551${"".padEnd(50)}\u2551`));
-      console.log(
-        import_chalk2.default.hex(this.colors.primary)("\u2551") + import_chalk2.default.hex(this.colors.muted)(
-          `  # Powered by Vimcord v${version}`.padEnd(50 - 3 - `${client.clientId}`.length)
-        ) + import_chalk2.default.hex(this.colors.primary)(`${import_chalk2.default.hex(this.colors.muted)(`i${client.clientId}`)}  \u2551`)
-      );
-      console.log(import_chalk2.default.hex(this.colors.primary)(`\u255A${border}\u255D
-`));
-    },
-    clientReady(clientTag, guildCount) {
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        import_chalk2.default.hex(this.colors.success)("\u{1F916} READY"),
-        import_chalk2.default.white(`Connected as ${import_chalk2.default.bold.hex(this.colors.primary)(clientTag)}`),
-        import_chalk2.default.hex(this.colors.muted)(`\u2022 ${guildCount} guilds`)
-      );
-    },
-    moduleLoaded(moduleName, count, ignoredCount) {
-      const countText = count ? import_chalk2.default.hex(this.colors.muted)(`(${count} items)`) : "";
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        import_chalk2.default.hex("#9B59B6")("\u{1F4E6} MODULE"),
-        import_chalk2.default.hex(this.colors.warn)(`${moduleName} loaded`),
-        ignoredCount ? import_chalk2.default.hex(this.colors.muted)(`(${ignoredCount} ignored)`) : "",
-        countText
-      );
-    },
-    commandExecuted(commandName, username, guildName) {
-      const location = guildName ? `in ${import_chalk2.default.hex(this.colors.muted)(guildName)}` : "in DMs";
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        import_chalk2.default.hex("#87CEEB")("\u{1F4DD} COMMAND"),
-        import_chalk2.default.hex(this.colors.warn)(`/${commandName}`),
-        import_chalk2.default.white(`used by ${import_chalk2.default.bold(username)}`),
-        import_chalk2.default.hex(this.colors.muted)(location)
-      );
-    },
-    database(action, details) {
-      console.log(
-        this.formatTimestamp(),
-        this.formatPrefix(),
-        import_chalk2.default.hex("#FF6B9D")("\u{1F5C4}\uFE0F  DATABASE"),
-        import_chalk2.default.white(action),
-        details ? import_chalk2.default.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") {
-        import_dotenv.default.config({ quiet: true, ...this.features.useEnv });
-      } else {
-        import_dotenv.default.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");
+    (0, import_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 import_qznt4.$.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 import_qznt4.$.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;
@@ -2823,29 +3050,25 @@ var Vimcord = class _Vimcord extends import_discord11.Client {
         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
+var import_mongoose2 = require("mongoose");
+var import_node_crypto4 = require("crypto");
+var import_qznt6 = require("qznt");
+
+// src/db/mongo/mongo.database.ts
 var import_mongoose = __toESM(require("mongoose"));
-var import_node_events2 = __toESM(require("events"));
+var import_node_events3 = __toESM(require("events"));
 var import_qznt5 = require("qznt");
 try {
   import("mongoose");
@@ -2854,7 +3077,7 @@ try {
 }
 var MongoDatabase = class _MongoDatabase {
   static instances = /* @__PURE__ */ new Map();
-  static emitter = new import_node_events2.default();
+  static emitter = new import_node_events3.default();
   moduleName = "MongoDatabase";
   clientId;
   client;
@@ -2939,10 +3162,9 @@ var MongoDatabase = class _MongoDatabase {
     this.isConnecting = true;
     try {
       const stopLoader = this.client.logger.loader("Connecting to MongoDB...");
-      await import_qznt5.$.async.retry(
-        () => this.mongoose.connect(connectionUri, { autoIndex: true, ...connectionOptions }),
-        maxRetries
-      );
+      await import_qznt5.$.async.retry(() => this.mongoose.connect(connectionUri, { autoIndex: true, ...connectionOptions }), {
+        retries: maxRetries
+      });
       _MongoDatabase.emitter.emit("ready", this);
       stopLoader("Connected to MongoDB    ");
     } catch (err) {
@@ -2973,10 +3195,7 @@ var MongoDatabase = class _MongoDatabase {
   }
 };
 
-// src/modules/db/mongo/mongoSchema.builder.ts
-var import_mongoose2 = require("mongoose");
-var import_node_crypto4 = require("crypto");
-var import_qznt6 = require("qznt");
+// src/db/mongo/mongo-schema.builder.ts
 try {
   import("mongoose");
 } catch {
@@ -3062,10 +3281,13 @@ var MongoSchemaBuilder = class _MongoSchemaBuilder {
    * @param maxRetries [default: 3]
    */
   async execute(fn, maxRetries = 3) {
-    return await import_qznt6.$.async.retry(async () => {
-      const model = await this.getModel();
-      return await fn(model);
-    }, maxRetries);
+    return await import_qznt6.$.async.retry(
+      async () => {
+        const model = await this.getModel();
+        return await fn(model);
+      },
+      { retries: maxRetries }
+    );
   }
   async startSession(options) {
     return await this.execute(async () => {
@@ -3139,6 +3361,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
@@ -3310,8 +3538,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();
@@ -3357,7 +3585,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
@@ -3365,7 +3593,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) {
@@ -3381,6 +3609,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);
@@ -3458,7 +3694,7 @@ var BetterModal = class {
     this.id = options.id || this.createModalId();
     this.options = options;
     this.modal = new import_discord13.ModalBuilder().setCustomId(this.id);
-    this.config = options.config || globalVimcordToolsConfig;
+    this.config = options.config || globalToolsConfig;
     if (options.title) {
       this.setTitle(options.title);
     }
@@ -3638,7 +3874,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;
@@ -3656,7 +3893,7 @@ var BetterModal = class {
 
 // src/tools/Paginator.ts
 var import_discord14 = require("discord.js");
-var import_node_events3 = __toESM(require("events"));
+var import_node_events4 = __toESM(require("events"));
 var PaginationType = /* @__PURE__ */ ((PaginationType2) => {
   PaginationType2[PaginationType2["Short"] = 0] = "Short";
   PaginationType2[PaginationType2["ShortJump"] = 1] = "ShortJump";
@@ -3701,9 +3938,9 @@ var Paginator = class {
   config;
   data;
   events;
-  eventEmitter = new import_node_events3.default();
+  eventEmitter = new import_node_events4.default();
   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 ?? [],
@@ -4131,7 +4368,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;
@@ -4313,9 +4550,6 @@ async function prompt(handler, options, sendOptions) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BUILTIN_ContextCommandHandler,
-  BUILTIN_PrefixCommandHandler,
-  BUILTIN_SlashCommandHandler,
   BaseCommandBuilder,
   BaseCommandManager,
   BetterCollector,
@@ -4328,13 +4562,16 @@ async function prompt(handler, options, sendOptions) {
   CommandType,
   ContextCommandBuilder,
   ContextCommandManager,
+  DEFAULT_MODULE_SUFFIXES,
   DynaSend,
+  ErrorHandler,
   EventBuilder,
   EventManager,
   LOGGER_COLORS,
   LogLevel,
   Logger,
   MissingPermissionReason,
+  ModuleImporter,
   MongoDatabase,
   MongoSchemaBuilder,
   PaginationTimeoutType,
@@ -4354,17 +4591,24 @@ async function prompt(handler, options, sendOptions) {
   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,
@@ -4372,17 +4616,20 @@ async function prompt(handler, options, sendOptions) {
   fetchMessage,
   fetchRole,
   fetchUser,
-  getCallerFileName,
+  getDevMode,
   getFirstMentionId,
   getMessageMention,
+  getPackageJson,
   getProcessDir,
-  globalVimcordToolsConfig,
+  globalToolsConfig,
   importModulesFromDir,
-  initCLI,
   isMentionOrSnowflake,
   logger,
+  moduleImporters,
+  prefixCommandHandler,
   prompt,
   sendCommandErrorEmbed,
+  slashCommandHandler,
   useClient,
   useReadyClient,
   validateCommandPermissions