bakit 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/index.js

@@ -1,12 +1,172 @@
-import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, ChatInputCommandInteraction, Message } from 'discord.js';
-import z3, { z } from 'zod';
-import { pathToFileURL } from 'url';
-import glob from 'tiny-glob';
+import { GatewayIntentBits, Events, Collection, Client, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
 import { inspect } from 'util';
-import { posix } from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { join, resolve, relative, sep, dirname } from 'path';
+import glob from 'tiny-glob';
+import z2 from 'zod';
+import { register } from 'module';
+import { MessageChannel } from 'worker_threads';
+import { randomUUID, createHash } from 'crypto';
+import EventEmitter from 'events';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { mkdir, writeFile, readFile, rm } from 'fs/promises';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional(),
+  required: z2.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z2.number().min(1).optional(),
+  minLength: z2.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z2.number().optional(),
+  minValue: z2.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/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/lib/errors/ArgumentError.ts
+var ArgumentError = class extends BakitError {
+  constructor(target, reason) {
+    super(`Invalid argument for '${target}': ${reason}`);
+    this.target = target;
+    this.reason = reason;
+  }
+};
 
-// src/config.ts
-var ProjectConfigSchema = z.object({
+// 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;
+  }
+  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;
+}
+var CONFIG_EXTENSIONS = ["ts", "js"], ProjectConfigSchema = z2.object({
   /**
    * The gateway intents to use for the Discord client.
    *
@@ -16,7 +176,7 @@ var ProjectConfigSchema = z.object({
    *
    * @defaultvalue `auto`
    */
-  intents: z.union([z.literal("auto"), z.bigint(), z.array(z.enum(GatewayIntentBits))]).default("auto"),
+  intents: z2.union([z2.literal("auto"), z2.bigint(), z2.array(z2.enum(GatewayIntentBits))]).default("auto"),
   /**
    * Optional custom client options for Discord.js (excluding `intents`).
    *
@@ -24,15 +184,20 @@ var ProjectConfigSchema = z.object({
    *
    * @see {@link https://discord.js.org/docs/packages/discord.js/main/ClientOptions:Interface}
    */
-  clientOptions: z.custom().optional(),
+  clientOptions: z2.custom().optional(),
   /**
-   * The path to the main project source directory.
-   *
+   * Your bot prefixes to trigger the commands.
+   */
+  prefixes: z2.array(z2.string()).default([]),
+  /**
+   * Your Discord bot token.
+   */
+  token: z2.string(),
+  /**
+   * The main source directory.
    * @defaultvalue `src`
    */
-  entryDir: z.string().default("src"),
-  prefixes: z.array(z.string()).default([]),
-  token: z.string()
+  entryDirectory: z2.string().default("src")
 });
 function defineConfig(config) {
   return config;
@@ -41,7 +206,7 @@ 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, {
+  let globPattern = `bakit.config.{${CONFIG_EXTENSIONS.join(",")}}`, [configPath, other] = await glob(globPattern, {
     cwd: cwd.replace(/\\/g, "/"),
     // ensure the path uses `/` instead of `\` on Windows
     absolute: true
@@ -49,7 +214,7 @@ async function loadConfig(cwd = process.cwd()) {
   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);
+  let config = (await import(pathToFileURL(configPath).href)).default;
   return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
 }
 function getConfig() {
@@ -57,175 +222,262 @@ function getConfig() {
     throw new Error("Project config is not loaded.");
   return _config;
 }
+function getTopLevelDirectory(path, entryDir) {
+  return relative(entryDir, path).split(sep)[0] ?? null;
+}
+function getEntryDirectory() {
+  return resolve(getConfig().entryDirectory);
+}
+function getEntryFile() {
+  return process.env.BAKIT_ENTRY_FILE;
+}
 
-// src/base/lifecycle/Context.ts
-var Context = class {
-  canceled = false;
-  cancel() {
-    this.canceled = true;
-  }
-};
-
-// src/command/CommandContext.ts
-var BaseCommandContext = class extends Context {
-  constructor(source) {
+// src/lib/loader/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  addHotReloader: () => addHotReloader,
+  containsEntryFile: () => containsEntryFile,
+  containsHotModule: () => containsHotModule,
+  getDependencyChain: () => getDependencyChain,
+  getImporters: () => getImporters,
+  getImports: () => getImports,
+  hotReloaders: () => hotReloaders,
+  importsAny: () => importsAny,
+  init: () => init,
+  isEntryFile: () => isEntryFile,
+  isImported: () => isImported,
+  isImportedBy: () => isImportedBy,
+  isInHotDirectory: () => isInHotDirectory,
+  restartProcess: () => restartProcess,
+  unload: () => unload
+});
+var RPC_RESPONSE_MARK = "$DONE:", RPC_RESPONSE_TIMEOUT = 5e3, RPC = class extends EventEmitter {
+  constructor(transport) {
     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 LifecycleManager = class {
-  constructor(id) {
-    this.id = id;
+    this.transport = transport;
+    this.transport.on("message", (message) => this.onMessage(message));
   }
-  // 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}`;
+  requests = /* @__PURE__ */ new Map();
+  postMessage(message) {
+    let { transport } = this;
+    "send" in transport ? transport.send(message) : "postMessage" in transport ? transport.postMessage(message) : console.warn(`${transport.constructor.name} doesn't support IPC`);
   }
-  // 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);
+  onMessage(message) {
+    if (message.id.startsWith(RPC_RESPONSE_MARK)) {
+      this.handleResponseMessage(message);
+      return;
+    }
+    if ("type" in message) {
+      this.handleRequestMessage(message);
+      return;
     }
-    return this;
-  }
-  main(callback) {
-    return this.setHook("main", "MAIN" /* Main */, callback);
   }
-  pre(callback) {
-    return this.setHook("pre", "PRE" /* Pre */, callback);
+  handleResponseMessage(message) {
+    let id = message.id.slice(RPC_RESPONSE_MARK.length), request = this.requests.get(id);
+    if (!request)
+      return;
+    let { reject, resolve: resolve6, timeout } = request;
+    this.requests.delete(id), clearTimeout(timeout), "data" in message ? resolve6(message.data) : reject(new Error(message.error));
   }
-  post(callback) {
-    return this.setHook("post", "POST" /* Post */, callback);
+  handleRequestMessage(message) {
+    this.emit("message", message), this.emit(message.type, message.id, message.data);
   }
-  error(callback) {
-    return this.setHook("error", "ERROR" /* Error */, callback);
+  send(type, data = {}, id = randomUUID()) {
+    let message = {
+      id,
+      type,
+      data
+    };
+    this.postMessage(message);
   }
-  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;
-      try {
-        await hook(context, ...args);
-      } catch (e) {
-        error = e;
-        break;
-      }
-    }
-    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);
-      }
-    }
+  success(id, data) {
+    let message = {
+      id: `${RPC_RESPONSE_MARK}${id}`,
+      data
+    };
+    this.postMessage(message);
   }
-};
-
-// src/errors/BakitError.ts
-var BakitError = class extends Error {
-  constructor(message) {
-    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
+  error(id, error) {
+    let message = {
+      id: `${RPC_RESPONSE_MARK}${id}`,
+      error
+    };
+    this.postMessage(message);
+  }
+  request(type, data, id = randomUUID()) {
+    return new Promise((resolve6, reject) => {
+      let timeout = setTimeout(() => {
+        this.requests.delete(id) && reject(new Error("Request timed out"));
+      }, RPC_RESPONSE_TIMEOUT);
+      this.requests.set(id, {
+        resolve: resolve6,
+        reject,
+        timeout
+      }), this.send(type, data, id);
+    });
   }
 };
 
-// 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/lib/loader/loader.ts
+var hooksRPC, processRPC, hotReloaders = new Collection(), reverseDependencyGraph = new Collection(), forwardDependencyGraph = new Collection();
+function init() {
+  initProcess(), initHooks();
+}
+function initProcess() {
+  processRPC = new RPC(process), processRPC.on("fileChange", (_, path) => onFileChange(path)), processRPC.on("fileRemove", (_, path) => onFileRemove(path));
+}
+function initHooks() {
+  let { port1, port2 } = new MessageChannel(), hookPath = new URL("./hooks.js", import.meta.url).href;
+  register(hookPath, import.meta.url, {
+    data: { port: port1 },
+    transferList: [port1]
+  }), hooksRPC = new RPC(port2), hooksRPC.on("dependencyAdd", (_, data) => onDependencyAdd(data)), port2.unref();
+}
+function addHotReloader(reloader) {
+  hotReloaders.set(reloader.entryDirectory, reloader);
+}
+function unload(path) {
+  if (!hooksRPC)
+    throw new Error("Loader isn't initialized");
+  return hooksRPC.request("unload", resolve(path));
+}
+function getImporters(path, createNew = false) {
+  path = resolve(path);
+  let entry = reverseDependencyGraph.get(path);
+  return createNew && !entry && (entry = /* @__PURE__ */ new Set(), reverseDependencyGraph.set(path, entry)), entry;
+}
+function getImports(path) {
+  path = resolve(path);
+  let imports = [];
+  for (let [target, importers] of reverseDependencyGraph)
+    importers.has(path) && imports.push(target);
+  return imports;
+}
+function getDependencyChain(path) {
+  path = resolve(path);
+  let queue = [path], visited = /* @__PURE__ */ new Set();
+  for (; queue.length > 0; ) {
+    let current = queue.shift();
+    if (!current || visited.has(current) || (visited.add(current), current.includes("/node_modules/")))
+      continue;
+    let parents = getImporters(current);
+    if (!parents)
+      continue;
+    for (let parent of parents)
+      visited.has(parent) || queue.push(parent);
+    let children = getImports(current);
+    for (let child of children)
+      visited.has(child) || importsAny(child, visited) && queue.push(child);
+  }
+  return Array.from(visited);
+}
+function importsAny(path, targets) {
+  return getImports(path).some((imp) => targets.has(imp));
+}
+function isImported(path) {
+  return !!getImporters(path)?.size;
+}
+function isImportedBy(path, matcher) {
+  return getDependencyChain(path).slice(1).some((p) => {
+    let isMatch = false;
+    return typeof matcher == "string" && (isMatch = resolve(matcher) === p), typeof matcher == "function" && (isMatch = matcher(p)), matcher instanceof RegExp && (isMatch = matcher.test(p)), isMatch;
+  });
+}
+function onDependencyAdd(data) {
+  let { url, parentURL } = data, path = fileURLToPath(url), parentPath = fileURLToPath(parentURL);
+  if (parentPath.includes("/node_modules/"))
+    return;
+  let reverseEntry = reverseDependencyGraph.get(path);
+  reverseEntry || (reverseEntry = /* @__PURE__ */ new Set(), reverseDependencyGraph.set(path, reverseEntry)), reverseEntry.add(parentPath);
+  let forwardEntry = forwardDependencyGraph.get(parentPath);
+  forwardEntry || (forwardEntry = /* @__PURE__ */ new Set(), forwardDependencyGraph.set(parentPath, forwardEntry)), forwardEntry.add(path);
+}
+function isInHotDirectory(path) {
+  let sourceRoot = getEntryDirectory();
+  if (!path.startsWith(sourceRoot))
+    return false;
+  let topLevelDir = getTopLevelDirectory(path, sourceRoot);
+  if (!topLevelDir)
+    return;
+  let entryDirectory = join(sourceRoot, topLevelDir);
+  return hotReloaders.some((m) => m.entryDirectory === entryDirectory);
+}
+function isEntryFile(path) {
+  return path === getEntryFile();
+}
+function containsEntryFile(chain) {
+  return chain.some((x) => isEntryFile(x));
+}
+function containsHotModule(chain) {
+  return chain.some((x) => isInHotDirectory(x));
+}
+function restartProcess() {
+  processRPC?.send("restart");
+}
+async function unloadModule(path, reload = false) {
+  let topLevel = getTopLevelDirectory(path, getEntryDirectory());
+  if (!topLevel)
+    return;
+  let directory = resolve(getEntryDirectory(), topLevel), reloader = hotReloaders.get(directory);
+  if (!reloader) {
+    await unload(path);
+    return;
+  }
+  reloader[reload ? "reload" : "unload"](path);
+}
+async function onFileRemove(path) {
+  if (isEntryFile(path)) {
+    restartProcess();
+    return;
+  }
+  if (!isImported(path))
+    return;
+  let chain = getDependencyChain(path);
+  if (containsEntryFile(chain)) {
+    restartProcess();
+    return;
+  }
+  if (containsHotModule(chain))
+    for (let path2 of chain.reverse())
+      await unloadModule(path2);
+}
+async function onFileChange(path) {
+  if (isEntryFile(path)) {
+    restartProcess();
+    return;
+  }
+  if (!isImported(path))
+    return;
+  let chain = getDependencyChain(path);
+  if (containsEntryFile(chain)) {
+    restartProcess();
+    return;
+  }
+  if (containsHotModule(chain))
+    for (let path2 of chain.toReversed())
+      await unloadModule(path2, true);
+}
 
-// src/command/param/Param.ts
+// src/core/structures/param/Param.ts
 var BaseParam = class {
-  options;
-  constructor(options) {
-    this.options = { ...options, required: options.required ?? true };
+  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) {
-    return value === null ? delete this.options[key] : this.options[key] = value, this;
+    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);
@@ -239,8 +491,15 @@ var BaseParam = class {
   async resolve(context, value) {
     if (context.isChatInput())
       return await this.resolveChatInput(context);
-    if (context.isMessage())
+    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");
   }
   /**
@@ -251,18 +510,13 @@ var BaseParam = class {
   }
 }, StringParam = class extends BaseParam {
   constructor(options) {
-    super(BaseParam.getOptions(options));
+    super(BaseParam.getOptions(options), StringParamSchema);
   }
   required(value) {
     return super.required(value);
   }
   resolveMessage(_context, value) {
-    let { required, minLength, maxLength, name } = this.options;
-    if (value === void 0) {
-      if (required)
-        throw new ArgumentError(name, "is required");
-      return null;
-    }
+    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)
@@ -289,19 +543,13 @@ var BaseParam = class {
   }
 }, NumberParam = class extends BaseParam {
   constructor(options) {
-    super(BaseParam.getOptions(options));
+    super(BaseParam.getOptions(options), NumberParamSchema);
   }
   required(value) {
     return super.required(value);
   }
-  resolveMessage(ctx, value) {
-    let { required, minValue, maxValue, name } = this.options;
-    if (value === void 0) {
-      if (required)
-        throw new ArgumentError(name, "is required");
-      return null;
-    }
-    let num = Number(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)
@@ -328,18 +576,120 @@ var BaseParam = class {
   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 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;
+  }
+  // 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;
+      try {
+        await hook(context, ...args);
+      } catch (e) {
+        error = e;
+        break;
+      }
+    }
+    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);
+      }
+    }
+  }
 };
 
-// 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([]),
-  quotes: z.boolean().default(true)
+// 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 = z2.object({
+  name: z2.string().readonly(),
+  description: z2.string().min(1).max(100).optional().readonly(),
+  nsfw: z2.boolean().default(false).readonly(),
+  params: z2.array(z2.instanceof(BaseParam)).default([]).readonly(),
+  quotes: z2.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, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
@@ -349,42 +699,100 @@ var CommandOptionsSchema = z.object({
   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);
 }
+var HotReloadable2 = class {
+  constructor(entryDirectory) {
+    this.entryDirectory = entryDirectory;
+    entryDirectory = resolve(entryDirectory);
+  }
+  unloadFile(path) {
+    return loader_exports.unload(path);
+  }
+};
 
-// src/base/BaseClientManager.ts
-var BaseClientManager = class {
+// src/core/managers/CommandManager.ts
+var CommandManager = class extends HotReloadable2 {
   constructor(client) {
+    super(join(getEntryDirectory(), "commands"));
     this.client = client;
   }
-};
-
-// src/command/CommandManager.ts
-var CommandManager = class extends BaseClientManager {
   commands = new Collection();
+  entries = 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;
+    let pattern = join(this.entryDirectory, "**/*.{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) {
+    path = resolve(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) {
+    path = resolve(path);
+    let command = this.entries.get(path);
+    if (this.entries.delete(path), await this.unloadFile(path), !!command)
+      return this.remove(command);
+  }
+  async reload(path) {
+    path = resolve(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");
@@ -395,18 +803,30 @@ 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 = z2.object({
+  name: z2.enum(Events),
+  once: z2.boolean().default(false)
 }), Listener = class extends LifecycleManager {
   options;
   constructor(options) {
@@ -417,138 +837,80 @@ var ListenerOptionsSchema = z3.object({
 function defineListener(options) {
   return new Listener(options);
 }
-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/listener/ListenerManager.ts
-var ListenerManager = class extends BaseClientManager {
+// src/core/context/Context.ts
+var Context = class {
+  canceled = false;
+  cancel() {
+    this.canceled = true;
+  }
+};
+
+// src/core/managers/ListenerManager.ts
+var ListenerManager = class extends HotReloadable2 {
+  constructor(client) {
+    super(join(getEntryDirectory(), "listeners"));
+    this.client = client;
+  }
   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;
+    let pattern = join(this.entryDirectory, "**/*.{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) {
+    path = resolve(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) {
+    path = resolve(path);
+    let listener = this.entries.get(path);
+    if (this.entries.delete(path), await this.unloadFile(path), !!listener)
+      return this.remove(listener)?.[0];
+  }
+  async reload(path) {
+    path = resolve(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) => {
@@ -559,9 +921,17 @@ 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) {
@@ -572,15 +942,17 @@ var ListenerManager = class extends BaseClientManager {
   }
 };
 
-// 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)
     };
   }
+  managers;
   /**
    * Check if the client is connected to gateway successfully and finished initialization.
    */
@@ -613,25 +985,213 @@ 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()
+
+// src/core/managers/BaseClientManager.ts
+var BaseClientManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+};
+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 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 });
+  }
+};
+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);
+});
+
+// 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("SIGINT", () => this.shutdown()), process.on("SIGTERM", () => this.shutdown());
+  }
+  loadModules() {
+    let { managers } = this.client, { commands, listeners } = managers;
+    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), addHotReloader(commands), addHotReloader(listeners), 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;
+  }
+  async shutdown() {
+    this.client && await this.client.destroy().catch(() => null), process.exit(0);
+  }
+};
+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, HotReloadable2 as HotReloadable, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, loader_exports as Loader, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectCacheManager, ProjectConfigSchema, RPC, RPC_RESPONSE_MARK, RPC_RESPONSE_TIMEOUT, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getEntryDirectory, getEntryFile, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };