bakit 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/index.js

@@ -1,134 +1,334 @@
-import { GatewayIntentBits, Events, Client, Collection, ChatInputCommandInteraction, Message } from 'discord.js';
-import z3, { z } from 'zod';
-import { pathToFileURL } from 'url';
-import glob from 'tiny-glob';
+import { register } from 'module';
+import { MessageChannel } from 'worker_threads';
+import { GatewayIntentBits, Events, Client, Collection, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
 import { inspect } from 'util';
-import { posix } from 'path';
+import { posix, relative, sep, join, dirname } from 'path';
+import glob from 'tiny-glob';
+import z4 from 'zod';
+import { pathToFileURL } from 'url';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { mkdir, writeFile, readFile, rm } from 'fs/promises';
+import { createHash } from 'crypto';
 
-// src/config.ts
-var ProjectConfigSchema = z.object({
-  /**
-   * 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`
-   */
-  intents: z.union([z.literal("auto"), z.bigint(), z.array(z.enum(GatewayIntentBits))]).default("auto"),
-  /**
-   * 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}
-   */
-  clientOptions: z.custom().optional(),
-  /**
-   * The path to the main project source directory.
-   *
-   * @defaultvalue `src`
-   */
-  entryDir: z.string().default("src")
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/loader/register.ts
+var register_exports = {};
+__export(register_exports, {
+  unload: () => unload
 });
-function defineConfig(config) {
-  return config;
+function unload(module) {
+  port2.postMessage({ type: "unload", target: module });
 }
-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 configFileURL = pathToFileURL(configPath).toString(), { default: config } = await import(configFileURL);
-  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
-}
-function getConfig() {
-  if (!_config)
-    throw new Error("Project config is not loaded.");
-  return _config;
+var port1, port2, hookPath, init_register = __esm({
+  "src/loader/register.ts"() {
+    (({ port1, port2 } = new MessageChannel())), hookPath = new URL("./hooks.js", import.meta.url).href;
+    register(hookPath, import.meta.url, {
+      data: { port: port1 },
+      transferList: [port1]
+    });
+  }
+});
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  required: z4.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z4.number().min(1).optional(),
+  minLength: z4.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z4.number().optional(),
+  minValue: z4.number().optional()
+}), UserParamSchema = BaseParamSchema.extend({});
+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);
 }
 
-// src/base/lifecycle/Context.ts
-var Context = class {
-  canceled = false;
-  cancel() {
-    this.canceled = true;
+// src/lib/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/CommandContext.ts
-var BaseCommandContext = class extends Context {
-  constructor(source) {
-    super();
-    this.source = source;
+// src/lib/errors/ArgumentError.ts
+var ArgumentError = class extends BakitError {
+  constructor(target, reason) {
+    super(`Invalid argument for '${target}': ${reason}`);
+    this.target = target;
+    this.reason = reason;
   }
-  get client() {
-    return this.source.client;
+};
+
+// src/lib/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;
+    }
+    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;
   }
-  get channel() {
-    return this.source.channel;
+  return current.length > 0 && args.push(current), args;
+}
+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;
+}
+function getTopLevelDirectory(path, entryDir) {
+  return relative(entryDir, path).split(sep)[0] ?? null;
+}
+
+// src/core/structures/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;
   }
-  get channelId() {
-    return this.source.channelId;
+  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;
   }
-  get guild() {
-    return this.source.guild;
+  name(value) {
+    return this.setOption("name", value);
   }
-  get guildId() {
-    return this.source.guildId;
+  description(value) {
+    return this.setOption("description", value);
   }
-  get member() {
-    return this.source.member;
+  required(value) {
+    return this.setOption("required", value);
   }
-  inGuild() {
-    return !!this.guildId;
+  async resolve(context, value) {
+    if (context.isChatInput())
+      return await this.resolveChatInput(context);
+    if (context.isMessage()) {
+      let { required, name } = this.options;
+      if (value === void 0) {
+        if (required)
+          throw new ArgumentError(name, "is required");
+        return null;
+      }
+      return await this.resolveMessage(context, value);
+    }
+    throw new Error("Invalid context type provided");
   }
-  inCachedGuild() {
-    if (this.isChatInput())
-      return this.source.inCachedGuild();
-    if (this.isMessage())
-      return this.source.inGuild();
-    throw new Error("Invalid source");
+  /**
+   * Helper to normalize string inputs into an options object.
+   */
+  static getOptions(options) {
+    return typeof options == "string" ? { name: options } : options;
   }
-  get user() {
-    if (this.isChatInput())
-      return this.source.user;
-    if (this.isMessage())
-      return this.source.author;
-    throw new Error("Invalid source");
+}, StringParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), StringParamSchema);
   }
-  isChatInput() {
-    return this.source instanceof ChatInputCommandInteraction;
+  required(value) {
+    return super.required(value);
   }
-  isMessage() {
-    return this.source instanceof Message;
+  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;
   }
-}, ChatInputContext = class extends BaseCommandContext {
-  async send(options) {
-    typeof options == "string" && (options = { content: options });
-    let sendOptions = {
-      ...options,
-      withResponse: true
-    };
-    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
   }
-}, MessageContext = class extends BaseCommandContext {
-  async send(options) {
-    let { channel } = this;
-    if (!channel?.isSendable())
-      throw new Error("Invalid channel or channel is not sendable");
-    return await channel.send(options);
+  /**
+   * Sets the minimum allowed length for this string.
+   * Pass `null` to remove this constraint.
+   */
+  min(length) {
+    return this.setOption("minLength", length);
+  }
+  /**
+   * Sets the maximum allowed length for this string.
+   * Pass `null` to remove this constraint.
+   */
+  max(length) {
+    return this.setOption("maxLength", length);
+  }
+}, NumberParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), NumberParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  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;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
+  }
+  /**
+   * Sets the minimum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  min(value) {
+    return this.setOption("minValue", value);
+  }
+  /**
+   * Sets the maximum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  max(value) {
+    return this.setOption("maxValue", value);
+  }
+}, UserParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), UserParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  async resolveMessage(context, value) {
+    let id = extractSnowflakeId(value);
+    if (!id)
+      return null;
+    let { users } = context.client;
+    return await users.fetch(id).catch(() => null);
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getUser(name, required);
   }
 };
-var LifecycleManager = class {
+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;
   }
@@ -199,124 +399,123 @@ var LifecycleManager = class {
   }
 };
 
-// src/command/param/Param.ts
-var BaseParam = class {
-  options;
-  constructor(options) {
-    this.options = { ...options, required: options.required ?? true };
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  setOption(key, value) {
-    return value === null ? delete this.options[key] : this.options[key] = value, this;
-  }
-  name(value) {
-    return this.setOption("name", value);
-  }
-  description(value) {
-    return this.setOption("description", value);
-  }
-  required(value) {
-    return this.setOption("required", value);
-  }
-  /**
-   * Helper to normalize string inputs into an options object.
-   */
-  static getOptions(options) {
-    return typeof options == "string" ? { name: options } : options;
-  }
-}, StringParam = class extends BaseParam {
-  constructor(options) {
-    super(BaseParam.getOptions(options));
-  }
-  required(value) {
-    return super.required(value);
-  }
-  /**
-   * Sets the minimum allowed length for this string.
-   * Pass `null` to remove this constraint.
-   */
-  min(length) {
-    return this.setOption("minLength", length);
-  }
-  /**
-   * Sets the maximum allowed length for this string.
-   * Pass `null` to remove this constraint.
-   */
-  max(length) {
-    return this.setOption("maxLength", length);
-  }
-}, NumberParam = class extends BaseParam {
-  constructor(options) {
-    super(BaseParam.getOptions(options));
-  }
-  required(value) {
-    return super.required(value);
-  }
-  /**
-   * Sets the minimum allowed value for this number.
-   * Pass `null` to remove this constraint.
-   */
-  min(value) {
-    return this.setOption("minValue", value);
-  }
-  /**
-   * Sets the maximum allowed value for this number.
-   * Pass `null` to remove this constraint.
-   */
-  max(value) {
-    return this.setOption("maxValue", value);
-  }
-};
-
-// src/command/Command.ts
-var CommandOptionsSchema = z.object({
-  name: z.string(),
-  description: z.string().min(1).max(100).optional(),
-  params: z.array(z.instanceof(BaseParam)).default([])
+// src/core/structures/Command.ts
+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 = z4.object({
+  name: z4.string().readonly(),
+  description: z4.string().min(1).max(100).optional().readonly(),
+  nsfw: z4.boolean().default(false).readonly(),
+  params: z4.array(z4.instanceof(BaseParam)).default([]).readonly(),
+  quotes: z4.boolean().default(true).readonly()
 }).transform((data) => ({
   ...data,
   description: data.description ?? `Command ${data.name}`
-})), Command = class extends LifecycleManager {
+})).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;
+    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
+      await this.handleSyntaxError(ctx, error, args);
+    });
+  }
+  async handleSyntaxError(context, error, _args) {
+    error instanceof BakitError && await context.send(error.message);
+  }
+  toSlashCommandJSON() {
+    let { name, description, nsfw, params } = this.options, builder = new SlashCommandBuilder().setName(name).setDescription(description).setNSFW(nsfw);
+    return this.initSlashCommandOptions(builder, params), builder.toJSON();
+  }
+  initSlashCommandOptions(builder, params) {
+    for (let param of params)
+      this.initSlashCommandOption(builder, param);
+  }
+  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;
+    }
   }
 };
 function defineCommand(options) {
   return new Command(options);
 }
 
-// src/base/BaseClientManager.ts
+// src/core/managers/BaseClientManager.ts
 var BaseClientManager = class {
   constructor(client) {
     this.client = client;
   }
 };
-
-// src/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()
-    })).map(async (file) => {
-      try {
-        let { default: command } = await import(pathToFileURL(file).toString());
-        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);
-      }
-    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
-    return console.log(`Loaded ${loaded.length} command(s).`), loaded;
+  entries = new Collection();
+  async loadModules(entryDir) {
+    let pattern = posix.join(posix.resolve(entryDir), "commands", "**/*.{ts,js}"), files = await glob(pattern, { cwd: process.cwd(), absolute: true }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((c) => !!c);
+    return console.log(`[Loader] Loaded ${filtered.length}/${files.length} command(s)`), filtered;
   }
+  /**
+   * Load the file and add the command to the registry.
+   * @param path The path to the command file.
+   * @returns The command object if added successfully.
+   */
+  async load(path) {
+    let command = (await import(pathToFileURL(path).href)).default;
+    if (!command) {
+      console.warn(`[Loader] File has no default export: ${path}`);
+      return;
+    }
+    if (!(command instanceof Command)) {
+      console.warn(`[Loader] Default export is not a Command: ${path}`);
+      return;
+    }
+    return this.add(command), this.entries.set(path, command), command;
+  }
+  /**
+   * Unload the file and remove the command from the registry.
+   * @param path The path to the command file.
+   * @returns The command object if unloaded successfully.
+   */
+  async unload(path) {
+    let command = this.entries.get(path);
+    if (this.entries.delete(path), (await Promise.resolve().then(() => (init_register(), register_exports))).unload(path), !!command)
+      return this.remove(command);
+  }
+  async reload(path) {
+    await this.unload(path);
+    let command = await this.load(path);
+    if (command)
+      return console.log(`[Loader] Reloaded command '${command.options.name}' at '${path}'`), command;
+  }
+  /**
+   * Add a command to the registry.
+   * @param command Command to add.
+   */
   add(command) {
     if (!(command instanceof Command))
       throw new Error("Invalid command provided");
@@ -327,65 +526,106 @@ var CommandManager = class extends BaseClientManager {
     }
     this.commands.set(name, command);
   }
+  /**
+   * Remove a command from the registry.
+   * @param target Command name or object to remove.
+   * @returns The command object if removed successfully.
+   */
   remove(target) {
+    if (typeof target != "string" && !(target instanceof Command))
+      return;
     let name = typeof target == "string" ? target : target.options.name, existing = this.commands.get(name);
     if (existing)
       return this.commands.delete(name), existing;
   }
+  /**
+   * Get a command using its name.
+   * @param name The command to get.
+   * @returns The command object.
+   */
   get(name) {
     return this.commands.get(name);
   }
 };
-var ListenerOptionsSchema = z3.object({
-  name: z3.enum(Events),
-  once: z3.boolean().default(false)
+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;
+    super(`listener:${_options.name}`), this.options = _options;
   }
 };
 function defineListener(options) {
   return new Listener(options);
 }
 
-// src/listener/ListenerManager.ts
+// src/core/context/Context.ts
+var Context = class {
+  canceled = false;
+  cancel() {
+    this.canceled = true;
+  }
+};
 var ListenerManager = class extends BaseClientManager {
   listeners = [];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  entries = new Collection();
   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()
-    })).map(async (file) => {
-      try {
-        let { default: listener } = await import(pathToFileURL(file).toString());
-        if (!listener) {
-          console.warn(`[Loader] File has no default export: ${file}`);
-          return;
-        }
-        if (!(listener instanceof Listener)) {
-          console.warn(`[Loader] Default export is not a Listener: ${file}`);
-          return;
-        }
-        return this.add(listener), listener;
-      } catch (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;
+  async loadModules(entryDir) {
+    let pattern = posix.join(posix.resolve(entryDir), "listeners", "**/*.{ts,js}"), files = await glob(pattern, { cwd: process.cwd(), absolute: true }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((l) => !!l);
+    return console.log(`[Loader] Loaded ${filtered.length}/${files.length} listener(s)`), filtered;
   }
+  /**
+   * Load the file and add the listener to the registry.
+   * @param path The path to the listener file.
+   * @returns The listener object if added successfully.
+   */
+  async load(path) {
+    let listener = (await import(pathToFileURL(path).href)).default;
+    if (!listener) {
+      console.warn(`[Loader] File has no default export: ${path}`);
+      return;
+    }
+    if (!(listener instanceof Listener)) {
+      console.warn(`[Loader] Default export is not a Listener: ${path}`);
+      return;
+    }
+    return this.add(listener), this.entries.set(path, listener), listener;
+  }
+  /**
+   * Unload the file and remove the listener from the registry.
+   * @param path The path to the listener file.
+   * @returns The listener object if unloaded successfully.
+   */
+  async unload(path) {
+    let listener = this.entries.get(path);
+    if (this.entries.delete(path), (await Promise.resolve().then(() => (init_register(), register_exports))).unload(path), !!listener)
+      return this.remove(listener)?.[0];
+  }
+  async reload(path) {
+    await this.unload(path);
+    let listener = await this.load(path);
+    if (listener)
+      return console.log(`[Loader] Reloaded listener '${listener.options.name}' at '${path}'`), listener;
+  }
+  /**
+   * Add a listener to the registry and create a listener for client.
+   * @param listener Listener to add.
+   */
   add(listener) {
     if (!(listener instanceof Listener))
       throw new Error("Invalid listener provided");
-    let execute = (...args) => {
+    let { once, name } = listener.options, 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);
+    this.listeners.push(listener), this.executors.set(listener, execute), this.client[once ? "once" : "on"](name, execute);
   }
+  /**
+   * Remove a listener from the registry and client.
+   * @param target Listener name or object to remove.
+   * @returns The list of listener objects if removed successfully.
+   */
   remove(target) {
     let isMatched = (listener) => typeof target == "string" ? listener.options.name === target : listener === target, removed = [];
     return this.listeners = this.listeners.filter((listener) => {
@@ -396,21 +636,38 @@ var ListenerManager = class extends BaseClientManager {
       return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
     }), removed;
   }
+  /**
+   * Get a list of required intents for Bakit to run correctly.
+   * @returns Used intents.
+   */
+  getBaseIntents() {
+    return new IntentsBitField([GatewayIntentBits.Guilds]);
+  }
+  /**
+   * Get a list of needed intents based on registered listeners to receive needed events.
+   * @returns Used intents.
+   */
+  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 BakitClient3 = class extends Client {
-  managers;
-  constructor(options) {
-    super(options), this.managers = {
+// src/core/client/BakitClient.ts
+var BakitClient = class extends Client {
+  constructor(options, instance) {
+    super(options);
+    this.instance = instance;
+    this.managers = {
       commands: new CommandManager(this),
       listeners: new ListenerManager(this)
     };
   }
-  async start(token) {
-    let { commands, listeners } = this.managers;
-    return await Promise.all([commands.loadModules(), listeners.loadModules()]), await this.login(token);
-  }
+  managers;
   /**
    * Check if the client is connected to gateway successfully and finished initialization.
    */
@@ -443,25 +700,263 @@ var BakitClient3 = class extends Client {
     return `${this.constructor.name} {}`;
   }
 };
-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()
+var BaseCommandContext = class extends Context {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  get client() {
+    return this.source.client;
+  }
+  get channel() {
+    return this.source.channel;
+  }
+  get channelId() {
+    return this.source.channelId;
+  }
+  get guild() {
+    return this.source.guild;
+  }
+  get guildId() {
+    return this.source.guildId;
+  }
+  get member() {
+    return this.source.member;
+  }
+  inGuild() {
+    return !!this.guildId;
+  }
+  inCachedGuild() {
+    if (this.isChatInput())
+      return this.source.inCachedGuild();
+    if (this.isMessage())
+      return this.source.inGuild();
+    throw new Error("Invalid source");
+  }
+  get user() {
+    if (this.isChatInput())
+      return this.source.user;
+    if (this.isMessage())
+      return this.source.author;
+    throw new Error("Invalid source");
+  }
+  isChatInput() {
+    return this.source instanceof ChatInputCommandInteraction;
+  }
+  isMessage() {
+    return this.source instanceof Message;
+  }
+}, ChatInputContext = class extends BaseCommandContext {
+  async send(options) {
+    typeof options == "string" && (options = { content: options });
+    let sendOptions = {
+      ...options,
+      withResponse: true
+    };
+    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
+  }
+}, MessageContext = class extends BaseCommandContext {
+  async send(options) {
+    let { channel } = this;
+    if (!channel?.isSendable())
+      throw new Error("Invalid channel or channel is not sendable");
+    return await channel.send(options);
+  }
+};
+var ProjectConfigSchema = z4.object({
+  /**
+   * 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`
+   */
+  intents: z4.union([z4.literal("auto"), z4.bigint(), z4.array(z4.enum(GatewayIntentBits))]).default("auto"),
+  /**
+   * 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}
+   */
+  clientOptions: z4.custom().optional(),
+  prefixes: z4.array(z4.string()).default([]),
+  token: z4.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 import(pathToFileURL(configPath).href)).default;
+  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
+}
+function getConfig() {
+  if (!_config)
+    throw new Error("Project config is not loaded.");
+  return _config;
+}
+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 {
+      let content = await readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    await rm(this.rootDir, { recursive: true, force: true });
+  }
+  clearSync() {
+    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
+  }
+};
+
+// src/core/internal/Instance.ts
+var Instance = class {
+  client;
+  cache;
+  constructor() {
+    this.cache = new ProjectCacheManager();
+  }
+  async start() {
+    await loadConfig();
+    let config = getConfig();
+    this.client = new BakitClient(
+      {
+        intents: [],
+        ...config.clientOptions
+      },
+      this
+    ), await this.loadModules(), this.initIntents(), await this.client.login(config.token), this.initProcess();
+  }
+  initProcess() {
+    process.on("message", (msg) => this.onProcessMessage(msg));
+  }
+  loadModules() {
+    let { managers } = this.client, { commands, listeners } = managers;
+    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules("src"), listeners.loadModules("src")]);
+  }
+  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;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async onProcessMessage(message) {
+    let { type, file } = message;
+    if (!type.startsWith("hmr:"))
+      return;
+    let target = type.split(":")[1], { listeners, commands } = this.client.managers;
+    switch (target) {
+      case "listeners":
+        await listeners.reload(file);
+        break;
+      case "commands":
+        await commands.reload(file);
+        break;
+    }
+  }
+};
+function useApp() {
+  return new Instance();
+}
 
-// src/command/param/Params.ts
+// src/core/structures/param/Params.ts
 function createFactory(ctor) {
   return (...args) => new ctor(...args);
 }
 var Params = {
   string: createFactory(StringParam),
-  number: createFactory(NumberParam)
+  number: createFactory(NumberParam),
+  user: createFactory(UserParam)
 };
 
-export { BakitClient3 as BakitClient, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig };
+export { ArgumentError, 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, ProjectCacheManager, ProjectConfigSchema, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };