vimcord 1.0.0 → 1.0.1

package/dist/index.js

@@ -6,11 +6,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/types/command.base.ts
-var CommandType = /* @__PURE__ */ ((CommandType3) => {
-  CommandType3[CommandType3["Slash"] = 0] = "Slash";
-  CommandType3[CommandType3["Prefix"] = 1] = "Prefix";
-  CommandType3[CommandType3["Context"] = 2] = "Context";
-  return CommandType3;
+var CommandType = /* @__PURE__ */ ((CommandType2) => {
+  CommandType2[CommandType2["Slash"] = 0] = "Slash";
+  CommandType2[CommandType2["Prefix"] = 1] = "Prefix";
+  CommandType2[CommandType2["Context"] = 2] = "Context";
+  return CommandType2;
 })(CommandType || {});
 var MissingPermissionReason = /* @__PURE__ */ ((MissingPermissionReason2) => {
   MissingPermissionReason2[MissingPermissionReason2["User"] = 0] = "User";
@@ -134,270 +134,239 @@ import _ from "lodash";
 var BaseCommandBuilder = class {
   uuid = randomUUID();
   commandType;
-  client;
-  enabled;
-  conditions;
-  permissions;
-  metadata;
-  rateLimit;
-  beforeExecute;
-  execute;
-  afterExecute;
-  onRateLimit;
-  onMissingPermissions;
-  onConditionsNotMet;
-  onUsedWhenDisabled;
-  onError;
-  globalRateLimitData = { executions: 0, timestamp: 0 };
-  userRateLimitData = /* @__PURE__ */ new Map();
-  guildRateLimitData = /* @__PURE__ */ new Map();
-  channelRateLimitData = /* @__PURE__ */ new Map();
-  constructor(type, config) {
+  /** Local command configuration and hooks */
+  options;
+  /** Internal state for rate limiting across different scopes */
+  rlStores = {
+    [3 /* Global */]: { executions: 0, timestamp: 0 },
+    [0 /* User */]: /* @__PURE__ */ new Map(),
+    [1 /* Guild */]: /* @__PURE__ */ new Map(),
+    [2 /* Channel */]: /* @__PURE__ */ new Map()
+  };
+  /** * Mapping of CommandTypes to their respective config keys in the Vimcord client
+   */
+  typeConfigMapping = {
+    [0 /* Slash */]: "slashCommands",
+    [1 /* Prefix */]: "prefixCommands",
+    [2 /* Context */]: "contextCommands"
+  };
+  constructor(type, options = {}) {
     this.commandType = type;
-    this.enabled = config?.enabled ?? true;
-    this.conditions = config?.conditions;
-    this.permissions = config?.permissions;
-    this.metadata = config?.metadata;
-    this.rateLimit = config?.rateLimit;
-    this.beforeExecute = config?.beforeExecute;
-    this.execute = config?.execute;
-    this.afterExecute = config?.afterExecute;
-    this.onRateLimit = config?.onRateLimit;
-    this.onMissingPermissions = config?.onMissingPermissions;
-    this.onConditionsNotMet = config?.onConditionsNotMet;
-    this.onUsedWhenDisabled = config?.onUsedWhenDisabled;
-    this.onError = config?.onError;
-    this.validateBaseConfig();
+    this.options = { enabled: true, ...options };
   }
   validateBaseConfig() {
-    if (this.rateLimit) {
-      if (this.rateLimit.max <= 0) {
-        throw new Error("DJSSlashCommandBuilder: Rate limit max must be greater than 0");
+    if (this.options.rateLimit) {
+      const { max, interval } = this.options.rateLimit;
+      if (max <= 0 || interval <= 0) {
+        throw new Error(`[Vimcord:${this.constructor.name}] Rate limit values must be positive.`);
       }
-      if (this.rateLimit.interval <= 0) {
-        throw new Error("DJSSlashCommandBuilder: Rate limit interval must be greater than 0");
+    }
+  }
+  /**
+   * Resolves the final configuration by merging layers:
+   * Client Defaults < Client Type-Specific < Local Command Options
+   */
+  resolveConfig(client) {
+    const typeKey = this.typeConfigMapping[this.commandType];
+    const typeSpecificGlobals = client.config?.[typeKey] || {};
+    return _.merge({}, typeSpecificGlobals, this.options);
+  }
+  /**
+   * Executes the command lifecycle.
+   * Merges global client config with local command options at runtime.
+   */
+  async run(client, ...args) {
+    const config = this.resolveConfig(client);
+    const ctx = this.extractContext(args);
+    try {
+      if (!config.enabled) {
+        return await config.onUsedWhenDisabled?.(...args);
+      }
+      if (this.isRateLimited(config, ctx)) {
+        return await config.onRateLimit?.(...args);
+      }
+      const perms = this.checkPermissions(client, ctx.member || ctx.user, args[1]);
+      if (!perms.validated) {
+        return await config.onMissingPermissions?.(perms, ...args);
       }
+      if (!await this.checkConditions(config, ...args)) {
+        return await config.onConditionsNotMet?.(...args);
+      }
+      await config.beforeExecute?.(...args);
+      if (config.logExecution !== false) {
+        const cmdName = this.options.name || this.builder?.name || "Unknown";
+        const location = ctx.guild ? `${ctx.guild.name} (${ctx.guild.id})` : "Direct Messages";
+        client.logger.commandExecuted(cmdName, ctx.user.username, location);
+      }
+      const result = await config.execute?.(...args);
+      await config.afterExecute?.(result, ...args);
+    } catch (error) {
+      await this.handleError(error, config, ...args);
     }
   }
-  toConfig() {
+  /**
+   * Internal logic to determine if a command execution should be throttled.
+   * @param config The merged configuration to use for limits.
+   * @param ctx Extracted Discord context (User, Guild, Channel).
+   */
+  isRateLimited(config, ctx) {
+    if (!config.rateLimit) return false;
+    const { scope, interval, max } = config.rateLimit;
+    const now = Date.now();
+    const key = this.getScopeKey(scope, ctx);
+    if (scope !== 3 /* Global */ && !key) return false;
+    let data;
+    if (scope === 3 /* Global */) {
+      data = this.rlStores[3 /* Global */];
+    } else {
+      const store = this.rlStores[scope];
+      data = store.get(key) ?? { executions: 0, timestamp: now };
+      store.set(key, data);
+    }
+    if (now - data.timestamp > interval) {
+      data.executions = 0;
+      data.timestamp = now;
+    }
+    if (data.executions >= max) return true;
+    data.executions++;
+    return false;
+  }
+  /**
+   * Validates if the user has required permissions.
+   */
+  checkPermissions(client, user, target) {
+    if (!this.options.permissions) return { validated: true };
+    return validateCommandPermissions(this.options.permissions, client, user, target);
+  }
+  /**
+   * Evaluates all custom conditions defined for the command.
+   */
+  async checkConditions(config, ...args) {
+    if (!config.conditions?.length) return true;
+    const results = await Promise.all(config.conditions.map((c) => c(...args)));
+    return results.every(Boolean);
+  }
+  /**
+   * Normalizes the trigger arguments into a standard context object.
+   */
+  extractContext(args) {
+    const event = args[1];
     return {
-      enabled: this.enabled,
-      conditions: this.conditions,
-      permissions: this.permissions,
-      metadata: this.metadata,
-      rateLimit: this.rateLimit,
-      beforeExecute: this.beforeExecute,
-      execute: this.execute,
-      afterExecute: this.afterExecute,
-      onMissingPermissions: this.onMissingPermissions,
-      onConditionsNotMet: this.onConditionsNotMet,
-      onUsedWhenDisabled: this.onUsedWhenDisabled,
-      onRateLimit: this.onRateLimit,
-      onError: this.onError
+      user: event.user || event.author,
+      member: event.member,
+      guild: event.guild,
+      channel: event.channel
     };
   }
+  /**
+   * Resolves the storage key based on the RateLimit scope.
+   */
+  getScopeKey(scope, ctx) {
+    switch (scope) {
+      case 0 /* User */:
+        return ctx.user.id;
+      case 1 /* Guild */:
+        return ctx.guild?.id ?? null;
+      case 2 /* Channel */:
+        return ctx.channel?.id ?? null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Handles command errors by checking local handlers before falling back to global handlers.
+   */
+  async handleError(err, config, ...args) {
+    if (config.onError) return config.onError(err, ...args);
+    throw err;
+  }
+  /** Toggle command availability */
   setEnabled(enabled) {
-    this.enabled = enabled;
+    this.options.enabled = enabled;
     return this;
   }
+  /** Merge new permission requirements into the existing ones */
+  setPermissions(perms) {
+    this.options.permissions = _.merge(this.options.permissions || {}, perms);
+    return this;
+  }
+  /** Add custom logic checks that run before execution */
   addConditions(...conditions) {
-    if (!this.conditions) this.conditions = [];
-    this.conditions.push(...conditions);
+    this.options.conditions = [...this.options.conditions || [], ...conditions];
     return this;
   }
-  setConditions(conditions) {
-    this.conditions = conditions;
+  /** Set the primary command execution logic */
+  setExecute(fn) {
+    this.options.execute = fn;
     return this;
   }
-  setPermissions(permissions) {
-    this.permissions = _.merge(this.permissions, permissions);
+  /** * Set the custom conditions that must be met for this command to execute
+   */
+  setConditions(conditions) {
+    this.options.conditions = conditions;
     return this;
   }
+  /** * Set the command metadata configuration
+   */
   setMetadata(metadata) {
-    this.metadata = _.merge(this.metadata, metadata);
+    this.options.metadata = _.merge(this.options.metadata || {}, metadata);
     return this;
   }
+  /** * Set the rate limiting options for this command
+   */
   setRateLimit(options) {
-    this.rateLimit = options;
+    this.options.rateLimit = options;
+    this.validateBaseConfig();
     return this;
   }
-  setBeforeExecute(callback) {
-    this.beforeExecute = callback;
+  /** * Set whether to log whenever this command is executed
+   * @default true
+   */
+  setLogExecution(log) {
+    this.options.logExecution = log;
     return this;
   }
-  setExecute(callback) {
-    this.execute = callback;
+  /** * Set the function to execute before the main command logic
+   */
+  setBeforeExecute(callback) {
+    this.options.beforeExecute = callback;
     return this;
   }
+  /** * Set the function to execute after successful command execution
+   */
   setAfterExecute(callback) {
-    this.afterExecute = callback;
-    return this;
-  }
-  setOnRateLimit(callback) {
-    this.onRateLimit = callback;
+    this.options.afterExecute = callback;
     return this;
   }
+  /** * Set the function to execute when the required permissions are not met
+   */
   setOnMissingPermissions(callback) {
-    this.onMissingPermissions = callback;
+    this.options.onMissingPermissions = callback;
     return this;
   }
+  /** * Set the function to execute when the required conditions are not met
+   */
   setOnConditionsNotMet(callback) {
-    this.onConditionsNotMet = callback;
+    this.options.onConditionsNotMet = callback;
     return this;
   }
+  /** * Set the function to execute when this command is used when its disabled
+   */
   setOnUsedWhenDisabled(callback) {
-    this.onUsedWhenDisabled = callback;
+    this.options.onUsedWhenDisabled = callback;
     return this;
   }
-  setOnError(callback) {
-    this.onError = callback;
+  /** * Set the function to execute when the rate limit is hit
+   */
+  setOnRateLimit(callback) {
+    this.options.onRateLimit = callback;
     return this;
   }
-  getRateLimitInfo(user, guild, channel) {
-    if (!this.rateLimit) return null;
-    let rateLimitData;
-    switch (this.rateLimit.scope) {
-      case 0 /* User */:
-        if (!user) return null;
-        rateLimitData = this.userRateLimitData.get(user.id) ?? { executions: 0, timestamp: 0 };
-        break;
-      case 1 /* Guild */:
-        if (!guild) return null;
-        rateLimitData = this.guildRateLimitData.get(guild.id) ?? { executions: 0, timestamp: 0 };
-        break;
-      case 2 /* Channel */:
-        if (!channel) return null;
-        rateLimitData = this.channelRateLimitData.get(channel.id) ?? { executions: 0, timestamp: 0 };
-        break;
-      case 3 /* Global */:
-        rateLimitData = this.globalRateLimitData;
-        break;
-      default:
-        return null;
-    }
-    return { ...rateLimitData, isLimited: this.isRateLimited(user, guild, channel, false) };
-  }
-  isRateLimited(user, guild, channel, updateExecutions = true) {
-    if (!this.rateLimit) return false;
-    const now = Date.now();
-    let rateLimitData;
-    switch (this.rateLimit.scope) {
-      case 0 /* User */:
-        if (!user) return false;
-        rateLimitData = this.userRateLimitData.get(user.id) ?? { executions: 0, timestamp: 0 };
-        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
-          rateLimitData.executions = 0;
-          rateLimitData.timestamp = now;
-        }
-        if (updateExecutions) rateLimitData.executions++;
-        this.userRateLimitData.set(user.id, rateLimitData);
-        break;
-      case 1 /* Guild */:
-        if (!guild) return false;
-        rateLimitData = this.guildRateLimitData.get(guild.id) ?? { executions: 0, timestamp: 0 };
-        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
-          rateLimitData.executions = 0;
-          rateLimitData.timestamp = now;
-        }
-        if (updateExecutions) rateLimitData.executions++;
-        this.guildRateLimitData.set(guild.id, rateLimitData);
-        break;
-      case 2 /* Channel */:
-        if (!channel) return false;
-        rateLimitData = this.guildRateLimitData.get(channel.id) ?? { executions: 0, timestamp: 0 };
-        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
-          rateLimitData.executions = 0;
-          rateLimitData.timestamp = now;
-        }
-        if (updateExecutions) rateLimitData.executions++;
-        this.channelRateLimitData.set(channel.id, rateLimitData);
-        break;
-      case 3 /* Global */:
-        rateLimitData = this.globalRateLimitData;
-        if (now - rateLimitData.timestamp >= this.rateLimit.interval) {
-          rateLimitData.executions = 0;
-          rateLimitData.timestamp = now;
-        }
-        if (updateExecutions) rateLimitData.executions++;
-        this.globalRateLimitData = rateLimitData;
-        break;
-    }
-    return rateLimitData.executions >= this.rateLimit.max;
-  }
-  checkPermissions(client, user, command) {
-    if (!this.permissions) return { validated: true };
-    return validateCommandPermissions(this.permissions, client, user, command);
-  }
-  async checkConditions(...args) {
-    if (!this.conditions?.length) return true;
-    const results = await Promise.all(this.conditions.map((condition) => condition(...args)));
-    return results.every(Boolean);
-  }
-  async _runPreflight(clientConfig, command, ...args) {
-    try {
-      if (!this.enabled) {
-        await clientConfig.onUsedWhenDisabled?.(...args);
-        await this.onUsedWhenDisabled?.(...args);
-        return;
-      }
-      if (this.isRateLimited(args[1]?.member || args[1]?.author, args[1].guild, args[1].channel)) {
-        await clientConfig.onRateLimit?.(...args);
-        await this.rateLimit?.onRateLimit?.(...args);
-        return;
-      }
-      const permissionResults = this.checkPermissions(
-        args[0],
-        args[1]?.member || args[1]?.author || args[1]?.user,
-        command
-      );
-      if (!permissionResults.validated) {
-        await clientConfig.onMissingPermissions?.(permissionResults, ...args);
-        await this.onMissingPermissions?.(permissionResults, ...args);
-        return;
-      }
-      if (!await this.checkConditions(...args)) {
-        await clientConfig.onConditionsNotMet?.(...args);
-        await this.onConditionsNotMet?.(...args);
-        return;
-      }
-    } catch (err) {
-      if (this.onError) {
-        return this.onError(err, ...args);
-      } else if (clientConfig.onError) {
-        return clientConfig.onError(err, ...args);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async _runCabinCheck(clientConfig, ...args) {
-    try {
-      await clientConfig.beforeExecute?.(...args);
-      await this.beforeExecute?.(...args);
-    } catch (err) {
-      if (this.onError) {
-        return this.onError(err, ...args);
-      } else if (clientConfig.onError) {
-        return clientConfig.onError(err, ...args);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async _runFlyAndLand(clientConfig, ...args) {
-    try {
-      const result = await this.execute?.(...args);
-      await clientConfig?.afterExecute?.(result, ...args);
-      await this.afterExecute?.(result, ...args);
-    } catch (err) {
-      if (this.onError) {
-        return this.onError(err, ...args);
-      } else if (clientConfig.onError) {
-        return clientConfig.onError(err, ...args);
-      } else {
-        throw err;
-      }
-    }
+  /** * Set a custom error handler for this command
+   */
+  setOnError(callback) {
+    this.options.onError = callback;
+    return this;
   }
 };
 
@@ -406,73 +375,48 @@ import { ContextMenuCommandBuilder } from "discord.js";
 import _2 from "lodash";
 var ContextCommandBuilder = class extends BaseCommandBuilder {
   builder;
-  deferReply;
-  deployment;
   constructor(config) {
     super(2 /* Context */, config);
     this.setBuilder(config.builder);
-    this.deferReply = config?.deferReply;
-    this.deployment = config?.deployment;
-    this.validateConfig();
+    const originalExecute = this.options.execute;
+    this.options.execute = async (client, interaction) => {
+      return await this.handleExecution(client, interaction, originalExecute);
+    };
   }
-  validateBuilder() {
-    if (!this.builder.name) {
-      throw new Error("VContextCommandBuilder: Command name is required");
-    }
-    try {
-      this.builder.toJSON();
-    } catch (err) {
-      throw new Error("VContextCommandBuilder: Invalid command builder", { cause: err });
+  async handleExecution(client, interaction, originalExecute) {
+    const config = this.resolveConfig(client);
+    if (config.deferReply && !interaction.replied && !interaction.deferred) {
+      await interaction.deferReply(typeof config.deferReply === "object" ? config.deferReply : void 0);
     }
+    return await originalExecute?.(client, interaction);
   }
-  validateConfig() {
-  }
-  toConfig() {
-    return {
-      ...super.toConfig(),
-      builder: this.builder,
-      deferReply: this.deferReply,
-      deployment: this.deployment
-    };
+  validateBuilder() {
+    if (!this.builder.name) throw new Error(`[Vimcord] ContextCommandBuilder: Command name is required.`);
+    this.builder.toJSON();
   }
+  // --- Specialized Fluent API ---
   setBuilder(builder) {
-    if (typeof builder === "function") {
-      this.builder = builder(new ContextMenuCommandBuilder());
-    } else {
-      this.builder = builder;
-    }
+    this.builder = typeof builder === "function" ? builder(new ContextMenuCommandBuilder()) : builder;
     this.validateBuilder();
     return this;
   }
   setDeferReply(defer) {
-    this.deferReply = defer;
+    this.options.deferReply = defer;
     return this;
   }
   setDeployment(deployment) {
-    this.deployment = _2.merge(this.deployment, deployment);
+    this.options.deployment = _2.merge(this.options.deployment || {}, deployment);
     return this;
   }
-  async executeCommand(client, interaction) {
-    try {
-      await this._runPreflight(client.config.contextCommands, interaction, client, interaction);
-      await this._runCabinCheck(client.config.contextCommands, client, interaction);
-      if (this.deferReply && !interaction.replied && !interaction.deferred) {
-        await interaction.deferReply(typeof this.deferReply === "object" ? this.deferReply : void 0);
-      }
-      return this._runFlyAndLand(client.config.contextCommands, client, interaction);
-    } catch (err) {
-      if (this.onError) {
-        return this.onError(err, client, interaction);
-      } else if (client.config.contextCommands.onError) {
-        return client.config.contextCommands.onError(err, client, interaction);
-      } else {
-        throw err;
-      }
-    } finally {
-      if (client.config.contextCommands.logExecution) {
-        client.logger.commandExecuted(this.builder.name, interaction.user.username, interaction.guild?.name);
-      }
-    }
+  setExecute(fn) {
+    const originalExecute = fn;
+    this.options.execute = async (client, interaction) => {
+      return await this.handleExecution(client, interaction, originalExecute);
+    };
+    return this;
+  }
+  toConfig() {
+    return { ...this.options, builder: this.builder };
   }
 };
 
@@ -719,39 +663,74 @@ var EventBuilder = class _EventBuilder {
 
 // src/builders/prefixCommand.builder.ts
 var PrefixCommandBuilder = class extends BaseCommandBuilder {
-  name;
-  aliases;
-  description;
   constructor(config) {
     super(1 /* Prefix */, config);
-    this.name = config.name;
-    this.description = config.description;
-    this.validateConfig();
+    const originalExecute = this.options.execute;
+    this.options.execute = async (client, message) => {
+      return await this.handleExecution(client, message, originalExecute);
+    };
+    this.validatePrefixConfig();
+  }
+  /**
+   * Specialized execution logic for Prefix Commands.
+   */
+  async handleExecution(client, message, originalExecute) {
+    return await originalExecute?.(client, message);
+  }
+  validatePrefixConfig() {
+    if (!this.options.name) {
+      throw new Error(`[Vimcord] PrefixCommandBuilder: Command name is required.`);
+    }
+  }
+  // --- Fluent API (Prefix Specific Only) ---
+  /**
+   * Set the primary name of the command.
+   */
+  setName(name) {
+    this.options.name = name;
+    return this;
+  }
+  /**
+   * Set or replace the command aliases.
+   */
+  setAliases(aliases) {
+    this.options.aliases = aliases;
+    return this;
+  }
+  /**
+   * Add additional aliases without clearing existing ones.
+   */
+  addAliases(...aliases) {
+    this.options.aliases = [...this.options.aliases || [], ...aliases];
+    return this;
   }
-  validateConfig() {
+  /**
+   * Set the command description.
+   */
+  setDescription(description) {
+    this.options.description = description;
+    return this;
   }
+  // --- Overrides ---
+  /**
+   * Override setExecute to ensure handleExecution remains the entry point.
+   * This is the only base method we need to redefine.
+   */
+  setExecute(fn) {
+    const originalExecute = fn;
+    this.options.execute = async (client, message) => {
+      return await this.handleExecution(client, message, originalExecute);
+    };
+    return this;
+  }
+  /**
+   * Converts the current builder state back into a config object.
+   */
   toConfig() {
     return {
-      ...super.toConfig(),
-      name: this.name,
-      description: this.description
+      ...this.options
     };
   }
-  async executeCommand(client, message) {
-    try {
-      await this._runPreflight(client.config.prefixCommands, this.name, client, message);
-      await this._runCabinCheck(client.config.prefixCommands, client, message);
-      return this._runFlyAndLand(client.config.prefixCommands, client, message);
-    } catch (err) {
-      this.onError?.(err, client, message);
-      client.config.prefixCommands.onError?.(err, client, message);
-      throw err;
-    } finally {
-      if (client.config.prefixCommands.logExecution) {
-        client.logger.commandExecuted(this.name, message.author.username, message.guild?.name);
-      }
-    }
-  }
 };
 
 // src/builders/slashCommand.builder.ts
@@ -759,110 +738,81 @@ import { SlashCommandBuilder as DJSSlashCommandBuilder } from "discord.js";
 import _4 from "lodash";
 var SlashCommandBuilder = class extends BaseCommandBuilder {
   builder;
-  deferReply;
-  deployment;
   routes = /* @__PURE__ */ new Map();
-  onUnknownRouteHandler;
   constructor(config) {
     super(0 /* Slash */, config);
     this.setBuilder(config.builder);
-    this.setRoutes(...config.routes ?? []);
-    this.deferReply = config?.deferReply;
-    this.deployment = config?.deployment;
-    this.validateConfig();
+    if (config.routes) this.addRoutes(...config.routes);
+    const originalExecute = this.options.execute;
+    this.options.execute = async (client, interaction) => {
+      return await this.handleExecution(client, interaction, originalExecute);
+    };
   }
-  validateBuilder() {
-    if (!this.builder.name) {
-      throw new Error("VSlashCommandBuilder: Command name is required");
+  async handleExecution(client, interaction, originalExecute) {
+    const config = this.resolveConfig(client);
+    if (config.deferReply && !interaction.replied && !interaction.deferred) {
+      await interaction.deferReply(typeof config.deferReply === "object" ? config.deferReply : void 0);
     }
-    if (!this.builder.description) {
-      throw new Error("VSlashCommandBuilder: Command description is required");
+    const subCommand = interaction.options.getSubcommand(false);
+    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);
     }
-    try {
-      this.builder.toJSON();
-    } catch (err) {
-      throw new Error("VSlashCommandBuilder: Invalid command builder", { cause: err });
-    }
-  }
-  validateConfig() {
+    return await originalExecute?.(client, interaction);
   }
-  toConfig() {
-    return {
-      ...super.toConfig(),
-      builder: this.builder,
-      deferReply: this.deferReply,
-      deployment: this.deployment,
-      routes: this.routes.size ? Array.from(this.routes.entries()).map(([k, v]) => ({ name: k, handler: v })) : void 0,
-      onUnknownRouteHandler: this.onUnknownRouteHandler
-    };
+  validateBuilder() {
+    if (!this.builder.name) throw new Error(`[Vimcord] SlashCommandBuilder: Command name is required.`);
+    if (!this.builder.description) throw new Error(`[Vimcord] SlashCommandBuilder: Command description is required.`);
+    this.builder.toJSON();
   }
+  // --- Specialized Fluent API ---
   setBuilder(builder) {
-    if (typeof builder === "function") {
-      this.builder = builder(new DJSSlashCommandBuilder());
-    } else {
-      this.builder = builder;
-    }
+    this.builder = typeof builder === "function" ? builder(new DJSSlashCommandBuilder()) : builder;
     this.validateBuilder();
     return this;
   }
   setDeferReply(defer) {
-    this.deferReply = defer;
+    this.options.deferReply = defer;
     return this;
   }
   setDeployment(deployment) {
-    this.deployment = _4.merge(this.deployment, deployment);
+    this.options.deployment = _4.merge(this.options.deployment || {}, deployment);
     return this;
   }
   setRoutes(...routes) {
-    if (routes.length) {
-      for (const route of routes) {
-        this.routes.set(route.name.toLowerCase(), route.handler);
-      }
-    } else {
-      this.routes = /* @__PURE__ */ new Map();
-    }
+    this.routes.clear();
+    this.addRoutes(...routes);
     return this;
   }
   addRoutes(...routes) {
+    if (!this.options.routes) this.options.routes = [];
     for (const route of routes) {
-      this.routes.set(route.name.toLowerCase(), route.handler);
+      const name = route.name.toLowerCase();
+      this.routes.set(name, route.handler);
+      const existingIndex = this.options.routes.findIndex((r) => r.name.toLowerCase() === name);
+      if (existingIndex > -1) this.options.routes[existingIndex] = route;
+      else this.options.routes.push(route);
     }
     return this;
   }
   setUnknownRouteHandler(handler) {
-    this.onUnknownRouteHandler = handler;
+    this.options.onUnknownRouteHandler = handler;
     return this;
   }
-  async executeCommand(client, interaction) {
-    try {
-      await this._runPreflight(client.config.slashCommands, interaction, client, interaction);
-      await this._runCabinCheck(client.config.slashCommands, client, interaction);
-      if (this.deferReply && !interaction.replied && !interaction.deferred) {
-        await interaction.deferReply(typeof this.deferReply === "object" ? this.deferReply : void 0);
-      }
-      if (this.routes.size) {
-        const subCommand = interaction.options.getSubcommand();
-        const route = this.routes.get(subCommand);
-        if (route) {
-          const result = await route(client, interaction);
-          await this.afterExecute?.(result, client, interaction);
-          return result;
-        } else if (this.onUnknownRouteHandler) {
-          const result = await this.onUnknownRouteHandler?.(client, interaction);
-          await this.afterExecute?.(result, client, interaction);
-          return result;
-        }
-      }
-      return this._runFlyAndLand(client.config.slashCommands, client, interaction);
-    } catch (err) {
-      this.onError?.(err, client, interaction);
-      client.config.slashCommands.onError?.(err, client, interaction);
-      throw err;
-    } finally {
-      if (client.config.slashCommands.logExecution) {
-        client.logger.commandExecuted(this.builder.name, interaction.user.username, interaction.guild?.name);
-      }
-    }
+  setExecute(fn) {
+    const originalExecute = fn;
+    this.options.execute = async (client, interaction) => {
+      return await this.handleExecution(client, interaction, originalExecute);
+    };
+    return this;
+  }
+  toConfig() {
+    return {
+      ...this.options,
+      builder: this.builder,
+      routes: Array.from(this.routes.entries()).map(([name, handler]) => ({ name, handler }))
+    };
   }
 };
 
@@ -877,12 +827,19 @@ var globalVimcordToolsConfig = {
   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: {
-    notAParticipantMessage: "You are not allowed to use this!",
+    notAParticipantMessage: "You are not allowed to use this.",
     jumpableThreshold: 5,
     longThreshold: 4,
     buttons: {
@@ -895,7 +852,7 @@ var globalVimcordToolsConfig = {
   },
   prompt: {
     defaultTitle: "Are you sure?",
-    defaultDescription: "Make sure you know what you're doing!",
+    defaultDescription: "Make sure you know what you're doing.",
     confirmLabel: "Confirm",
     rejectLabel: "Cancel"
   }
@@ -985,7 +942,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-var DEFAULT_COLORS = {
+var LOGGER_COLORS = {
   primary: "#5865F2",
   success: "#57F287",
   warn: "#FEE75C",
@@ -1006,7 +963,7 @@ var Logger = class {
     this.minLevel = minLevel;
     this.showTimestamp = showTimestamp;
     this.colorScheme = {
-      ...DEFAULT_COLORS,
+      ...LOGGER_COLORS,
       ...options?.colors
     };
   }
@@ -1067,7 +1024,7 @@ var Logger = class {
   }
   setColors(colors) {
     this.colorScheme = {
-      ...DEFAULT_COLORS,
+      ...LOGGER_COLORS,
       ...colors
     };
     return this;
@@ -1462,236 +1419,187 @@ var VimcordStatusManager = class {
 
 // src/modules/command.manager.ts
 import { REST, Routes } from "discord.js";
-var VimcordCommandManager = class {
-  slash;
-  prefix;
-  context;
-  constructor(client) {
-    this.slash = new VimcordSlashCommandManager(client);
-    this.prefix = new VimcordPrefixCommandManager(client);
-    this.context = new VimcordContextCommandManager(client);
-  }
-};
-var VimcordSlashCommandManager = class {
-  constructor(client) {
+var VimcordAppCommandManager = class {
+  constructor(client, typeName) {
     this.client = client;
-    client.whenReady().then((c) => this.rest = new REST().setToken(c.token));
+    this.typeName = typeName;
+    this.client.whenReady().then((c) => this.rest = new REST().setToken(c.token));
   }
   commands = /* @__PURE__ */ new Map();
   rest;
   get(name) {
     return this.commands.get(name);
   }
+  /**
+   * Filters and returns commands based on deployment options
+   */
   getAll(options) {
     const matchedCommands = /* @__PURE__ */ new Map();
+    const isDev = this.client.config.app.devMode;
     for (const cmd of this.commands.values()) {
-      let matched = null;
-      if (options?.names || options?.fuzzyNames || options?.guilds) {
-        const nameMatched = (
-          // Exact name match
-          options.names?.includes(cmd.builder.name) || // Fuzzy match
-          options.fuzzyNames?.some((fuzzyCommand) => cmd.builder.name.includes(fuzzyCommand))
-        );
-        if ((options.names || options.fuzzyNames) && !nameMatched) continue;
-        const guildMatched = cmd.deployment?.guilds?.some((guildId) => options.guilds?.includes(guildId));
-        if (options.guilds && !guildMatched) continue;
-        matched = cmd;
-      } else {
-        matched = cmd;
+      const config = cmd.toConfig();
+      const name = cmd.builder.name;
+      if (options?.names || options?.fuzzyNames) {
+        const nameMatched = options.names?.includes(name) || options.fuzzyNames?.some((fuzzy) => name.includes(fuzzy));
+        if (!nameMatched) continue;
       }
-      if (!matched) continue;
       if (options?.ignoreDeploymentOptions) {
-        if (matchedCommands.has(matched.builder.name)) continue;
-        matchedCommands.set(matched.builder.name, matched);
+        matchedCommands.set(name, cmd);
         continue;
       }
-      const isProperEnvironment = matched?.deployment?.environments?.includes(
-        this.client.config.app.devMode ? "development" : "production"
-      );
-      if ((isProperEnvironment ?? true) && ((options?.globalOnly && (matched?.deployment?.global ?? true)) ?? true)) {
-        matchedCommands.set(matched.builder.name, matched);
-      }
+      const deployment = config.deployment || {};
+      const isProperEnv = !deployment.environments || deployment.environments.includes(isDev ? "development" : "production");
+      if (!isProperEnv) continue;
+      if (options?.globalOnly && deployment.global === false) continue;
+      matchedCommands.set(name, cmd);
     }
     return matchedCommands;
   }
-  /** Import command modules that end with `.slash` */
-  async importFrom(dir, replaceAll) {
-    if (replaceAll) {
-      this.commands.clear();
+  async registerGlobal(options) {
+    const client = await this.client.whenReady();
+    const commands = Array.from(
+      this.getAll({
+        names: options?.commands,
+        fuzzyNames: options?.fuzzyCommands,
+        globalOnly: true
+      }).values()
+    ).map((cmd) => cmd.builder.toJSON());
+    if (!commands.length) {
+      console.log(`[${this.typeName}] No commands to register`);
+      return;
     }
-    dir = Array.isArray(dir) ? dir : [dir];
-    const commandModules = await Promise.all(
-      dir.map((dir2) => importModulesFromDir(dir2, "slash"))
-    );
-    let importedCommands = 0;
-    for (const command of commandModules.flat()) {
-      const isProperEnvironment = command.module.default.deployment?.environments?.includes(
-        this.client.config.app.devMode ? "development" : "production"
-      );
-      if (isProperEnvironment ?? true) {
-        this.commands.set(command.module.default.builder.name, command.module.default);
-        importedCommands++;
-      }
+    console.log(`[${this.typeName}] Registering ${commands.length} commands globally...`);
+    try {
+      await this.rest.put(Routes.applicationCommands(client.user.id), { body: commands });
+      console.log(`[${this.typeName}] \u2714 Registered app commands globally`);
+    } catch (err) {
+      console.log(`[${this.typeName}] \u2716 Failed to register app commands globally`, err);
     }
-    this.client.logger.moduleLoaded("Slash Commands", importedCommands);
-    return this.commands;
   }
   async registerGuild(options) {
     const client = await this.client.whenReady();
-    const commandsToRegister = Array.from(
+    const commands = Array.from(
       this.getAll({
         names: options?.commands,
         fuzzyNames: options?.fuzzyCommands
       }).values()
     ).map((cmd) => cmd.builder.toJSON());
-    if (!commandsToRegister.length) {
-      console.log("[SlashCommandManager] No commands to register");
+    if (!commands.length) {
+      console.log(`[${this.typeName}] No commands to register`);
       return;
     }
-    const guildIds = options?.guilds || client.guilds.cache.map((guild) => guild.id);
-    console.log(
-      `[SlashCommandManager] Registering ${commandsToRegister.length} app (/) ${commandsToRegister.length === 1 ? "command" : "commands"} for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}...`
-    );
+    const guildIds = options?.guilds || client.guilds.cache.map((g) => g.id);
+    console.log(`[${this.typeName}] Registering ${commands.length} commands for ${guildIds.length} guilds...`);
     await Promise.all(
       guildIds.map(
-        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), {
-          body: commandsToRegister
-        }).then(
-          () => console.log(
-            `[SlashCommandManager] \u2714 Set app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`
-          )
-        ).catch(
-          (err) => console.log(
-            `[SlashCommandManager] \u2716 Failed to set app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`,
-            err
-          )
-        )
+        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: commands }).then(() => {
+          const gName = client.guilds.cache.get(guildId)?.name || "n/a";
+          console.log(`[${this.typeName}] \u2714 Set app commands in guild: ${guildId} (${gName})`);
+        }).catch((err) => {
+          const gName = client.guilds.cache.get(guildId)?.name || "n/a";
+          console.log(`[${this.typeName}] \u2716 Failed to set app commands in guild: ${guildId} (${gName})`, err);
+        })
       )
     );
-    console.log(
-      `[SlashCommandManager] \u2714 Finished registering app (/) commands for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}`
-    );
   }
   async unregisterGuild(options) {
     const client = await this.client.whenReady();
-    const guildIds = options?.guilds || client.guilds.cache.map((guild) => guild.id);
-    console.log(
-      `[SlashCommandManager] Unregistering app (/) commands from ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}...`
-    );
+    const guildIds = options?.guilds || client.guilds.cache.map((g) => g.id);
+    console.log(`[${this.typeName}] Unregistering commands from ${guildIds.length} guilds...`);
     await Promise.all(
       guildIds.map(
-        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), {
-          body: []
-        }).then(
-          () => console.log(
-            `[SlashCommandManager] \u2714 Removed app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`
-          )
-        ).catch(
-          (err) => console.log(
-            `[SlashCommandManager] \u2716 Failed to remove app (/) commands in guild: ${guildId} (${client.guilds.cache.find((g) => g.id === guildId)?.name || "n/a"})`,
-            err
-          )
+        (guildId) => this.rest.put(Routes.applicationGuildCommands(client.user.id, guildId), { body: [] }).then(() => console.log(`[${this.typeName}] \u2714 Removed app commands in guild: ${guildId}`)).catch(
+          (err) => console.log(`[${this.typeName}] \u2716 Failed to remove app commands in guild: ${guildId}`, err)
         )
       )
     );
-    console.log(
-      `[SlashCommandManager] \u2714 Finished unregistering app (/) commands for ${guildIds.length} ${guildIds.length === 1 ? "guild" : "guilds"}`
-    );
-  }
-  async registerGlobal(options) {
-    const client = await this.client.whenReady();
-    const commandsToRegister = Array.from(
-      this.getAll({
-        names: options?.commands,
-        fuzzyNames: options?.fuzzyCommands,
-        globalOnly: true
-      }).values()
-    ).map((cmd) => cmd.builder.toJSON());
-    if (!commandsToRegister.length) {
-      console.log("[SlashCommandManager] No commands to register");
-      return;
-    }
-    console.log(
-      `[SlashCommandManager] Registering ${commandsToRegister.length} app (/) ${commandsToRegister.length === 1 ? "command" : "commands"} globally...`
-    );
-    try {
-      await this.rest.put(Routes.applicationCommands(client.user.id), { body: commandsToRegister });
-      console.log("[SlashCommandManager] \u2714 Registered app (/) commands globally");
-    } catch (err) {
-      console.log("[SlashCommandManager] \u2716 Failed to register app (/) commands globally", err);
-    }
   }
   async unregisterGlobal() {
     const client = await this.client.whenReady();
-    console.log("[SlashCommandManager] Unregistering app (/) commands globally...");
     try {
       await this.rest.put(Routes.applicationCommands(client.user.id), { body: [] });
-      console.log("[SlashCommandManager] \u2714 Removed app (/) commands globally");
+      console.log(`[${this.typeName}] \u2714 Removed app commands globally`);
     } catch (err) {
-      console.log("[SlashCommandManager] \u2716 Failed to remove app (/) commands globally", err);
+      console.log(`[${this.typeName}] \u2716 Failed to remove app commands globally`, err);
     }
   }
 };
-var VimcordPrefixCommandManager = class {
+var VimcordSlashCommandManager = class extends VimcordAppCommandManager {
   constructor(client) {
-    this.client = client;
-  }
-  commands = /* @__PURE__ */ new Map();
-  get(name) {
-    if (this.client.config.prefixCommands.allowCaseInsensitiveCommandNames) {
-      name = name.toLowerCase();
-      return Array.from(this.commands.values()).find((cmd) => cmd.name.toLowerCase() === name);
-    }
-    return this.commands.get(name);
-  }
-  getByAlias(alias) {
-    if (this.client.config.prefixCommands.allowCaseInsensitiveCommandNames) {
-      alias = alias.toLowerCase();
-      return Array.from(this.commands.values()).find((cmd) => cmd.aliases?.includes(alias));
-    }
-    return Array.from(this.commands.values()).find((cmd) => cmd.aliases?.includes(alias));
+    super(client, "SlashCommandManager");
+  }
+  async importFrom(dir, replaceAll = false) {
+    if (replaceAll) this.commands.clear();
+    const dirs = Array.isArray(dir) ? dir : [dir];
+    const modules = (await Promise.all(
+      dirs.map((d) => importModulesFromDir(d, "slash"))
+    )).flat();
+    for (const { module } of modules) {
+      this.commands.set(module.default.builder.name, module.default);
+    }
+    this.client.logger.moduleLoaded("Slash Commands", modules.length);
+    return this.commands;
   }
-  /** Import command modules that end with `.prefix` */
-  async importFrom(dir, replaceAll) {
-    if (replaceAll) {
-      this.commands.clear();
-    }
-    dir = Array.isArray(dir) ? dir : [dir];
-    const commandModules = await Promise.all(
-      dir.map((dir2) => importModulesFromDir(dir2, "prefix"))
-    );
-    let importedCommands = 0;
-    for (const command of commandModules.flat()) {
-      this.commands.set(command.module.default.name, command.module.default);
-      importedCommands++;
-    }
-    this.client.logger.moduleLoaded("Prefix Commands", importedCommands);
+};
+var VimcordContextCommandManager = class extends VimcordAppCommandManager {
+  constructor(client) {
+    super(client, "ContextCommandManager");
+  }
+  async importFrom(dir, replaceAll = false) {
+    if (replaceAll) this.commands.clear();
+    const dirs = Array.isArray(dir) ? dir : [dir];
+    const modules = (await Promise.all(
+      dirs.map((d) => importModulesFromDir(d, "ctx"))
+    )).flat();
+    for (const { module } of modules) {
+      this.commands.set(module.default.builder.name, module.default);
+    }
+    this.client.logger.moduleLoaded("Context Commands", modules.length);
     return this.commands;
   }
 };
-var VimcordContextCommandManager = class {
+var VimcordPrefixCommandManager = class {
   constructor(client) {
     this.client = client;
   }
   commands = /* @__PURE__ */ new Map();
-  /** Import command modules that end with `.ctx` */
-  async importFrom(dir, replaceAll) {
-    if (replaceAll) {
-      this.commands.clear();
-    }
-    dir = Array.isArray(dir) ? dir : [dir];
-    const commandModules = await Promise.all(
-      dir.map((dir2) => importModulesFromDir(dir2, "ctx"))
-    );
-    let importedCommands = 0;
-    for (const command of commandModules.flat()) {
-      this.commands.set(command.module.default.builder.name, command.module.default);
-      importedCommands++;
+  resolve(trigger) {
+    const config = this.client.config.prefixCommands;
+    const search = config.allowCaseInsensitiveCommandNames ? trigger.toLowerCase() : trigger;
+    return Array.from(this.commands.values()).find((cmd) => {
+      const opts = cmd.toConfig();
+      const name = config.allowCaseInsensitiveCommandNames ? opts.name.toLowerCase() : opts.name;
+      if (name === search) return true;
+      return opts.aliases?.some(
+        (a) => config.allowCaseInsensitiveCommandNames ? a.toLowerCase() === search : a === search
+      );
+    });
+  }
+  async importFrom(dir, replaceAll = false) {
+    if (replaceAll) this.commands.clear();
+    const dirs = Array.isArray(dir) ? dir : [dir];
+    const modules = (await Promise.all(
+      dirs.map(
+        (d) => importModulesFromDir(d, "prefix")
+      )
+    )).flat();
+    for (const { module } of modules) {
+      this.commands.set(module.default.toConfig().name, module.default);
     }
-    this.client.logger.moduleLoaded("Context Commands", importedCommands);
+    this.client.logger.moduleLoaded("Prefix Commands", modules.length);
     return this.commands;
   }
 };
+var VimcordCommandManager = class {
+  slash;
+  prefix;
+  context;
+  constructor(client) {
+    this.slash = new VimcordSlashCommandManager(client);
+    this.prefix = new VimcordPrefixCommandManager(client);
+    this.context = new VimcordContextCommandManager(client);
+  }
+};
 
 // src/modules/event.manager.ts
 import { Events } from "discord.js";
@@ -2087,7 +1995,7 @@ var BetterEmbed = class _BetterEmbed {
     }
     if (this.data.description) {
       this.data.description = formatString(
-        Array.isArray(this.data.description) ? this.data.description.join("\n") : this.data.description
+        Array.isArray(this.data.description) ? this.data.description.filter((s) => s !== null && s !== void 0).join("\n") : this.data.description
       );
     }
     if (this.data.footer && typeof this.data.footer === "object") {
@@ -2099,7 +2007,7 @@ var BetterEmbed = class _BetterEmbed {
     if (this.data.imageUrl) {
       this.data.imageUrl = formatString(this.data.imageUrl);
     }
-    this.data.fields = this.data.fields.map((field) => ({
+    this.data.fields = this.data.fields.filter(Boolean).map((field) => ({
       ...field,
       name: formatString(field.name),
       value: formatString(field.value)
@@ -2324,7 +2232,7 @@ async function retryExponentialBackoff(fn, maxRetries = 3, retryDelay = 1e3) {
 }
 
 // package.json
-var version = "1.0.0";
+var version = "1.0.1";
 
 // src/client.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -2590,62 +2498,63 @@ var Vimcord = class _Vimcord extends Client2 {
     return fetchGuild(client, id);
   }
 };
-var defaultSlashCommandHandler = new EventBuilder({
-  event: "interactionCreate",
-  name: "SlashCommandHandler",
-  async execute(client, interaction) {
-    if (!interaction.isChatInputCommand()) return;
-    const command = client.commands.slash.get(interaction.commandName);
-    if (!command) {
-      return interaction.reply({
-        content: `**/\`${interaction.commandName}\`** is not a command`,
-        flags: "Ephemeral"
-      });
-    }
-    if (command.deferReply && !interaction.replied && !interaction.deferred) {
-      await interaction.deferReply(typeof command.deferReply === "object" ? command.deferReply : void 0);
-    }
-    try {
-      return command.executeCommand(client, interaction);
-    } catch (err) {
-      sendCommandErrorEmbed(client, err, interaction.guild, interaction);
-      throw err;
-    }
-  }
-});
 var defaultPrefixCommandHandler = new EventBuilder({
   event: "messageCreate",
   name: "PrefixCommandHandler",
   async execute(client, message) {
-    if (message.author.bot) return;
+    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(client.config.prefixCommands.defaultPrefix)) {
-      if (client.config.prefixCommands.allowMentionAsPrefix) {
-        if (!message.content.startsWith(`${userMention(client.user.id)} `)) {
-          return;
-        } else {
-          prefixUsed = `${userMention(client.user.id)} `;
-        }
-      } else {
-        return;
+    if (message.content.startsWith(activePrefix)) {
+      prefixUsed = activePrefix;
+    } else if (config.allowMentionAsPrefix) {
+      const mention = userMention(client.user.id);
+      if (message.content.startsWith(mention)) {
+        prefixUsed = message.content.startsWith(`${mention} `) ? `${mention} ` : mention;
       }
-    } else {
-      prefixUsed = client.config.prefixCommands.defaultPrefix;
     }
-    message.content = message.content.slice(prefixUsed.length);
-    let commandName = message.content.split(" ")[0];
-    if (!commandName) {
-      return;
+    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.resolve(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;
     }
-    const command = client.commands.prefix.get(commandName) || client.commands.prefix.getByAlias(commandName);
+  }
+});
+var defaultSlashCommandHandler = new EventBuilder({
+  event: "interactionCreate",
+  name: "SlashCommandHandler",
+  async execute(client, interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    const command = client.commands.slash.get(interaction.commandName);
     if (!command) {
-      return;
+      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" });
     }
-    message.content = message.content.slice(commandName.length + 1);
     try {
-      return command.executeCommand(client, message);
+      return await command.run(client, client, interaction);
     } catch (err) {
-      sendCommandErrorEmbed(client, err, message.guild, message);
+      await sendCommandErrorEmbed(client, err, interaction.guild, interaction);
       throw err;
     }
   }
@@ -2653,9 +2562,22 @@ var defaultPrefixCommandHandler = new EventBuilder({
 var defaultContextCommandHandler = new EventBuilder({
   event: "interactionCreate",
   name: "ContextCommandHandler",
-  execute(client, interaction) {
+  async execute(client, interaction) {
     if (!interaction.isContextMenuCommand()) return;
-    interaction.reply({ content: "This handler is not yet implemented" });
+    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;
+    }
   }
 });
 
@@ -2670,8 +2592,8 @@ try {
 }
 var globalInstanceEmitter = new EventEmitter2();
 var instances = [];
-async function useMongoDatabase(index) {
-  const instance = instances.at(index ?? 0);
+async function useMongoDatabase(instanceIndex) {
+  const instance = instances.at(instanceIndex ?? 0);
   if (!instance) {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => reject("useMongoDatabase timed out"), 45e3);
@@ -2683,6 +2605,15 @@ async function useMongoDatabase(index) {
   }
   return instance;
 }
+async function useReadyMongoDatabase(instanceIndex) {
+  const instance = await useMongoDatabase(instanceIndex);
+  await instance.waitForReady();
+  return instance;
+}
+async function createMongoSession(instanceIndex, options) {
+  const instance = await useReadyMongoDatabase(instanceIndex);
+  return instance.mongoose.startSession(options);
+}
 var MongoDatabase = class {
   constructor(client, options) {
     this.client = client;
@@ -2839,6 +2770,7 @@ var MongoSchemaBuilder = class {
     this.eventEmitter.off(event, listener);
     return this;
   }
+  /** Execute a function while ensuring the connection is ready. On error it will retry using an exponential backoff. */
   async execute(fn) {
     try {
       if (!this.isReady) {
@@ -2875,9 +2807,9 @@ var MongoSchemaBuilder = class {
       return id;
     });
   }
-  async count(filter) {
+  async count(filter, options) {
     return await this.execute(async () => {
-      return this.model.countDocuments(filter);
+      return this.model.countDocuments(filter, options);
     });
   }
   async exists(filter) {
@@ -2885,29 +2817,29 @@ var MongoSchemaBuilder = class {
       return await this.model.exists(filter) ? true : false;
     });
   }
-  async create(query) {
+  async create(query, options) {
     return await this.execute(async () => {
-      return this.model.create(query);
-    });
+      return this.model.create(query, options);
+    }) ?? [];
   }
   async upsert(filter, query, options) {
     return await this.execute(async () => {
       return this.model.findOneAndUpdate(filter, query, { ...options, upsert: true, new: true });
     });
   }
-  async delete(filter) {
+  async delete(filter, options) {
     return await this.execute(async () => {
-      return this.model.deleteOne(filter);
+      return this.model.deleteOne(filter, options);
     });
   }
-  async deleteAll(filter) {
+  async deleteAll(filter, options) {
     return await this.execute(async () => {
-      return this.model.deleteMany(filter);
+      return this.model.deleteMany(filter, options);
     });
   }
-  async distinct(key, filter) {
+  async distinct(key, filter, options) {
     return await this.execute(async () => {
-      return this.model.distinct(key, filter);
+      return this.model.distinct(key, filter, options);
     });
   }
   async fetch(filter, projection, options) {
@@ -2938,6 +2870,215 @@ var MongoSchemaBuilder = class {
   }
 };
 
+// src/tools/BetterCollector.ts
+var CollectorTimeoutType = /* @__PURE__ */ ((CollectorTimeoutType2) => {
+  CollectorTimeoutType2[CollectorTimeoutType2["DisableComponents"] = 0] = "DisableComponents";
+  CollectorTimeoutType2[CollectorTimeoutType2["DeleteMessage"] = 1] = "DeleteMessage";
+  CollectorTimeoutType2[CollectorTimeoutType2["DoNothing"] = 2] = "DoNothing";
+  return CollectorTimeoutType2;
+})(CollectorTimeoutType || {});
+var BetterCollector = class _BetterCollector {
+  message;
+  collector;
+  options;
+  activeUsers = /* @__PURE__ */ new Set();
+  participantWarningCooldowns = /* @__PURE__ */ new Map();
+  config;
+  events = {
+    collectId: /* @__PURE__ */ new Map(),
+    collect: [],
+    end: [],
+    timeout: []
+  };
+  static create(message, options) {
+    return new _BetterCollector(message, options);
+  }
+  async validateParticipant(interaction, participants) {
+    const allowedParticipants = participants || this.options?.participants || [];
+    if (!allowedParticipants.length) return true;
+    const isAllowed = allowedParticipants.some((user) => {
+      if (typeof user === "string") return user === interaction.user.id;
+      if (typeof user === "object" && "id" in user) return user.id === interaction.user.id;
+      return false;
+    });
+    if (!isAllowed) {
+      const now = Date.now();
+      const lastWarned = this.participantWarningCooldowns.get(interaction.user.id) || 0;
+      if (now - lastWarned > this.config.collector.notAParticipantWarningCooldown) {
+        this.participantWarningCooldowns.set(interaction.user.id, now);
+        if (this.config.collector.notAParticipantMessage) {
+          await interaction.reply({
+            content: this.config.collector.notAParticipantMessage,
+            flags: "Ephemeral"
+          }).catch(() => {
+          });
+        } else {
+          await interaction.deferUpdate().catch(() => {
+          });
+        }
+      } else {
+        await interaction.deferUpdate().catch(() => {
+        });
+      }
+    }
+    return isAllowed;
+  }
+  build() {
+    if (!this.message) return;
+    if (this.collector) return;
+    this.collector = this.message.createMessageComponentCollector({
+      idle: this.options?.idle ?? this.config.timeouts.collectorIdle,
+      time: this.options?.timeout ?? this.config.timeouts.collectorTimeout,
+      componentType: this.options?.type,
+      max: this.options?.max,
+      maxComponents: this.options?.maxComponents,
+      maxUsers: this.options?.maxUsers
+    });
+    this.setupListeners();
+  }
+  setupListeners() {
+    if (!this.collector) return;
+    this.collector.on("collect", async (interaction) => {
+      if (this.options?.userLock && this.activeUsers.has(interaction.user.id)) {
+        return interaction.reply({ content: this.config.collector.userLockMessage, flags: "Ephemeral" }).catch(() => {
+        });
+      }
+      if (this.options?.userLock) {
+        this.activeUsers.add(interaction.user.id);
+      }
+      const globalListeners = this.events.collect;
+      const idListeners = this.events.collectId.get(interaction.customId) || [];
+      const allListeners = [...globalListeners, ...idListeners];
+      const shouldBeDeferred = allListeners.find((l) => l.options?.defer)?.options?.defer;
+      const validListeners = [];
+      for (const listener of allListeners) {
+        const isAllowed = await this.validateParticipant(interaction, listener.options?.participants);
+        if (isAllowed) validListeners.push(listener);
+      }
+      if (validListeners.length === 0) return;
+      try {
+        if (shouldBeDeferred) {
+          if (typeof shouldBeDeferred === "object") {
+            if (shouldBeDeferred.update) {
+              await interaction.deferUpdate().catch(Boolean);
+            } else {
+              await interaction.deferReply({ ephemeral: shouldBeDeferred.ephemeral }).catch(Boolean);
+            }
+          } else {
+            await interaction.deferReply().catch(Boolean);
+          }
+        }
+        if (this.options?.sequential) {
+          for (const listener of allListeners) {
+            try {
+              const isAllowed = await this.validateParticipant(interaction, listener.options?.participants);
+              if (!isAllowed) return;
+              await listener.fn(interaction);
+            } catch (err) {
+              this.handleListenerError(err);
+            }
+          }
+        } else {
+          Promise.all(
+            allListeners.map((l) => {
+              const isAllowed = this.validateParticipant(interaction, l.options?.participants);
+              if (!isAllowed) return;
+              return l.fn(interaction).catch(this.handleListenerError);
+            })
+          );
+        }
+      } finally {
+        if (this.options?.userLock) {
+          this.activeUsers.delete(interaction.user.id);
+        }
+      }
+    });
+    this.collector.on("end", async (collected, reason) => {
+      if (this.options?.sequential) {
+        for (const listener of this.events.end) {
+          try {
+            await listener.fn(collected, reason);
+          } catch (err) {
+            this.handleListenerError(err);
+          }
+        }
+      } else {
+        Promise.all(this.events.end.map((l) => l.fn(collected, reason).catch(this.handleListenerError)));
+      }
+      switch (this.options?.onTimeout) {
+        case 0 /* DisableComponents */:
+          if (!this.message?.editable) break;
+          try {
+            const disabledRows = this.message.components.map((row) => {
+              const updatedRow = row.toJSON();
+              if ("components" in updatedRow) {
+                updatedRow.components = updatedRow.components.map((component) => ({
+                  ...component,
+                  disabled: true
+                }));
+              }
+              return updatedRow;
+            });
+            await this.message.edit({ components: disabledRows });
+          } catch (err) {
+            if (!(err instanceof Error && err.message.includes("Unknown Message"))) {
+              this.handleListenerError(err);
+            }
+          }
+          break;
+        case 1 /* DeleteMessage */:
+          if (!this.message?.deletable) break;
+          await this.message.delete().catch(Boolean);
+          break;
+        case 2 /* DoNothing */:
+        default:
+          break;
+      }
+    });
+  }
+  handleListenerError(err) {
+    console.error("[BetterCollector] Listener Error:", err);
+  }
+  constructor(message, options) {
+    this.config = options?.config || globalVimcordToolsConfig;
+    this.message = message || void 0;
+    this.options = options;
+    this.build();
+  }
+  on(idOrFunc, fnOrOptions, options) {
+    let finalFn;
+    let finalOptions;
+    let customId;
+    if (typeof idOrFunc === "function") {
+      finalFn = idOrFunc;
+      finalOptions = fnOrOptions;
+    } else {
+      if (typeof fnOrOptions !== "function") {
+        throw new Error("[BetterCollector] Second argument must be a function when a customId is provided.");
+      }
+      customId = idOrFunc;
+      finalFn = fnOrOptions;
+      finalOptions = options;
+    }
+    if (customId) {
+      const listeners = this.events.collectId.get(customId) || [];
+      listeners.push({ fn: finalFn, options: finalOptions });
+      this.events.collectId.set(customId, listeners);
+    } else {
+      this.events.collect.push({ fn: finalFn, options: finalOptions });
+    }
+    return this;
+  }
+  onEnd(fn, options) {
+    this.events.end.push({ fn, options });
+    return this;
+  }
+  /** Manually stop the collector and trigger cleanup */
+  stop(reason = "manual") {
+    this.collector?.stop(reason);
+  }
+};
+
 // src/tools/BetterContainer.ts
 import {
   ButtonBuilder as ButtonBuilder2,
@@ -2982,7 +3123,9 @@ var BetterContainer = class {
     return this;
   }
   addText(text) {
-    this.container.addTextDisplayComponents((tdb) => tdb.setContent(Array.isArray(text) ? text.join("\n") : text));
+    this.container.addTextDisplayComponents(
+      (tdb) => tdb.setContent(Array.isArray(text) ? text.filter((t) => t !== null && t !== void 0).join("\n") : text)
+    );
     return this;
   }
   addMedia(...media) {
@@ -3006,7 +3149,9 @@ var BetterContainer = class {
     this.container.addSectionComponents((sb) => {
       if (data.text) {
         sb.addTextDisplayComponents(
-          (tdb) => tdb.setContent(Array.isArray(data.text) ? data.text.join("\n") : data.text)
+          (tdb) => tdb.setContent(
+            Array.isArray(data.text) ? data.text.filter((t) => t !== null && t !== void 0).join("\n") : data.text
+          )
         );
       }
       if (data.thumbnail) sb.setThumbnailAccessory(new ThumbnailBuilder(data.thumbnail));
@@ -3237,6 +3382,7 @@ var BetterModal = class {
 // src/tools/Paginator.ts
 import {
   ActionRowBuilder as ActionRowBuilder4,
+  AttachmentBuilder as AttachmentBuilder2,
   ButtonBuilder as ButtonBuilder3,
   ButtonStyle as ButtonStyle2,
   ComponentType as ComponentType2,
@@ -3256,6 +3402,7 @@ var PaginationTimeoutType = /* @__PURE__ */ ((PaginationTimeoutType2) => {
   PaginationTimeoutType2[PaginationTimeoutType2["DisableComponents"] = 0] = "DisableComponents";
   PaginationTimeoutType2[PaginationTimeoutType2["ClearComponents"] = 1] = "ClearComponents";
   PaginationTimeoutType2[PaginationTimeoutType2["DeleteMessage"] = 2] = "DeleteMessage";
+  PaginationTimeoutType2[PaginationTimeoutType2["DoNothing"] = 3] = "DoNothing";
   return PaginationTimeoutType2;
 })(PaginationTimeoutType || {});
 function wrapPositive(num, max) {
@@ -3336,7 +3483,8 @@ var Paginator = class {
       last: [],
       collect: [],
       react: [],
-      timeout: []
+      preTimeout: [],
+      postTimeout: []
     };
     if (this.options.pages.length) {
       this.addChapter(this.options.pages, { label: "Default" });
@@ -3403,16 +3551,23 @@ var Paginator = class {
       embeds: [],
       components: [],
       flags: [],
+      files: [],
+      // Explicitly empty to clear previous files on page switch
       ...options,
       withResponse: true
     };
     const page = this.data.page.current;
+    const currentChapter = this.chapters[this.data.page.index.chapter];
+    const chapterFile = currentChapter?.files?.[this.data.page.index.nested];
+    if (chapterFile) sendOptions.files.push(chapterFile);
     if (Array.isArray(page)) {
       sendOptions.embeds.push(...page);
     } else if (typeof page === "string") {
       sendOptions.content = page;
     } else if (isEmbed(page)) {
       sendOptions.embeds.push(page);
+    } else if (page instanceof AttachmentBuilder2) {
+      sendOptions.files.push(page);
     } else if (page instanceof ContainerBuilder3 || page instanceof BetterContainer) {
       sendOptions.components.push(page);
       if (!sendOptions.flags.includes("IsComponentsV2")) {
@@ -3424,7 +3579,7 @@ var Paginator = class {
   }
   async handlePostTimeout() {
     if (!this.data.message) return;
-    this.callEventStack("timeout", this.data.message);
+    this.callEventStack("preTimeout", this.data.message);
     this.data.collectors.component?.stop();
     this.data.collectors.reaction?.stop();
     switch (this.options.onTimeout) {
@@ -3468,7 +3623,10 @@ var Paginator = class {
       case 2 /* DeleteMessage */:
         await this.data.message.delete().catch(Boolean);
         break;
+      case 3 /* DoNothing */:
+        break;
     }
+    this.callEventStack("postTimeout", this.data.message);
   }
   async nav_removeFromMessage() {
     if (!this.data.message?.editable) return;
@@ -3515,35 +3673,43 @@ var Paginator = class {
           await i.reply({ content: "Jump not implemented yet.", flags: "Ephemeral" });
           return;
         }
-        await i.deferUpdate().catch(Boolean);
         switch (i.customId) {
           case "ssm_chapterSelect":
+            await i.deferUpdate().catch(Boolean);
             const chapterIndex = this.chapters.findIndex(
               (c) => c.id === i.values[0]
             );
             await this.setPage(chapterIndex, 0);
+            await this.refresh();
             break;
           case "btn_first":
+            await i.deferUpdate().catch(Boolean);
             this.callEventStack("first", this.data.page.current, this.data.page.index);
             await this.setPage(this.data.page.index.chapter, 0);
+            await this.refresh();
             break;
           case "btn_back":
+            await i.deferUpdate().catch(Boolean);
             this.callEventStack("back", this.data.page.current, this.data.page.index);
             await this.setPage(this.data.page.index.chapter, this.data.page.index.nested - 1);
+            await this.refresh();
             break;
           case "btn_next":
+            await i.deferUpdate().catch(Boolean);
             this.callEventStack("next", this.data.page.current, this.data.page.index);
             await this.setPage(this.data.page.index.chapter, this.data.page.index.nested + 1);
+            await this.refresh();
             break;
           case "btn_last":
+            await i.deferUpdate().catch(Boolean);
             this.callEventStack("last", this.data.page.current, this.data.page.index);
             await this.setPage(
               this.data.page.index.chapter,
               this.chapters[this.data.page.index.chapter].pages.length - 1
             );
+            await this.refresh();
             break;
         }
-        await this.refresh();
       } catch (err) {
         console.error("[Paginator] Component navigation error", err);
       }
@@ -3583,7 +3749,7 @@ var Paginator = class {
       data.value = `ssm_c:${this.chapters.length}`;
     }
     const normalizedPages = resolvePages(pages);
-    this.chapters.push({ id: data.value, pages: normalizedPages });
+    this.chapters.push({ id: data.value, pages: normalizedPages, files: data.files });
     this.data.components.chapterSelect.addOptions(data);
     return this;
   }
@@ -3965,7 +4131,7 @@ CLI.addCommand("help", "View information about a command, or the available CLI o
   }
   CLI.logger.table("(help)", helpList);
 });
-CLI.addCommand("register", "Register app commands globally, or per guild", async (args, content) => {
+CLI.addCommand("register", "Register app commands (slash & context) globally, or per guild", async (args, content) => {
   const client = CLI.getClientInstance(content);
   if (!client) return;
   const mode = args[0]?.toLowerCase() || "";
@@ -3976,10 +4142,14 @@ CLI.addCommand("register", "Register app commands globally, or per guild", async
   if (!guildIds.length) guildIds = client.guilds.cache.map((g) => g.id);
   switch (mode) {
     case "guild":
+      CLI.logger.info("Registering guild commands...");
       await client.commands.slash.registerGuild({ guilds: guildIds });
+      await client.commands.context.registerGuild({ guilds: guildIds });
       break;
     case "global":
+      CLI.logger.info("Registering global commands...");
       await client.commands.slash.registerGlobal();
+      await client.commands.context.registerGlobal();
       break;
   }
 });
@@ -3994,10 +4164,14 @@ CLI.addCommand("unregister", "Unregister app commands globally, or per guild", a
   if (!guildIds.length) guildIds = client.guilds.cache.map((g) => g.id);
   switch (mode) {
     case "guild":
+      CLI.logger.info("Unregistering guild commands...");
       await client.commands.slash.unregisterGuild({ guilds: guildIds });
+      await client.commands.context.unregisterGuild({ guilds: guildIds });
       break;
     case "global":
+      CLI.logger.info("Unregistering global commands...");
       await client.commands.slash.unregisterGlobal();
+      await client.commands.context.unregisterGlobal();
       break;
   }
 });
@@ -4012,46 +4186,48 @@ CLI.addCommand("stats", "View statistics about a client instance", (args, conten
     "Memory Usage:": `${(process.memoryUsage().rss / 1024 / 1024).toFixed(2)} MB`
   });
 });
-CLI.addCommand("cmds", "List the loaded commands", (args, content) => {
+CLI.addCommand("cmds", "List the loaded commands", async (args, content) => {
   const client = CLI.getClientInstance(content);
   if (!client) return;
-  const mode = args[0] || "slash";
+  const mode = (args[0] || "slash").toLowerCase();
   switch (mode) {
-    case "slash":
-      const slashCommands = Array.from(client.commands.slash.commands.values());
-      slashCommands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
-      const slashCommands_f = {};
-      for (const cmd of slashCommands) {
-        slashCommands_f[`/${cmd.builder.name}`] = `~ ${cmd.builder.description || "No description"}`;
+    case "slash": {
+      const commands = Array.from(client.commands.slash.commands.values());
+      commands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
+      const tableData = {};
+      for (const cmd of commands) {
+        tableData[`/${cmd.builder.name}`] = `~ ${cmd.builder.description || "No description"}`;
       }
-      return CLI.logger.table(
-        `(cmds) ~ slash (${jsTools2.formatThousands(client.commands.slash.commands.size)})`,
-        slashCommands_f
-      );
-    case "prefix":
-      const prefixCommands = Array.from(client.commands.prefix.commands.values());
-      prefixCommands.sort((a, b) => a.name.localeCompare(b.name));
-      const prefixCommands_f = {};
-      for (const cmd of prefixCommands) {
-        prefixCommands_f[`${client.config.prefixCommands.defaultPrefix}${cmd.name}`] = `~ ${cmd.description || "No description"}`;
+      return CLI.logger.table(`(cmds) ~ slash (${jsTools2.formatThousands(commands.length)})`, tableData);
+    }
+    case "prefix": {
+      const commands = Array.from(client.commands.prefix.commands.values());
+      commands.sort((a, b) => {
+        const nameA = a.toConfig().name;
+        const nameB = b.toConfig().name;
+        return nameA.localeCompare(nameB);
+      });
+      const tableData = {};
+      const defaultPrefix = client.config.prefixCommands.defaultPrefix;
+      for (const cmd of commands) {
+        const config = cmd.toConfig();
+        const aliasIndicator = config.aliases?.length ? ` [${config.aliases.join(", ")}]` : "";
+        tableData[`${defaultPrefix}${config.name}${aliasIndicator}`] = `~ ${config.description || "No description"}`;
       }
-      return CLI.logger.table(
-        `(cmds) ~ prefix (${jsTools2.formatThousands(client.commands.prefix.commands.size)})`,
-        prefixCommands_f
-      );
-    case "ctx":
-      const contextCommands = Array.from(client.commands.context.commands.values());
-      contextCommands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
-      const contextCommands_f = {};
-      for (const cmd of contextCommands) {
-        contextCommands_f[`${cmd.builder.name}`] = "";
+      return CLI.logger.table(`(cmds) ~ prefix (${jsTools2.formatThousands(commands.length)})`, tableData);
+    }
+    case "ctx": {
+      const commands = Array.from(client.commands.context.commands.values());
+      commands.sort((a, b) => a.builder.name.localeCompare(b.builder.name));
+      const tableData = {};
+      for (const cmd of commands) {
+        const type = cmd.builder.type === 2 ? "User" : "Msg";
+        tableData[`[${type}] ${cmd.builder.name}`] = "";
       }
-      return CLI.logger.table(
-        `(cmds) ~ ctx (${jsTools2.formatThousands(client.commands.context.commands.size)})`,
-        contextCommands_f
-      );
+      return CLI.logger.table(`(cmds) ~ ctx (${jsTools2.formatThousands(commands.length)})`, tableData);
+    }
     default:
-      return CLI.logger.error(`'${mode}' is not a valid option. Your options are [slash|prefix|ctx]`);
+      return CLI.logger.error(`'${mode}' is not a valid option. Valid options: [slash|prefix|ctx]`);
   }
 });
 function initCLI() {
@@ -4077,14 +4253,17 @@ function getClientInstances() {
 }
 export {
   BaseCommandBuilder,
+  BetterCollector,
   BetterContainer,
   BetterEmbed,
   BetterModal,
   CLI,
+  CollectorTimeoutType,
   CommandType,
   ContextCommandBuilder,
   DynaSend,
   EventBuilder,
+  LOGGER_COLORS,
   LogLevel,
   Logger,
   MissingPermissionReason,
@@ -4113,6 +4292,7 @@ export {
   clientInstances,
   createClient,
   createMongoSchema,
+  createMongoSession,
   createToolsConfig,
   createVimcordAppConfig,
   createVimcordContextCommandConfig,
@@ -4146,6 +4326,7 @@ export {
   useClient,
   useMongoDatabase,
   useReadyClient,
+  useReadyMongoDatabase,
   validateCommandPermissions
 };
 //# sourceMappingURL=index.js.map