bakit 2.0.0-alpha.32 → 2.0.0-alpha.33

package/dist/index.js

@@ -1,1196 +1 @@
-import { GatewayIntentBits, Events, Collection, Client, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
-import { inspect } from 'util';
-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/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.
-   *
-   * - `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: z2.union([z2.literal("auto"), z2.bigint(), z2.array(z2.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: z2.custom().optional(),
-  /**
-   * 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`
-   */
-  entryDirectory: z2.string().default("src")
-});
-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.{${CONFIG_EXTENSIONS.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;
-}
-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/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.transport = transport;
-    this.transport.on("message", (message) => this.onMessage(message));
-  }
-  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`);
-  }
-  onMessage(message) {
-    if (message.id.startsWith(RPC_RESPONSE_MARK)) {
-      this.handleResponseMessage(message);
-      return;
-    }
-    if ("type" in message) {
-      this.handleRequestMessage(message);
-      return;
-    }
-  }
-  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));
-  }
-  handleRequestMessage(message) {
-    this.emit("message", message), this.emit(message.type, message.id, message.data);
-  }
-  send(type, data = {}, id = randomUUID()) {
-    let message = {
-      id,
-      type,
-      data
-    };
-    this.postMessage(message);
-  }
-  success(id, data) {
-    let message = {
-      id: `${RPC_RESPONSE_MARK}${id}`,
-      data
-    };
-    this.postMessage(message);
-  }
-  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/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), 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) {
-  if (path.includes("/node_modules/"))
-    return;
-  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/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;
-  }
-  options;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  setOption(key, value) {
-    if (value === null)
-      return delete this.options[key], this;
-    let fieldValidator = this.schema.shape[key];
-    if (!fieldValidator)
-      return this.options[key] = value, this;
-    let parsedValue = fieldValidator.parse(value);
-    return this.options[key] = parsedValue, this;
-  }
-  name(value) {
-    return this.setOption("name", value);
-  }
-  description(value) {
-    return this.setOption("description", value);
-  }
-  required(value) {
-    return this.setOption("required", value);
-  }
-  async resolve(context, value) {
-    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");
-  }
-  /**
-   * 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), StringParamSchema);
-  }
-  required(value) {
-    return super.required(value);
-  }
-  resolveMessage(_context, value) {
-    let { minLength, maxLength, name } = this.options;
-    if (minLength && value.length < minLength)
-      throw new ArgumentError(name, `must be at least ${minLength} chars long`);
-    if (maxLength && value.length > maxLength)
-      throw new ArgumentError(name, `must be at most ${maxLength} chars long`);
-    return value;
-  }
-  resolveChatInput(context) {
-    let { name, required } = this.options;
-    return context.source.options.getString(name, required);
-  }
-  /**
-   * 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 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/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}`
-})).refine(({ params }) => validateParamsOrder(params), {
-  path: ["params"],
-  error: "Required params must be placed before optional params"
-}), Command = class extends LifecycleManager {
-  constructor(options) {
-    let _options = CommandOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
-      await this.handleSyntaxError(ctx, error, args);
-    });
-  }
-  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/core/managers/CommandManager.ts
-var CommandManager = class extends HotReloadable2 {
-  constructor(client) {
-    super(join(getEntryDirectory(), "commands"));
-    this.client = client;
-  }
-  commands = new Collection();
-  entries = new Collection();
-  async loadModules() {
-    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");
-    let { name } = command.options;
-    if (this.commands.has(name)) {
-      console.warn(`[Loader] Duplicate command registered: '${name}'`);
-      return;
-    }
-    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 = z2.object({
-  name: z2.enum(Events),
-  once: z2.boolean().default(false)
-}), Listener = class extends LifecycleManager {
-  options;
-  constructor(options) {
-    let _options = ListenerOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`listener:${_options.name}`), this.options = _options;
-  }
-};
-function defineListener(options) {
-  return new Listener(options);
-}
-
-// 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 = [];
-  entries = new Collection();
-  executors = /* @__PURE__ */ new WeakMap();
-  async loadModules() {
-    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 { once, name } = listener.options, execute = (...args) => {
-      listener.execute(new Context(), ...args);
-    };
-    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) => {
-      if (!isMatched(listener))
-        return true;
-      removed.push(listener);
-      let execute = this.executors.get(listener);
-      return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
-    }), removed;
-  }
-  /**
-   * 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/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.
-   */
-  isReady() {
-    return super.isReady();
-  }
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  once(event, listener) {
-    return super.once(event, listener);
-  }
-  off(event, listener) {
-    return super.off(event, listener);
-  }
-  removeAllListeners(event) {
-    return super.removeAllListeners(event);
-  }
-  removeListener(event, listener) {
-    return super.removeListener(event, listener);
-  }
-  emit(event, ...args) {
-    return super.emit(event, ...args);
-  }
-  /**
-   * Override BakitClient output when using logger for security concern.
-   * @returns `BakitClient {}`
-   */
-  [inspect.custom]() {
-    return `${this.constructor.name} {}`;
-  }
-};
-
-// src/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/core/structures/param/Params.ts
-function createFactory(ctor) {
-  return (...args) => new ctor(...args);
-}
-var Params = {
-  string: createFactory(StringParam),
-  number: createFactory(NumberParam),
-  user: createFactory(UserParam)
-};
-
-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 };