bakit 1.0.0-beta.9 → 2.0.0-alpha.10

package/dist/index.js

@@ -1,402 +1,213 @@
-// src/index.ts
-import "reflect-metadata";
+import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
+import z4, { z } from 'zod';
+import glob from 'tiny-glob';
+import { createJiti } from 'jiti';
+import { inspect } from 'util';
+import { posix, join, dirname } from 'path';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { mkdir, writeFile, readFile, rm } from 'fs/promises';
+import { createHash } from 'crypto';
 
-// src/BakitClient.ts
-import {
-  Client,
-  codeBlock,
-  Events
-} from "discord.js";
-
-// src/command/CommandRegistry.ts
-import {
-  Collection as Collection2,
-  SlashCommandBuilder,
-  SlashCommandSubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder
-} from "discord.js";
-import glob from "tiny-glob";
-import { pathToFileURL } from "url";
-
-// src/command/CommandEntry.ts
-import { Collection } from "discord.js";
-
-// src/base/BaseEntry.ts
-var BaseEntry = class {
-  target;
-  hooks = {
-    ["MAIN" /* Main */]: void 0,
-    ["ERROR" /* Error */]: void 0,
-    ["POST" /* Post */]: void 0,
-    ["PRE" /* Pre */]: void 0
-  };
-  main;
-  pre;
-  post;
-  error;
-  constructor() {
-    this.main = this.createMainHookDecorator("MAIN" /* Main */);
-    this.pre = this.createMainHookDecorator("PRE" /* Pre */);
-    this.post = this.createMainHookDecorator("POST" /* Post */);
-    this.error = this.createMainHookDecorator("ERROR" /* Error */);
-  }
-  setTarget(target) {
-    this.target = target;
-  }
-  createMainHookDecorator(state) {
-    return (target, _key, descriptor) => {
-      this.addHook(state, target, descriptor);
-    };
-  }
-  createErrorHookDecorator(state) {
-    return (target, _key, descriptor) => {
-      this.addHook(state, target, descriptor);
-    };
-  }
-  addHook(state, target, descriptor) {
-    if (this.target && this.target !== target.constructor) {
-      throw new Error("Hook is used at wrong constructor.");
-    }
-    const { value: method } = descriptor;
-    if (typeof method !== "function") {
-      throw new Error("Invalid target method for hook.");
-    }
-    const hook = {
-      state,
-      method,
-      entry: this
-    };
-    this.hooks[state] = hook;
-  }
-};
-
-// src/command/CommandEntry.ts
-var BaseCommandEntry = class extends BaseEntry {
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-};
-var BaseCommandGroupEntry = class extends BaseCommandEntry {
-  children = new Collection();
-  subcommand(options) {
-    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
-    if (this.children.has(fullOptions.name)) {
-      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
-    }
-    const subcommand = new SubcommandEntry(fullOptions, this);
-    this.children.set(fullOptions.name, subcommand);
-    return subcommand;
-  }
-};
-var RootCommandEntry = class extends BaseCommandGroupEntry {
-  group(options) {
-    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
-    if (this.children.has(fullOptions.name)) {
-      throw new Error(`Entry "${fullOptions.name}" is already existed.`);
-    }
-    const group = new CommandGroupEntry(fullOptions, this);
-    this.children.set(fullOptions.name, group);
-    return group;
-  }
-};
-var CommandGroupEntry = class extends BaseCommandGroupEntry {
-  constructor(options, parent) {
-    super(options);
-    this.parent = parent;
-  }
-};
-var SubcommandEntry = class extends BaseCommandEntry {
-  constructor(options, parent) {
-    super(options);
-    this.parent = parent;
-  }
-};
-
-// src/command/Command.ts
-var CommandAPI;
-((CommandAPI2) => {
-  const rootEntries = /* @__PURE__ */ new WeakMap();
-  function use(root) {
-    return (target) => {
-      root.setTarget(target);
-      rootEntries.set(target, root);
-    };
-  }
-  CommandAPI2.use = use;
-  function getRoot(constructor) {
-    return rootEntries.get(constructor);
-  }
-  CommandAPI2.getRoot = getRoot;
-})(CommandAPI || (CommandAPI = {}));
-function CommandFactory(options) {
-  if (typeof options === "string") {
-    options = { name: options };
-  }
-  if (!options.description) {
-    options.description = options.name;
-  }
-  return new RootCommandEntry(options);
+// src/config.ts
+var INTENT_GROUPS = {
+  [GatewayIntentBits.Guilds]: [
+    Events.GuildCreate,
+    Events.GuildDelete,
+    Events.GuildUpdate,
+    Events.GuildUnavailable,
+    Events.GuildRoleCreate,
+    Events.GuildRoleDelete,
+    Events.GuildRoleUpdate,
+    Events.ChannelCreate,
+    Events.ChannelDelete,
+    Events.ChannelUpdate,
+    Events.ChannelPinsUpdate,
+    Events.ThreadCreate,
+    Events.ThreadDelete,
+    Events.ThreadUpdate,
+    Events.ThreadListSync,
+    Events.ThreadMemberUpdate,
+    Events.ThreadMembersUpdate,
+    Events.StageInstanceCreate,
+    Events.StageInstanceUpdate,
+    Events.StageInstanceDelete
+  ],
+  [GatewayIntentBits.GuildMembers]: [
+    Events.GuildMemberAdd,
+    Events.GuildMemberUpdate,
+    Events.GuildMemberRemove,
+    Events.ThreadMembersUpdate
+  ],
+  [GatewayIntentBits.GuildModeration]: [Events.GuildAuditLogEntryCreate, Events.GuildBanAdd, Events.GuildBanRemove],
+  [GatewayIntentBits.GuildExpressions]: [
+    Events.GuildEmojiCreate,
+    Events.GuildEmojiDelete,
+    Events.GuildEmojiUpdate,
+    Events.GuildStickerCreate,
+    Events.GuildStickerDelete,
+    Events.GuildStickerUpdate,
+    Events.GuildSoundboardSoundCreate,
+    Events.GuildSoundboardSoundUpdate,
+    Events.GuildSoundboardSoundDelete,
+    Events.GuildSoundboardSoundsUpdate
+  ],
+  [GatewayIntentBits.GuildIntegrations]: [Events.GuildIntegrationsUpdate],
+  [GatewayIntentBits.GuildWebhooks]: [Events.WebhooksUpdate],
+  [GatewayIntentBits.GuildInvites]: [Events.InviteCreate, Events.InviteDelete],
+  [GatewayIntentBits.GuildVoiceStates]: [Events.VoiceStateUpdate],
+  [GatewayIntentBits.GuildPresences]: [Events.PresenceUpdate],
+  [GatewayIntentBits.GuildMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.MessageBulkDelete
+  ],
+  [GatewayIntentBits.GuildMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.GuildMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.DirectMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.ChannelPinsUpdate
+  ],
+  [GatewayIntentBits.DirectMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.DirectMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.MessageContent]: [Events.MessageCreate, Events.MessageUpdate],
+  [GatewayIntentBits.GuildScheduledEvents]: [
+    Events.GuildScheduledEventCreate,
+    Events.GuildScheduledEventDelete,
+    Events.GuildScheduledEventUpdate,
+    Events.GuildScheduledEventUserAdd,
+    Events.GuildScheduledEventUserRemove
+  ],
+  [GatewayIntentBits.AutoModerationConfiguration]: [
+    Events.AutoModerationRuleCreate,
+    Events.AutoModerationRuleDelete,
+    Events.AutoModerationRuleUpdate
+  ],
+  [GatewayIntentBits.AutoModerationExecution]: [Events.AutoModerationActionExecution],
+  [GatewayIntentBits.GuildMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove],
+  [GatewayIntentBits.DirectMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove]
+}, EVENT_INTENT_MAPPING = {};
+for (let [intentStr, events] of Object.entries(INTENT_GROUPS)) {
+  let intent = Number(intentStr);
+  for (let event of events)
+    EVENT_INTENT_MAPPING[event] ??= [], EVENT_INTENT_MAPPING[event].includes(intent) || EVENT_INTENT_MAPPING[event].push(intent);
 }
-var Command = Object.assign(CommandFactory, CommandAPI);
-
-// src/command/argument/Argument.ts
-var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
-  ArgumentType2["String"] = "string";
-  ArgumentType2["Integer"] = "integer";
-  ArgumentType2["Number"] = "number";
-  ArgumentType2["User"] = "user";
-  ArgumentType2["Member"] = "member";
-  return ArgumentType2;
-})(ArgumentType || {});
 
-// src/command/argument/Arg.ts
-var ARGS_KEY = Symbol("args");
-var cache = /* @__PURE__ */ new WeakMap();
-function getMethodArguments(method, init = false) {
-  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-  if (!args) {
-    args = [];
-    if (init) {
-      Reflect.defineMetadata(ARGS_KEY, args, method);
-      cache.set(method, args);
-    }
-  }
-  return init ? args : Object.freeze([...args]);
-}
-function createArgument(type) {
-  return function(options) {
-    const objOptions = typeof options === "string" ? { name: options } : options;
-    const fullOptions = { ...objOptions, type };
-    if (!fullOptions.description) {
-      fullOptions.description = fullOptions.name;
-    }
-    if (!("required" in fullOptions)) {
-      fullOptions.required = true;
-    }
-    return function(target, key, _index) {
-      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-      if (!method) {
-        throw new Error("No method found");
-      }
-      const args = getMethodArguments(method, true);
-      args.unshift(fullOptions);
-    };
-  };
-}
-var string = createArgument("string" /* String */);
-var integer = createArgument("integer" /* Integer */);
-var number = createArgument("number" /* Number */);
-var user = createArgument("user" /* User */);
-var member = createArgument("member" /* Member */);
-function describeArgumentExpectation(arg) {
-  const parts = [arg.type];
-  switch (arg.type) {
-    case "string" /* String */: {
-      if (arg.minLength && !arg.maxLength) {
-        parts.push(`\u2265 ${String(arg.minLength)}`);
-      }
-      if (!arg.minLength && arg.maxLength) {
-        parts.push(`\u2264 ${String(arg.maxLength)}`);
-      }
-      if (arg.minLength && arg.maxLength) {
-        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-      }
-      break;
-    }
-    case "number" /* Number */:
-    case "integer" /* Integer */: {
-      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-        parts.push(`\u2265 ${String(arg.minValue)}`);
-      }
-      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-        parts.push(`\u2264 ${String(arg.maxValue)}`);
-      }
-      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-      }
+// src/utils/string.ts
+function tokenize(content) {
+  let args = [], current = "", quoteChar = null, isEscaped = false;
+  for (let i = 0; i < content.length; i++) {
+    let char = content[i];
+    if (char === void 0)
       break;
+    if (isEscaped) {
+      current += char, isEscaped = false;
+      continue;
     }
-    case "user" /* User */:
-    case "member" /* Member */: {
-      break;
+    if (char === "\\") {
+      isEscaped = true;
+      continue;
     }
+    quoteChar ? char === quoteChar ? quoteChar = null : current += char : char === '"' ? quoteChar = char : /\s/.test(char) ? current.length > 0 && (args.push(current), current = "") : current += char;
   }
-  return parts.join(", ");
+  return current.length > 0 && args.push(current), args;
 }
-function format(arg) {
-  const { name, required, tuple } = arg;
-  const opening = required ? "<" : "[";
-  const closing = required ? ">" : "]";
-  const prefix = tuple ? "..." : "";
-  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+function extractSnowflakeId(input) {
+  if (!input) return null;
+  let mentionMatch = /^<@!?(\d{17,20})>$/.exec(input);
+  if (mentionMatch?.[1])
+    return mentionMatch[1];
+  let idMatch = /^(\d{17,20})$/.exec(input);
+  return idMatch?.[1] ? idMatch[1] : null;
 }
-var Arg = {
-  getMethodArguments,
-  createArgument,
-  describeArgumentExpectation,
-  format,
-  string,
-  number,
-  integer,
-  user,
-  member
-};
 
-// src/command/CommandRegistry.ts
-var CommandRegistry = class _CommandRegistry {
-  static constructors = new Collection2();
-  static instances = new Collection2();
+// src/utils/index.ts
+var $jiti = createJiti(import.meta.url);
+
+// src/config.ts
+var ProjectConfigSchema = z.object({
   /**
-   * Add a command to the registry.
-   * @param constructor The command class you want to add.
+   * The gateway intents to use for the Discord client.
+   *
+   * - `auto` — automatically determine the required intents.
+   * - bigint — a raw bitfield value representing the combined intents.
+   * - array — a list of individual intent flags from `GatewayIntentBits`.
+   *
+   * @defaultvalue `auto`
    */
-  static add(constructor) {
-    const root = Command.getRoot(constructor);
-    if (!root) {
-      throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    this.constructors.set(options.name, constructor);
-    this.instances.set(options.name, new constructor());
-  }
+  intents: z.union([z.literal("auto"), z.bigint(), z.array(z.enum(GatewayIntentBits))]).default("auto"),
   /**
-   * Load and add all commands which matched provided glob pattern to the registry.
-   * @param pattern glob pattern to load.
-   * @param parallel load all matched results in parallel, enabled by default.
-   * @returns All loaded command constructors.
+   * Optional custom client options for Discord.js (excluding `intents`).
+   *
+   * These are passed directly to the `Client` constructor when initializing the bot.
+   *
+   * @see {@link https://discord.js.org/docs/packages/discord.js/main/ClientOptions:Interface}
    */
-  static async load(pattern, parallel = true) {
-    const files = await glob(pattern);
-    const loaders = files.map(async (file) => {
-      const fileURL = pathToFileURL(file).toString();
-      const { default: constructor } = await import(fileURL);
-      _CommandRegistry.add(constructor);
-      return constructor;
-    });
-    if (parallel) {
-      return await Promise.all(loaders);
-    }
-    const result = [];
-    for (const loader of loaders) {
-      result.push(await loader);
-    }
-    return result;
-  }
+  clientOptions: z.custom().optional(),
   /**
-   * Build a command into application command data.
-   * @param constructor The command class you want to build.
-   * @returns a REST JSON version of the application command data.
+   * The path to the main project source directory.
+   *
+   * @defaultvalue `src`
    */
-  static buildSlashCommand(constructor) {
-    const root = Command.getRoot(constructor);
-    if (!root) {
-      throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    const builder = new SlashCommandBuilder().setName(options.name).setDescription(options.description).setNSFW(Boolean(options.nsfw));
-    const args = this.getMainHookArguments(root);
-    if (root.children.size) {
-      this.buildSlashCommandSubcommands(builder, root, args);
-    } else {
-      this.buildSlashCommandOptions(builder, args);
-    }
-    return builder.toJSON();
-  }
-  static getMainHookArguments(entry) {
-    const { hooks } = entry;
-    const mainHook = hooks["MAIN" /* Main */];
-    return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
-  }
-  static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
-    const { children } = entry;
-    for (const child of children.values()) {
-      if (child instanceof CommandGroupEntry && parent instanceof SlashCommandBuilder) {
-        const { options } = child;
-        const group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
-        this.buildSlashCommandSubcommands(group, child, [
-          ...inheritedArgs,
-          ...this.getMainHookArguments(child)
-        ]);
-        parent.addSubcommandGroup(group);
-      } else if (child instanceof SubcommandEntry) {
-        const { options } = child;
-        const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
-        this.buildSlashCommandOptions(subcommand, [
-          ...inheritedArgs,
-          ...this.getMainHookArguments(child)
-        ]);
-        parent.addSubcommand(subcommand);
-      }
-    }
-  }
-  static buildSlashCommandOptions(builder, args) {
-    const argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional");
-    const orderedArgs = [...argGroup.required || [], ...argGroup.optional || []];
-    for (const arg of orderedArgs) {
-      this.attachSlashCommandOption(builder, arg);
-    }
+  entryDir: z.string().default("src"),
+  prefixes: z.array(z.string()).default([]),
+  token: z.string()
+});
+function defineConfig(config) {
+  return config;
+}
+var _config;
+async function loadConfig(cwd = process.cwd()) {
+  if (_config)
+    return console.warn("loadConfig() was called more than once. This shouldn't happen."), _config;
+  let globPattern = `bakit.config.{${["ts", "js"].join(",")}}`, [configPath, other] = await glob(globPattern, {
+    cwd: cwd.replace(/\\/g, "/"),
+    // ensure the path uses `/` instead of `\` on Windows
+    absolute: true
+  });
+  if (!configPath)
+    throw new Error("Missing config file");
+  other && console.warn(`Multiple config files found in ${cwd}. Using ${configPath}.`);
+  let config = await $jiti.import(configPath, { default: true });
+  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
+}
+function getConfig() {
+  if (!_config)
+    throw new Error("Project config is not loaded.");
+  return _config;
+}
+
+// src/base/BaseClientManager.ts
+var BaseClientManager = class {
+  constructor(client) {
+    this.client = client;
   }
-  static attachSlashCommandOption(builder, arg) {
-    const setupOption = (option) => {
-      return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
-    };
-    switch (arg.type) {
-      case "string" /* String */: {
-        builder.addStringOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxLength) {
-            option.setMaxLength(arg.maxLength);
-          }
-          if (arg.minLength) {
-            option.setMinLength(arg.minLength);
-          }
-          return option;
-        });
-        break;
-      }
-      case "integer" /* Integer */: {
-        builder.addIntegerOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxValue) {
-            option.setMaxValue(arg.maxValue);
-          }
-          if (arg.minValue) {
-            option.setMinValue(arg.minValue);
-          }
-          return option;
-        });
-        break;
-      }
-      case "number" /* Number */: {
-        builder.addNumberOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxValue) {
-            option.setMaxValue(arg.maxValue);
-          }
-          if (arg.minValue) {
-            option.setMinValue(arg.minValue);
-          }
-          return option;
-        });
-        break;
-      }
-      case "user" /* User */:
-      case "member" /* Member */: {
-        builder.addUserOption((option) => setupOption(option));
-        break;
-      }
-    }
+};
+
+// src/base/lifecycle/Context.ts
+var Context = class {
+  canceled = false;
+  cancel() {
+    this.canceled = true;
   }
 };
 
-// src/command/Context.ts
-import {
-  ChatInputCommandInteraction,
-  Message
-} from "discord.js";
-var BaseContext = class {
+// src/base/command/CommandContext.ts
+var BaseCommandContext = class extends Context {
   constructor(source) {
+    super();
     this.source = source;
   }
   get client() {
@@ -414,26 +225,25 @@ var BaseContext = class {
   get guildId() {
     return this.source.guildId;
   }
+  get member() {
+    return this.source.member;
+  }
   inGuild() {
-    return Boolean(this.guildId);
+    return !!this.guildId;
   }
   inCachedGuild() {
-    if (this.isChatInput()) {
+    if (this.isChatInput())
       return this.source.inCachedGuild();
-    } else if (this.isMessage()) {
+    if (this.isMessage())
       return this.source.inGuild();
-    } else {
-      throw new Error("Invalid source");
-    }
+    throw new Error("Invalid source");
   }
-  get author() {
-    if (this.isChatInput()) {
+  get user() {
+    if (this.isChatInput())
       return this.source.user;
-    } else if (this.isMessage()) {
+    if (this.isMessage())
       return this.source.author;
-    } else {
-      throw new Error("Invalid source");
-    }
+    throw new Error("Invalid source");
   }
   isChatInput() {
     return this.source instanceof ChatInputCommandInteraction;
@@ -441,769 +251,614 @@ var BaseContext = class {
   isMessage() {
     return this.source instanceof Message;
   }
-};
-var ChatInputContext = class extends BaseContext {
+}, ChatInputContext = class extends BaseCommandContext {
   async send(options) {
-    if (typeof options === "string") {
-      options = { content: options };
-    }
-    const sendOptions = {
+    typeof options == "string" && (options = { content: options });
+    let sendOptions = {
       ...options,
       withResponse: true
     };
-    if (this.source.deferred || this.source.replied) {
-      return await this.source.followUp(sendOptions);
-    }
-    const response = await this.source.reply(sendOptions);
-    return response.resource?.message;
+    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
   }
-};
-var MessageContext = class extends BaseContext {
+}, MessageContext = class extends BaseCommandContext {
   async send(options) {
-    const { channel } = this;
-    if (!channel?.isSendable()) {
+    let { channel } = this;
+    if (!channel?.isSendable())
       throw new Error("Invalid channel or channel is not sendable");
-    }
     return await channel.send(options);
   }
 };
-
-// src/utils/user.ts
-function extractId(value) {
-  const idMatch = value.match(/^<@!?(\d+)>$/);
-  if (idMatch) {
-    return idMatch[1];
+var HookState = /* @__PURE__ */ ((HookState2) => (HookState2.Pre = "PRE", HookState2.Main = "MAIN", HookState2.Post = "POST", HookState2.Error = "ERROR", HookState2))(HookState || {}), HookOrder = /* @__PURE__ */ ((HookOrder2) => (HookOrder2[HookOrder2.First = 0] = "First", HookOrder2[HookOrder2.Last = 1] = "Last", HookOrder2))(HookOrder || {}), LifecycleManager = class {
+  constructor(id) {
+    this.id = id;
   }
-  const numericMatch = value.match(/^(\d{17,19})$/);
-  if (numericMatch) {
-    return numericMatch[1];
-  }
-  return null;
-}
-
-// src/errors/CommandSyntaxError.ts
-var CommandSyntaxErrorType = /* @__PURE__ */ ((CommandSyntaxErrorType2) => {
-  CommandSyntaxErrorType2["MissingRequireArgument"] = "MISSING_REQUIRE_ARGUMENT";
-  CommandSyntaxErrorType2["InvalidArgument"] = "INVALID_ARGUMENT";
-  CommandSyntaxErrorType2["InvalidVariadicArgumentValue"] = "INVALID_VARIADIC_ARGUMENT_VALUE";
-  return CommandSyntaxErrorType2;
-})(CommandSyntaxErrorType || {});
-var CommandSyntaxError = class extends Error {
-  arg;
-  type;
-  expected;
-  received;
-  constructor(options) {
-    let message;
-    const { arg, type, received } = options;
-    const expected = Arg.describeArgumentExpectation(arg);
-    switch (type) {
-      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
-        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join("\n");
-        break;
-      }
-      case "INVALID_ARGUMENT" /* InvalidArgument */: {
-        message = [
-          `Invalid value received for argument "${arg.name}"`,
-          `> Expected: ${expected}`,
-          `> Received: ${String(received)}`
-        ].join("\n");
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  hooks = {
+    MAIN: new Collection(),
+    PRE: new Collection(),
+    POST: new Collection(),
+    ERROR: new Collection()
+  };
+  getName(name) {
+    return `${this.id}:${name}`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  setHook(name, state, callback, order = 1 /* Last */) {
+    let currentHooks = this.hooks[state], key = this.getName(name);
+    if (currentHooks.has(key) && console.warn(`Overriding duplicate hook '${key}' for state '${state}'`), order === 1 /* Last */)
+      currentHooks.set(key, callback);
+    else {
+      let existingEntries = [...currentHooks.entries()].filter(([k]) => k !== key);
+      currentHooks.clear(), currentHooks.set(key, callback);
+      for (let [k, v] of existingEntries)
+        currentHooks.set(k, v);
+    }
+    return this;
+  }
+  main(callback) {
+    return this.setHook("main", "MAIN" /* Main */, callback);
+  }
+  pre(callback) {
+    return this.setHook("pre", "PRE" /* Pre */, callback);
+  }
+  post(callback) {
+    return this.setHook("post", "POST" /* Post */, callback);
+  }
+  error(callback) {
+    return this.setHook("error", "ERROR" /* Error */, callback);
+  }
+  async execute(context, ...args) {
+    let pipeline = [
+      ...this.hooks.PRE.values(),
+      ...this.hooks.MAIN.values(),
+      ...this.hooks.POST.values()
+    ], error;
+    for (let hook of pipeline) {
+      if (context.canceled)
         break;
-      }
-      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
-        message = [
-          `Invalid value received for variadic argument "${arg.name}"`,
-          `> Expected: ${expected}`,
-          `> Received: ${String(received)}`
-        ].join("\n");
+      try {
+        await hook(context, ...args);
+      } catch (e) {
+        error = e;
         break;
       }
-      default: {
-        message = "Unknown error";
+    }
+    if (!error)
+      return;
+    if (!this.hooks.ERROR.size)
+      throw error;
+    for (let [key, callback] of this.hooks.ERROR.entries()) {
+      if (context.canceled)
         break;
+      try {
+        await callback(context, error, ...args);
+      } catch (innerError) {
+        console.error(`[Lifecycle] Error handler for '${key}' failed:`, innerError);
       }
     }
-    super(message);
-    this.arg = arg;
-    this.type = type;
-    this.expected = expected;
-    this.received = received;
-    Error.captureStackTrace(this, this.constructor);
   }
-  get name() {
-    return `CommandSyntaxError[${this.type}]`;
+};
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  required: z.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z.number().min(1).optional(),
+  minLength: z.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z.number().optional(),
+  minValue: z.number().optional()
+}), UserParamSchema = BaseParamSchema.extend({});
+
+// src/errors/BakitError.ts
+var BakitError = class extends Error {
+  constructor(message) {
+    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
   }
 };
 
-// src/command/argument/ArgumentResolver.ts
-var ArgumentResolver = class _ArgumentResolver {
-  constructor(options) {
-    this.options = options;
+// src/errors/ArgumentError.ts
+var ArgumentError = class extends BakitError {
+  constructor(target, reason) {
+    super(`Invalid argument for '${target}': ${reason}`);
+    this.target = target;
+    this.reason = reason;
+  }
+};
+
+// src/base/command/param/Param.ts
+var BaseParam = class {
+  constructor(options, schema) {
+    this.schema = schema;
+    let parsed = schema.parse({
+      ...options,
+      description: options.description ?? options.name
+    });
+    this.options = parsed;
+  }
+  options;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setOption(key, value) {
+    if (value === null)
+      return delete this.options[key], this;
+    let fieldValidator = this.schema.shape[key];
+    if (!fieldValidator)
+      return this.options[key] = value, this;
+    let parsedValue = fieldValidator.parse(value);
+    return this.options[key] = parsedValue, this;
+  }
+  name(value) {
+    return this.setOption("name", value);
+  }
+  description(value) {
+    return this.setOption("description", value);
+  }
+  required(value) {
+    return this.setOption("required", value);
+  }
+  async resolve(context, value) {
+    let { required, name } = this.options;
+    if (value === void 0) {
+      if (required)
+        throw new ArgumentError(name, "is required");
+      return null;
+    }
+    if (context.isChatInput())
+      return await this.resolveChatInput(context);
+    if (context.isMessage())
+      return await this.resolveMessage(context, value);
+    throw new Error("Invalid context type provided");
   }
-  parsedValues = [];
   /**
-   * Get the first value as the command trigger.
+   * Helper to normalize string inputs into an options object.
    */
-  get trigger() {
-    return this.options.values[0];
+  static getOptions(options) {
+    return typeof options == "string" ? { name: options } : options;
+  }
+}, StringParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), StringParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  resolveMessage(_context, value) {
+    let { minLength, maxLength, name } = this.options;
+    if (minLength && value.length < minLength)
+      throw new ArgumentError(name, `must be at least ${minLength} chars long`);
+    if (maxLength && value.length > maxLength)
+      throw new ArgumentError(name, `must be at most ${maxLength} chars long`);
+    return value;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
   }
   /**
-   * Get amount of specified argument values.
+   * Sets the minimum allowed length for this string.
+   * Pass `null` to remove this constraint.
    */
-  get specifiedAmount() {
-    return this.options.values.length - this.options.startAt;
+  min(length) {
+    return this.setOption("minLength", length);
   }
   /**
-   * Get parsed raw values from content.
+   * Sets the maximum allowed length for this string.
+   * Pass `null` to remove this constraint.
    */
-  get values() {
-    return [...this.options.values];
+  max(length) {
+    return this.setOption("maxLength", length);
   }
-  get client() {
-    return this.options.message.client;
-  }
-  static create(message) {
-    const client = message.client;
-    const { enableMentionPrefix } = client.options;
-    const prefixes = [
-      // Custom prefixes specified in options
-      ...client.options.prefixes ?? [],
-      // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [client.user.toString()] : []
-    ];
-    const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
-    if (!prefix) {
-      return;
-    }
-    const values = message.content.slice(prefix.length).trim().split(/\s+/);
-    return new _ArgumentResolver({
-      message,
-      startAt: 1,
-      // Skip the command trigger
-      values,
-      args: [],
-      prefix
-    });
+}, NumberParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), NumberParamSchema);
   }
-  async resolve(args) {
-    const child = new _ArgumentResolver({
-      prefix: this.options.prefix,
-      message: this.options.message,
-      values: this.options.values,
-      args,
-      startAt: this.options.startAt
-    });
-    child.parsedValues = [...this.parsedValues];
-    if (!child.options.args.length) {
-      return child;
-    }
-    if (this.specifiedAmount >= child.options.args.length) {
-      await child.absoluteParse();
-    } else {
-      await child.dynamicParse();
-    }
-    return child;
-  }
-  async absoluteParse() {
-    const { args, values, startAt } = this.options;
-    let valueIndex = startAt;
-    let argIndex = 0;
-    while (valueIndex < values.length && argIndex < args.length) {
-      const value = values[valueIndex];
-      const arg = args[argIndex];
-      if (arg.tuple) {
-        this.parsedValues.push(...await this.resolveTuple(arg, valueIndex, argIndex));
-        break;
-      }
-      const matchedValue = await this.matchValue(arg, value);
-      if (matchedValue === null) {
-        throw new CommandSyntaxError({
-          arg,
-          type: "INVALID_ARGUMENT" /* InvalidArgument */,
-          received: value
-        });
-      }
-      this.parsedValues.push(matchedValue);
-      valueIndex++;
-      argIndex++;
-    }
+  required(value) {
+    return super.required(value);
   }
-  async dynamicParse() {
-    const { args, values } = this.options;
-    let argIndex = 0;
-    let valueIndex = this.options.startAt + 1;
-    while (valueIndex < values.length && argIndex < args.length) {
-      const value = values[valueIndex];
-      const arg = args[argIndex];
-      if (arg.tuple) {
-        this.parsedValues.push(...await this.resolveTuple(arg, valueIndex, argIndex));
-        break;
-      }
-      const matchedValue = await this.matchValue(arg, value);
-      if (matchedValue !== null) {
-        this.parsedValues.push(matchedValue);
-        valueIndex++;
-      } else if (arg.required) {
-        throw new CommandSyntaxError({
-          arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-          received: value
-        });
-      }
-      argIndex++;
-    }
-    while (argIndex < args.length) {
-      const arg = args[argIndex];
-      if (arg.required) {
-        throw new CommandSyntaxError({
-          arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-          received: "nothing"
-        });
-      }
-      argIndex++;
-    }
+  resolveMessage(_context, value) {
+    let { minValue, maxValue, name } = this.options, num = Number(value);
+    if (isNaN(num))
+      throw new ArgumentError(name, "must be a number");
+    if (minValue !== void 0 && num < minValue)
+      throw new ArgumentError(name, `must be greater than ${minValue}`);
+    if (maxValue !== void 0 && num > maxValue)
+      throw new ArgumentError(name, `must be less than ${minValue}`);
+    return num;
   }
-  async resolveTuple(arg, startIndex, argIndex) {
-    const { args } = this.options;
-    if (argIndex !== args.length - 1) {
-      throw new SyntaxError("Tuple argument must be the last argument");
-    }
-    const values = [];
-    for (const rest of this.values.slice(startIndex)) {
-      const matchedValue = await this.matchValue(arg, rest);
-      if (matchedValue === null) {
-        throw new CommandSyntaxError({
-          arg,
-          type: "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */,
-          received: rest
-        });
-      }
-      values.push(matchedValue);
-    }
-    if (values.length === 0 && arg.required) {
-      throw new CommandSyntaxError({
-        arg,
-        type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-        received: "nothing"
-      });
-    }
-    return values;
-  }
-  async matchValue(arg, value) {
-    switch (arg.type) {
-      case "user" /* User */:
-        return await this.matchUserValue(arg, value);
-      case "integer" /* Integer */:
-        return this.matchIntegerValue(arg, value);
-      case "number" /* Number */:
-        return this.matchNumberValue(arg, value);
-      case "string" /* String */:
-        return this.matchStringValue(arg, value);
-      default:
-        return null;
-    }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
   }
-  async matchUserValue(arg, value) {
-    const userId = extractId(value);
-    if (!userId) {
-      return null;
-    }
-    const user2 = await this.client.users.fetch(userId).catch(() => null);
-    if (!user2) {
-      return null;
-    }
-    return user2;
+  /**
+   * Sets the minimum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  min(value) {
+    return this.setOption("minValue", value);
   }
-  matchIntegerValue(arg, value) {
-    const intVal = parseInt(value, 10);
-    if (isNaN(intVal)) {
-      return null;
-    }
-    if (arg.minValue !== void 0 && intVal < arg.minValue) {
-      return null;
-    }
-    if (arg.maxValue !== void 0 && intVal > arg.maxValue) {
-      return null;
-    }
-    return intVal;
+  /**
+   * Sets the maximum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  max(value) {
+    return this.setOption("maxValue", value);
   }
-  matchNumberValue(arg, value) {
-    const numVal = parseFloat(value);
-    if (isNaN(numVal)) {
-      return null;
-    }
-    if (arg.minValue !== void 0 && numVal < arg.minValue) {
-      return null;
-    }
-    if (arg.maxValue !== void 0 && numVal > arg.maxValue) {
-      return null;
-    }
-    return numVal;
+}, UserParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), UserParamSchema);
   }
-  matchStringValue(arg, value) {
-    if (arg.minLength !== void 0 && value.length < arg.minLength) {
-      return null;
-    }
-    if (arg.maxLength !== void 0 && value.length > arg.maxLength) {
+  required(value) {
+    return super.required(value);
+  }
+  async resolveMessage(context, value) {
+    let id = extractSnowflakeId(value);
+    if (!id)
       return null;
-    }
-    return value;
+    let { users } = context.client;
+    return await users.fetch(id).catch(() => null);
   }
-  static resolveChatInput(interaction, arg) {
-    switch (arg.type) {
-      case "string" /* String */:
-        return interaction.options.getString(arg.name, arg.required);
-      case "integer" /* Integer */:
-        return interaction.options.getInteger(arg.name, arg.required);
-      case "number" /* Number */:
-        return interaction.options.getNumber(arg.name, arg.required);
-      case "user" /* User */:
-        return interaction.options.getUser(arg.name, arg.required);
-      case "member" /* Member */:
-        return interaction.options.getMember(arg.name);
-      default:
-        return null;
-    }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getUser(name, required);
   }
 };
-
-// src/libs/StateBox.ts
-import { AsyncLocalStorage } from "async_hooks";
-var StateBox = class _StateBox {
-  static STATES_KEY = Symbol("states");
-  static storage = new AsyncLocalStorage();
-  static getState() {
-    const state = this.storage.getStore();
-    if (!state) {
-      throw new Error("No active context, did you forget to wrap it with StateBox.wrap()?");
-    }
-    return state;
+function validateParamsOrder(params) {
+  let seenOptional = false;
+  for (let param of params)
+    if (param.options.required) {
+      if (seenOptional)
+        return false;
+    } else
+      seenOptional = true;
+  return true;
+}
+var CommandOptionsSchema = z.object({
+  name: z.string().readonly(),
+  description: z.string().min(1).max(100).optional().readonly(),
+  nsfw: z.boolean().default(false).readonly(),
+  params: z.array(z.instanceof(BaseParam)).default([]).readonly(),
+  quotes: z.boolean().default(true).readonly()
+}).transform((data) => ({
+  ...data,
+  description: data.description ?? `Command ${data.name}`
+})).refine(({ params }) => validateParamsOrder(params), {
+  path: ["params"],
+  error: "Required params must be placed before optional params"
+}), Command = class extends LifecycleManager {
+  constructor(options) {
+    let _options = CommandOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
+    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
+      await this.handleSyntaxError(ctx, error, args);
+    });
   }
-  static run(fn, store = {}) {
-    return this.storage.run(store, fn);
+  async handleSyntaxError(context, error, _args) {
+    error instanceof BakitError && await context.send(error.message);
   }
-  static wrap(fn) {
-    const currentStore = this.storage.getStore();
-    if (!currentStore) {
-      throw new Error("No active context, cannot wrap function outside a StateBox.run()");
-    }
-    return () => this.run(fn, currentStore);
-  }
-  static use(defaultValue) {
-    return (target, key) => {
-      Object.defineProperty(target, key, {
-        get() {
-          const states = _StateBox.getState();
-          if (!(key in states)) {
-            states[key] = defaultValue;
-          }
-          return states[key];
-        },
-        set(value) {
-          const states = _StateBox.getState();
-          states[key] = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-    };
+  toSlashCommandJSON() {
+    let { name, description, nsfw, params } = this.options, builder = new SlashCommandBuilder().setName(name).setDescription(description).setNSFW(nsfw);
+    return this.initSlashCommandOptions(builder, params), builder.toJSON();
   }
-};
-
-// src/listener/ListenerEntry.ts
-var ListenerEntry = class extends BaseEntry {
-  constructor(options) {
-    super();
-    this.options = options;
+  initSlashCommandOptions(builder, params) {
+    for (let param of params)
+      this.initSlashCommandOption(builder, param);
   }
-};
-
-// src/listener/Listener.ts
-var ListenerAPI;
-((ListenerAPI2) => {
-  ListenerAPI2.ENTRY_KEY = Symbol("entry");
-  function use(entry) {
-    return (target) => {
-      Reflect.defineMetadata(ListenerAPI2.ENTRY_KEY, entry, target);
+  initSlashCommandOption(builder, param) {
+    let initOption = (builder2) => {
+      let { name, description, required } = param.options;
+      return builder2.setName(name).setDescription(description).setRequired(required);
     };
+    if (param instanceof StringParam) {
+      let { maxLength, minLength } = param.options, option = initOption(new SlashCommandStringOption());
+      maxLength && option.setMaxLength(maxLength), minLength && option.setMinLength(minLength), builder.addStringOption(option);
+      return;
+    }
+    if (param instanceof NumberParam) {
+      let { maxValue, minValue } = param.options, option = initOption(new SlashCommandNumberOption());
+      maxValue && option.setMaxValue(maxValue), minValue && option.setMinValue(minValue), builder.addNumberOption(option);
+      return;
+    }
+    if (param instanceof UserParam) {
+      let option = initOption(new SlashCommandUserOption());
+      builder.addUserOption(option);
+      return;
+    }
   }
-  ListenerAPI2.use = use;
-  function getEntry(target) {
-    return Reflect.getMetadata(ListenerAPI2.ENTRY_KEY, target);
-  }
-  ListenerAPI2.getEntry = getEntry;
-})(ListenerAPI || (ListenerAPI = {}));
-function ListenerFactory(options) {
-  const fullOptions = typeof options !== "object" ? { name: options, once: false } : { once: false, ...options };
-  return new ListenerEntry(fullOptions);
+};
+function defineCommand(options) {
+  return new Command(options);
 }
-var Listener = Object.assign(ListenerFactory, ListenerAPI);
 
-// src/listener/ListenerRegistry.ts
-import glob2 from "tiny-glob";
-import { pathToFileURL as pathToFileURL2 } from "url";
-var ListenerRegistry = class {
-  static client;
-  static constructors = /* @__PURE__ */ new Set();
-  static instances = /* @__PURE__ */ new WeakMap();
-  static executors = /* @__PURE__ */ new WeakMap();
-  /**
-   * Add and register a listener to the registry.
-   * If `options.emitter` is not provided, the registry will use the base `client` by default.
-   * @param constructor The listener class you want to add.
-   */
-  static add(constructor) {
-    const entry = Listener.getEntry(constructor);
-    if (!entry) {
-      throw new Error(`No entry found for "${constructor.name}"`);
-    }
-    const { options } = entry;
-    if (!options.emitter) {
-      if (!this.client) {
-        throw new Error("Client is not ready.");
+// src/base/command/CommandManager.ts
+var CommandManager = class extends BaseClientManager {
+  commands = new Collection();
+  async loadModules() {
+    let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "commands", "**/*.{ts,js}"), loads = (await glob(pattern, {
+      cwd: process.cwd(),
+      absolute: true
+    })).map(async (file) => {
+      try {
+        let command = await $jiti.import(file, { default: !0 });
+        if (!command) {
+          console.warn(`[Loader] File has no default export: ${file}`);
+          return;
+        }
+        if (!(command instanceof Command)) {
+          console.warn(`[Loader] Default export is not a Command: ${file}`);
+          return;
+        }
+        return this.add(command), command;
+      } catch (error) {
+        console.error(`An error occurred while trying to add command for '${file}':`, error);
       }
-      options.emitter = this.client;
-    }
-    const instance = new constructor();
-    const executor = this.createExecutor(constructor, instance);
-    this.constructors.add(constructor);
-    this.instances.set(constructor, instance);
-    this.executors.set(instance, executor);
-    options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
-      void executor(...args);
-    });
+    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
+    return console.log(`Loaded ${loaded.length} command(s).`), loaded;
   }
-  /**
-   * Remove and unregister a listener from the registry.
-   * @param constructor The listener class you want to remove.
-   * @returns `boolean`, returns `true` if the listener is removed successfully.
-   */
-  static remove(constructor) {
-    const entry = Listener.getEntry(constructor);
-    if (!entry) {
-      return false;
-    }
-    this.constructors.delete(constructor);
-    const instance = this.instances.get(constructor);
-    if (!instance) {
-      return false;
-    }
-    this.instances.delete(constructor);
-    const executor = this.executors.get(instance);
-    if (!executor) {
-      return false;
+  add(command) {
+    if (!(command instanceof Command))
+      throw new Error("Invalid command provided");
+    let { name } = command.options;
+    if (this.commands.has(name)) {
+      console.warn(`[Loader] Duplicate command registered: '${name}'`);
+      return;
     }
-    const { name, emitter } = entry.options;
-    emitter?.removeListener(name, executor);
-    this.executors.delete(instance);
-    return true;
+    this.commands.set(name, command);
   }
-  /**
-   * Remove and unregister all listeners from the registry.
-   * @returns Amount of removed listeners.
-   */
-  static removeAll() {
-    let removedAmount = 0;
-    for (const constructor of this.constructors) {
-      if (this.remove(constructor)) {
-        removedAmount++;
-      }
-    }
-    return removedAmount;
+  remove(target) {
+    let name = typeof target == "string" ? target : target.options.name, existing = this.commands.get(name);
+    if (existing)
+      return this.commands.delete(name), existing;
   }
-  /**
-   * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
-   * @param newClient base client to set for the registry.
-   */
-  static setClient(newClient) {
-    this.client = newClient;
+  get(name) {
+    return this.commands.get(name);
   }
-  static createExecutor(constructor, instance) {
-    const entry = Listener.getEntry(constructor);
-    if (!entry) {
-      throw new Error("Missing listener entry");
-    }
-    const { hooks } = entry;
-    return async function(...args) {
-      const mainHook = hooks["MAIN" /* Main */];
-      const preHook = hooks["PRE" /* Pre */];
-      const postHook = hooks["POST" /* Post */];
-      const errorHook = hooks["ERROR" /* Error */];
-      if (!mainHook) {
-        return;
-      }
+};
+var ListenerOptionsSchema = z4.object({
+  name: z4.enum(Events),
+  once: z4.boolean().default(false)
+}), Listener = class extends LifecycleManager {
+  options;
+  constructor(options) {
+    let _options = ListenerOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
+    super(`listener:${_options.name}`), this.options = _options;
+  }
+};
+function defineListener(options) {
+  return new Listener(options);
+}
+var ListenerManager = class extends BaseClientManager {
+  listeners = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  executors = /* @__PURE__ */ new WeakMap();
+  async loadModules() {
+    let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "listeners", "**/*.{ts,js}"), loads = (await glob(pattern, {
+      cwd: process.cwd(),
+      absolute: true
+    })).map(async (file) => {
       try {
-        if (preHook) {
-          await preHook.method.call(instance, ...args);
+        let listener = await $jiti.import(file, { default: !0 });
+        if (!listener) {
+          console.warn(`[Loader] File has no default export: ${file}`);
+          return;
         }
-        await mainHook.method.call(instance, ...args);
-        if (postHook) {
-          await postHook.method.call(instance, ...args);
+        if (!(listener instanceof Listener)) {
+          console.warn(`[Loader] Default export is not a Listener: ${file}`);
+          return;
         }
+        return this.add(listener), listener;
       } catch (error) {
-        if (errorHook) {
-          await errorHook.method.call(
-            instance,
-            error,
-            ...args
-          );
-        } else {
-          throw error;
-        }
+        console.error(`An error occurred while trying to add listener for '${file}':`, error);
       }
-    };
+    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
+    return console.log(`Loaded ${loaded.length} listener(s).`), loaded;
   }
-  /**
-   * Load and add all listeners which matched provided glob pattern to the registry.
-   * @param pattern glob pattern to load.
-   * @param parallel load all matched results in parallel, enabled by default.
-   * @returns All loaded listener constructors.
-   */
-  static async load(pattern, parallel = true) {
-    const files = await glob2(pattern);
-    const loaders = files.map(async (file) => {
-      const fileURL = pathToFileURL2(file).toString();
-      const { default: constructor } = await import(fileURL);
-      this.add(constructor);
-      return constructor;
-    });
-    if (parallel) {
-      return Promise.all(loaders);
-    }
-    const result = [];
-    for (const loader of loaders) {
-      result.push(await loader);
+  add(listener) {
+    if (!(listener instanceof Listener))
+      throw new Error("Invalid listener provided");
+    let execute = (...args) => {
+      listener.execute(new Context(), ...args);
+    };
+    this.listeners.push(listener), this.executors.set(listener, execute);
+    let { once, name } = listener.options;
+    this.client[once ? "once" : "on"](name, execute);
+  }
+  remove(target) {
+    let isMatched = (listener) => typeof target == "string" ? listener.options.name === target : listener === target, removed = [];
+    return this.listeners = this.listeners.filter((listener) => {
+      if (!isMatched(listener))
+        return true;
+      removed.push(listener);
+      let execute = this.executors.get(listener);
+      return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
+    }), removed;
+  }
+  getBaseIntents() {
+    return new IntentsBitField([GatewayIntentBits.Guilds]);
+  }
+  getNeededIntents() {
+    let result = this.getBaseIntents();
+    for (let listener of this.listeners) {
+      let eventName = listener.options.name, requiredIntents = EVENT_INTENT_MAPPING[eventName];
+      requiredIntents && result.add(requiredIntents);
     }
     return result;
   }
 };
 
-// src/BakitClient.ts
-var BakitClient = class _BakitClient extends Client {
-  constructor(options) {
-    if (options.getSyntaxErrorMessage === void 0) {
-      options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
-    }
+// src/base/BakitClient.ts
+var BakitClient2 = class extends Client {
+  constructor(options, instance) {
     super(options);
-    ListenerRegistry["setClient"](this);
-    this.once(
-      Events.ClientReady,
-      (client) => void this.registerApplicationCommands(client)
-    );
-    this.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
-    this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
-  }
-  static getSyntaxErrorMessage = (command, error, context, args, prefix) => {
-    const requiredSyntax = args.map((x) => Arg.format(x)).join(" ");
-    const root = Command.getRoot(command.constructor);
-    if (!root) {
-      return;
-    }
-    const content = [
-      codeBlock(error.message),
-      "Required Syntax:",
-      codeBlock(`${prefix}${root.options.name} ${requiredSyntax}`)
-    ].join("\n");
-    return {
-      content
+    this.instance = instance;
+    this.managers = {
+      commands: new CommandManager(this),
+      listeners: new ListenerManager(this)
     };
-  };
-  async registerApplicationCommands(client) {
-    const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
-    await client.application.commands.set(commands);
   }
-  async handleMessage(message) {
-    if (message.author.bot) {
-      return;
-    }
-    const context = new MessageContext(message);
-    const resolver = ArgumentResolver.create(message);
-    if (!resolver) {
-      return;
-    }
-    const { trigger } = resolver;
-    const command = CommandRegistry.instances.get(trigger);
-    if (!command) {
-      return;
-    }
-    await StateBox.run(() => this.handleMessageHooks(context, command, resolver));
+  managers;
+  /**
+   * Check if the client is connected to gateway successfully and finished initialization.
+   */
+  isReady() {
+    return super.isReady();
   }
-  async handleInteraction(interaction) {
-    if (!interaction.isChatInputCommand()) {
-      return;
-    }
-    const { commandName } = interaction;
-    const command = CommandRegistry.instances.get(commandName);
-    if (!command) {
-      return;
-    }
-    const context = new ChatInputContext(interaction);
-    await StateBox.run(() => this.handleChatInputHooks(context, command));
-  }
-  async handleChatInputHooks(context, instance) {
-    const targetHooks = this.getChatInputTargetHooks(context.source, instance);
-    let inheritedArgs = [];
-    for (const hooks of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
-      if (!hooks) {
-        continue;
-      }
-      const newArgs = await this.runChatInputHooks(context, instance, hooks, inheritedArgs);
-      if (newArgs) {
-        inheritedArgs = newArgs;
-      }
-    }
+  on(event, listener) {
+    return super.on(event, listener);
   }
-  async handleMessageHooks(context, instance, resolver) {
-    if (!resolver) {
-      return;
-    }
-    const root = Command.getRoot(instance.constructor);
-    if (!root) {
-      return;
-    }
-    resolver = await this.runMessageHooks(context, instance, root.hooks, resolver);
-    if (!resolver) {
-      return;
-    }
-    await this.handleChildMessageHooks(context, root, instance, resolver);
+  once(event, listener) {
+    return super.once(event, listener);
   }
-  async handleChildMessageHooks(context, parent, instance, resolver, skip = 1) {
-    if (!resolver) {
-      return;
-    }
-    const usedValues = resolver.parsedValues.length;
-    const nextTrigger = resolver.values[usedValues + skip];
-    const child = parent.children.get(nextTrigger);
-    if (!child) {
-      return;
-    }
-    resolver = await this.runMessageHooks(context, instance, child.hooks, resolver);
-    if (child instanceof CommandGroupEntry) {
-      await this.handleChildMessageHooks(context, child, instance, resolver, skip + 1);
-    }
+  off(event, listener) {
+    return super.off(event, listener);
   }
-  async runMessageHooks(context, instance, hooks, resolver) {
-    const mainHook = hooks["MAIN" /* Main */];
-    if (!mainHook) {
-      return resolver;
-    }
-    const args = Arg.getMethodArguments(mainHook.method);
-    try {
-      resolver = await resolver.resolve(args);
-    } catch (error) {
-      if (error instanceof CommandSyntaxError) {
-        const errorContent = await this.options.getSyntaxErrorMessage?.(
-          instance,
-          error,
-          context,
-          args,
-          resolver.options.prefix
-        );
-        if (errorContent) {
-          await context.send(errorContent);
-        }
-        return null;
-      }
-      throw error;
-    }
-    await this.runHooks(context, instance, hooks, resolver.parsedValues);
-    return resolver;
+  removeAllListeners(event) {
+    return super.removeAllListeners(event);
   }
-  async runChatInputHooks(context, instance, hooks, inheritedArgs) {
-    const mainHook = hooks["MAIN" /* Main */];
-    if (!mainHook) {
-      return;
-    }
-    const newArgs = Arg.getMethodArguments(mainHook.method).map(
-      (arg) => ArgumentResolver.resolveChatInput(context.source, arg)
-    );
-    const argValues = [...inheritedArgs, ...newArgs];
-    await this.runHooks(context, instance, hooks, argValues);
-    return argValues;
-  }
-  async runHooks(context, instance, hooks, args) {
-    const mainHook = hooks["MAIN" /* Main */];
-    const preHook = hooks["PRE" /* Pre */];
-    const postHook = hooks["POST" /* Post */];
-    const errorHook = hooks["ERROR" /* Error */];
-    if (!mainHook) {
-      return;
-    }
-    const execute = async (hook, error) => {
-      if (!hook) {
-        return;
-      }
-      if (hook.state === "ERROR" /* Error */) {
-        await hook.method.call(instance, error, context, ...args);
-      } else {
-        await hook.method.call(instance, context, ...args);
-      }
-    };
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  /**
+   * Override BakitClient output when using logger for security concern.
+   * @returns `BakitClient {}`
+   */
+  [inspect.custom]() {
+    return `${this.constructor.name} {}`;
+  }
+};
+
+// src/base/command/param/Params.ts
+function createFactory(ctor) {
+  return (...args) => new ctor(...args);
+}
+var Params = {
+  string: createFactory(StringParam),
+  number: createFactory(NumberParam)
+};
+
+// src/defaults/command.ts
+var messageCommandHandler = defineListener(Events.MessageCreate), chatInputCommandHandler = defineListener(Events.InteractionCreate), registerCommandsHandler = defineListener({
+  name: Events.ClientReady,
+  once: true
+});
+registerCommandsHandler.main(async (_, client) => {
+  let { managers, instance } = client, { commands } = managers, { cache } = instance, payload = commands.commands.map((cmd) => cmd.toSlashCommandJSON()).sort((a, b) => a.name.localeCompare(b.name)), currentHash = cache.getHash(payload), CACHE_KEY = "commands/meta.json", cachedMeta = await cache.read(CACHE_KEY);
+  if (cachedMeta && cachedMeta.hash === currentHash) {
+    let { timestamp, count } = cachedMeta, time = new Date(timestamp).toLocaleString();
+    console.log(`${count} command(s) are up to date (Last sync: ${time}). Skipping registration.`);
+    return;
+  }
+  try {
+    let result = await client.application.commands.set(payload);
+    cache.write(CACHE_KEY, {
+      hash: currentHash,
+      timestamp: Date.now(),
+      count: result.size
+    }), cache.write("commands/debug_dump.json", payload), console.log(`Registered ${result.size} application command(s).`);
+  } catch (error) {
+    console.error("Failed to register commands:", error);
+  }
+});
+messageCommandHandler.main(async (_, message) => {
+  let config = getConfig();
+  if (message.author.bot)
+    return;
+  let { content } = message, client = message.client, lowerContent = content.toLowerCase(), prefix = config.prefixes.find((p) => lowerContent.startsWith(p));
+  if (!prefix)
+    return;
+  let [name, ...args] = content.slice(prefix.length).trim().split(/\s+/g);
+  if (!name)
+    return;
+  let command = client.managers.commands.get(name);
+  if (!command)
+    return;
+  let context = new MessageContext(message), { params, quotes } = command.options, rawArgs = quotes ? tokenize(args.join(" ")) : args, resolvedArgs = [];
+  for (let i = 0; i < params.length; i++) {
+    let param = params[i], arg = rawArgs[i];
+    if (!param)
+      break;
+    let resolved = await param.resolve(context, arg);
+    resolvedArgs.push(resolved);
+  }
+  await command.execute(context, ...resolvedArgs);
+});
+chatInputCommandHandler.main(async (_, interaction) => {
+  if (!interaction.isChatInputCommand())
+    return;
+  let { commandName } = interaction, command = interaction.client.managers.commands.get(commandName);
+  if (!command)
+    return;
+  let context = new ChatInputContext(interaction), { params } = command.options, resolvedArgs = [];
+  for (let param of params) {
+    let resolved = await param.resolve(context);
+    resolvedArgs.push(resolved);
+  }
+  await command.execute(context, ...resolvedArgs);
+});
+var ProjectCacheManager = class {
+  rootDir;
+  constructor(root = process.cwd()) {
+    this.rootDir = join(root, ".bakit"), this.ensureRoot();
+  }
+  ensureRoot() {
+    existsSync(this.rootDir) || mkdirSync(this.rootDir, { recursive: true });
+  }
+  getHash(data) {
+    return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+  }
+  async write(path, data) {
+    let fullPath = join(this.rootDir, path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: true });
+    let content = typeof data == "string" ? data : JSON.stringify(data);
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async read(path) {
+    let fullPath = join(this.rootDir, path);
     try {
-      await execute(preHook);
-      await execute(mainHook);
-      await execute(postHook);
-    } catch (error) {
-      if (errorHook) {
-        await execute(errorHook, error);
-      } else {
-        throw error;
-      }
+      let content = await readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
     }
   }
-  getChatInputTargetHooks(interaction, instance) {
-    const subcommandName = interaction.options.getSubcommand(false);
-    const groupName = interaction.options.getSubcommandGroup(false);
-    const root = Command.getRoot(instance.constructor);
-    if (!root) {
-      throw new Error("No root found.");
-    }
-    let group;
-    if (groupName) {
-      const child = root.children.get(groupName);
-      if (child instanceof CommandGroupEntry) {
-        group = child;
-      }
-    }
-    let subcommand;
-    if (subcommandName) {
-      const parent = group || root;
-      const child = parent.children.get(subcommandName);
-      if (child instanceof SubcommandEntry) {
-        subcommand = child;
-      }
-    }
-    return {
-      root: root.hooks,
-      group: group?.hooks,
-      subcommand: subcommand?.hooks
-    };
+  async clear() {
+    await rm(this.rootDir, { recursive: true, force: true });
+  }
+  clearSync() {
+    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
   }
 };
-export {
-  Arg,
-  ArgumentType,
-  BakitClient,
-  BaseCommandEntry,
-  BaseCommandGroupEntry,
-  BaseContext,
-  ChatInputContext,
-  Command,
-  CommandAPI,
-  CommandFactory,
-  CommandGroupEntry,
-  CommandRegistry,
-  CommandSyntaxError,
-  CommandSyntaxErrorType,
-  Listener,
-  ListenerAPI,
-  ListenerEntry,
-  ListenerFactory,
-  ListenerRegistry,
-  MessageContext,
-  RootCommandEntry,
-  StateBox,
-  SubcommandEntry,
-  extractId
+
+// src/base/Instance.ts
+var Instance = class {
+  client;
+  cache;
+  constructor() {
+    this.cache = new ProjectCacheManager();
+  }
+  async start() {
+    await loadConfig();
+    let config = getConfig();
+    this.client = new BakitClient2(
+      {
+        intents: [],
+        ...config.clientOptions
+      },
+      this
+    ), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
+  }
+  loadModules() {
+    let { managers } = this.client, { commands, listeners } = managers;
+    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
+  }
+  initIntents() {
+    let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
+    config.intents === "auto" ? intents = listeners.getNeededIntents() : (intents = listeners.getBaseIntents(), typeof config.intents == "bigint" ? intents.bitfield = Number(config.intents) : intents.add(...config.intents)), options.intents = intents;
+  }
 };
+function useApp() {
+  return new Instance();
+}
+
+export { $jiti, ArgumentError, BakitClient2 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };