bakit 2.0.0-alpha.9 → 2.0.0

package/dist/index.js

@@ -1,838 +1,4 @@
-import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, ChatInputCommandInteraction, Message } from 'discord.js';
-import z4, { z } from 'zod';
-import glob from 'tiny-glob';
-import { createJiti } from 'jiti';
-import { inspect } from 'util';
-import { posix, join, dirname } from 'path';
-import { existsSync, mkdirSync, rmSync } from 'fs';
-import { mkdir, writeFile, readFile, rm } from 'fs/promises';
-import { createHash } from 'crypto';
-
-// src/config.ts
-var INTENT_GROUPS = {
-  [GatewayIntentBits.Guilds]: [
-    Events.GuildCreate,
-    Events.GuildDelete,
-    Events.GuildUpdate,
-    Events.GuildUnavailable,
-    Events.GuildRoleCreate,
-    Events.GuildRoleDelete,
-    Events.GuildRoleUpdate,
-    Events.ChannelCreate,
-    Events.ChannelDelete,
-    Events.ChannelUpdate,
-    Events.ChannelPinsUpdate,
-    Events.ThreadCreate,
-    Events.ThreadDelete,
-    Events.ThreadUpdate,
-    Events.ThreadListSync,
-    Events.ThreadMemberUpdate,
-    Events.ThreadMembersUpdate,
-    Events.StageInstanceCreate,
-    Events.StageInstanceUpdate,
-    Events.StageInstanceDelete
-  ],
-  [GatewayIntentBits.GuildMembers]: [
-    Events.GuildMemberAdd,
-    Events.GuildMemberUpdate,
-    Events.GuildMemberRemove,
-    Events.ThreadMembersUpdate
-  ],
-  [GatewayIntentBits.GuildModeration]: [Events.GuildAuditLogEntryCreate, Events.GuildBanAdd, Events.GuildBanRemove],
-  [GatewayIntentBits.GuildExpressions]: [
-    Events.GuildEmojiCreate,
-    Events.GuildEmojiDelete,
-    Events.GuildEmojiUpdate,
-    Events.GuildStickerCreate,
-    Events.GuildStickerDelete,
-    Events.GuildStickerUpdate,
-    Events.GuildSoundboardSoundCreate,
-    Events.GuildSoundboardSoundUpdate,
-    Events.GuildSoundboardSoundDelete,
-    Events.GuildSoundboardSoundsUpdate
-  ],
-  [GatewayIntentBits.GuildIntegrations]: [Events.GuildIntegrationsUpdate],
-  [GatewayIntentBits.GuildWebhooks]: [Events.WebhooksUpdate],
-  [GatewayIntentBits.GuildInvites]: [Events.InviteCreate, Events.InviteDelete],
-  [GatewayIntentBits.GuildVoiceStates]: [Events.VoiceStateUpdate],
-  [GatewayIntentBits.GuildPresences]: [Events.PresenceUpdate],
-  [GatewayIntentBits.GuildMessages]: [
-    Events.MessageCreate,
-    Events.MessageUpdate,
-    Events.MessageDelete,
-    Events.MessageBulkDelete
-  ],
-  [GatewayIntentBits.GuildMessageReactions]: [
-    Events.MessageReactionAdd,
-    Events.MessageReactionRemove,
-    Events.MessageReactionRemoveAll,
-    Events.MessageReactionRemoveEmoji
-  ],
-  [GatewayIntentBits.GuildMessageTyping]: [Events.TypingStart],
-  [GatewayIntentBits.DirectMessages]: [
-    Events.MessageCreate,
-    Events.MessageUpdate,
-    Events.MessageDelete,
-    Events.ChannelPinsUpdate
-  ],
-  [GatewayIntentBits.DirectMessageReactions]: [
-    Events.MessageReactionAdd,
-    Events.MessageReactionRemove,
-    Events.MessageReactionRemoveAll,
-    Events.MessageReactionRemoveEmoji
-  ],
-  [GatewayIntentBits.DirectMessageTyping]: [Events.TypingStart],
-  [GatewayIntentBits.MessageContent]: [Events.MessageCreate, Events.MessageUpdate],
-  [GatewayIntentBits.GuildScheduledEvents]: [
-    Events.GuildScheduledEventCreate,
-    Events.GuildScheduledEventDelete,
-    Events.GuildScheduledEventUpdate,
-    Events.GuildScheduledEventUserAdd,
-    Events.GuildScheduledEventUserRemove
-  ],
-  [GatewayIntentBits.AutoModerationConfiguration]: [
-    Events.AutoModerationRuleCreate,
-    Events.AutoModerationRuleDelete,
-    Events.AutoModerationRuleUpdate
-  ],
-  [GatewayIntentBits.AutoModerationExecution]: [Events.AutoModerationActionExecution],
-  [GatewayIntentBits.GuildMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove],
-  [GatewayIntentBits.DirectMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove]
-}, EVENT_INTENT_MAPPING = {};
-for (let [intentStr, events] of Object.entries(INTENT_GROUPS)) {
-  let intent = Number(intentStr);
-  for (let event of events)
-    EVENT_INTENT_MAPPING[event] ??= [], EVENT_INTENT_MAPPING[event].includes(intent) || EVENT_INTENT_MAPPING[event].push(intent);
-}
-
-// src/utils/string.ts
-function tokenize(content) {
-  let args = [], current = "", quoteChar = null, isEscaped = false;
-  for (let i = 0; i < content.length; i++) {
-    let char = content[i];
-    if (char === void 0)
-      break;
-    if (isEscaped) {
-      current += char, isEscaped = false;
-      continue;
-    }
-    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;
-}
-
-// src/utils/index.ts
-var $jiti = createJiti(import.meta.url);
-
-// src/config.ts
-var ProjectConfigSchema = z.object({
-  /**
-   * The gateway intents to use for the Discord client.
-   *
-   * - `auto` — automatically determine the required intents.
-   * - bigint — a raw bitfield value representing the combined intents.
-   * - array — a list of individual intent flags from `GatewayIntentBits`.
-   *
-   * @defaultvalue `auto`
-   */
-  intents: z.union([z.literal("auto"), z.bigint(), z.array(z.enum(GatewayIntentBits))]).default("auto"),
-  /**
-   * Optional custom client options for Discord.js (excluding `intents`).
-   *
-   * These are passed directly to the `Client` constructor when initializing the bot.
-   *
-   * @see {@link https://discord.js.org/docs/packages/discord.js/main/ClientOptions:Interface}
-   */
-  clientOptions: z.custom().optional(),
-  /**
-   * The path to the main project source directory.
-   *
-   * @defaultvalue `src`
-   */
-  entryDir: z.string().default("src"),
-  prefixes: z.array(z.string()).default([]),
-  token: z.string()
-});
-function defineConfig(config) {
-  return config;
-}
-var _config;
-async function loadConfig(cwd = process.cwd()) {
-  if (_config)
-    return console.warn("loadConfig() was called more than once. This shouldn't happen."), _config;
-  let globPattern = `bakit.config.{${["ts", "js"].join(",")}}`, [configPath, other] = await glob(globPattern, {
-    cwd: cwd.replace(/\\/g, "/"),
-    // ensure the path uses `/` instead of `\` on Windows
-    absolute: true
-  });
-  if (!configPath)
-    throw new Error("Missing config file");
-  other && console.warn(`Multiple config files found in ${cwd}. Using ${configPath}.`);
-  let config = await $jiti.import(configPath, { default: true });
-  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
-}
-function getConfig() {
-  if (!_config)
-    throw new Error("Project config is not loaded.");
-  return _config;
-}
-
-// src/base/BaseClientManager.ts
-var BaseClientManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-};
-
-// src/base/lifecycle/Context.ts
-var Context = class {
-  canceled = false;
-  cancel() {
-    this.canceled = true;
-  }
-};
-
-// src/base/command/CommandContext.ts
-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 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);
-      }
-    }
-  }
-};
-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/errors/BakitError.ts
-var BakitError = class extends Error {
-  constructor(message) {
-    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/errors/ArgumentError.ts
-var ArgumentError = class extends BakitError {
-  constructor(target, reason) {
-    super(`Invalid argument for '${target}': ${reason}`);
-    this.target = target;
-    this.reason = reason;
-  }
-};
-
-// src/base/command/param/Param.ts
-var BaseParam = class {
-  constructor(options, schema) {
-    this.schema = schema;
-    let parsed = schema.parse({
-      ...options,
-      description: options.description ?? options.name
-    });
-    this.options = parsed;
-  }
-  options;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  setOption(key, value) {
-    if (value === null)
-      return delete this.options[key], this;
-    let fieldValidator = this.schema.shape[key];
-    if (!fieldValidator)
-      return this.options[key] = value, this;
-    let parsedValue = fieldValidator.parse(value);
-    return this.options[key] = parsedValue, this;
-  }
-  name(value) {
-    return this.setOption("name", value);
-  }
-  description(value) {
-    return this.setOption("description", value);
-  }
-  required(value) {
-    return this.setOption("required", value);
-  }
-  async resolve(context, value) {
-    if (context.isChatInput())
-      return await this.resolveChatInput(context);
-    if (context.isMessage())
-      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 { required, minLength, maxLength, name } = this.options;
-    if (value === void 0) {
-      if (required)
-        throw new ArgumentError(name, "is required");
-      return null;
-    }
-    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(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);
-    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);
-  }
-};
-function validateParamsOrder(params) {
-  let seenOptional = false;
-  for (let param of params)
-    if (param.options.required) {
-      if (seenOptional)
-        return false;
-    } else
-      seenOptional = true;
-  return true;
-}
-var CommandOptionsSchema = z.object({
-  name: z.string().readonly(),
-  description: z.string().min(1).max(100).optional().readonly(),
-  nsfw: z.boolean().default(false).readonly(),
-  params: z.array(z.instanceof(BaseParam)).default([]).readonly(),
-  quotes: z.boolean().default(true).readonly()
-}).transform((data) => ({
-  ...data,
-  description: data.description ?? `Command ${data.name}`
-})).refine(({ params }) => validateParamsOrder(params), {
-  path: ["params"],
-  error: "Required params must be placed before optional params"
-}), Command = class extends LifecycleManager {
-  constructor(options) {
-    let _options = CommandOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
-      await this.handleSyntaxError(ctx, error, args);
-    });
-  }
-  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;
-    }
-  }
-};
-function defineCommand(options) {
-  return new Command(options);
-}
-
-// src/base/command/CommandManager.ts
-var CommandManager = class extends BaseClientManager {
-  commands = new Collection();
-  async loadModules() {
-    let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "commands", "**/*.{ts,js}"), loads = (await glob(pattern, {
-      cwd: process.cwd(),
-      absolute: true
-    })).map(async (file) => {
-      try {
-        let command = await $jiti.import(file, { default: !0 });
-        if (!command) {
-          console.warn(`[Loader] File has no default export: ${file}`);
-          return;
-        }
-        if (!(command instanceof Command)) {
-          console.warn(`[Loader] Default export is not a Command: ${file}`);
-          return;
-        }
-        return this.add(command), command;
-      } catch (error) {
-        console.error(`An error occurred while trying to add command for '${file}':`, error);
-      }
-    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
-    return console.log(`Loaded ${loaded.length} command(s).`), loaded;
-  }
-  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(target) {
-    let name = typeof target == "string" ? target : target.options.name, existing = this.commands.get(name);
-    if (existing)
-      return this.commands.delete(name), existing;
-  }
-  get(name) {
-    return this.commands.get(name);
-  }
-};
-var ListenerOptionsSchema = z4.object({
-  name: z4.enum(Events),
-  once: z4.boolean().default(false)
-}), Listener = class extends LifecycleManager {
-  options;
-  constructor(options) {
-    let _options = ListenerOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
-    super(`listener:${_options.name}`), this.options = _options;
-  }
-};
-function defineListener(options) {
-  return new Listener(options);
-}
-var ListenerManager = class extends BaseClientManager {
-  listeners = [];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  executors = /* @__PURE__ */ new WeakMap();
-  async loadModules() {
-    let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "listeners", "**/*.{ts,js}"), loads = (await glob(pattern, {
-      cwd: process.cwd(),
-      absolute: true
-    })).map(async (file) => {
-      try {
-        let listener = await $jiti.import(file, { default: !0 });
-        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;
-  }
-  add(listener) {
-    if (!(listener instanceof Listener))
-      throw new Error("Invalid listener provided");
-    let execute = (...args) => {
-      listener.execute(new Context(), ...args);
-    };
-    this.listeners.push(listener), this.executors.set(listener, execute);
-    let { once, name } = listener.options;
-    this.client[once ? "once" : "on"](name, execute);
-  }
-  remove(target) {
-    let isMatched = (listener) => typeof target == "string" ? listener.options.name === target : listener === target, removed = [];
-    return this.listeners = this.listeners.filter((listener) => {
-      if (!isMatched(listener))
-        return true;
-      removed.push(listener);
-      let execute = this.executors.get(listener);
-      return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
-    }), removed;
-  }
-  getBaseIntents() {
-    return new IntentsBitField([GatewayIntentBits.Guilds]);
-  }
-  getNeededIntents() {
-    let result = this.getBaseIntents();
-    for (let listener of this.listeners) {
-      let eventName = listener.options.name, requiredIntents = EVENT_INTENT_MAPPING[eventName];
-      requiredIntents && result.add(requiredIntents);
-    }
-    return result;
-  }
-};
-
-// src/base/BakitClient.ts
-var BakitClient2 = 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/base/command/param/Params.ts
-function createFactory(ctor) {
-  return (...args) => new ctor(...args);
-}
-var Params = {
-  string: createFactory(StringParam),
-  number: createFactory(NumberParam)
-};
-
-// src/defaults/command.ts
-var messageCommandHandler = defineListener(Events.MessageCreate), chatInputCommandHandler = defineListener(Events.InteractionCreate), registerCommandsHandler = defineListener({
-  name: Events.ClientReady,
-  once: true
-});
-registerCommandsHandler.main(async (_, client) => {
-  let { managers, instance } = client, { commands } = managers, { cache } = instance, payload = commands.commands.map((cmd) => cmd.toSlashCommandJSON()).sort((a, b) => a.name.localeCompare(b.name)), currentHash = cache.getHash(payload), CACHE_KEY = "commands/meta.json", cachedMeta = await cache.read(CACHE_KEY);
-  if (cachedMeta && cachedMeta.hash === currentHash) {
-    let { timestamp, count } = cachedMeta, time = new Date(timestamp).toLocaleString();
-    console.log(`${count} command(s) are up to date (Last sync: ${time}). Skipping registration.`);
-    return;
-  }
-  try {
-    let result = await client.application.commands.set(payload);
-    cache.write(CACHE_KEY, {
-      hash: currentHash,
-      timestamp: Date.now(),
-      count: result.size
-    }), cache.write("commands/debug_dump.json", payload), console.log(`Registered ${result.size} application command(s).`);
-  } catch (error) {
-    console.error("Failed to register commands:", error);
-  }
-});
-messageCommandHandler.main(async (_, message) => {
-  let config = getConfig();
-  if (message.author.bot)
-    return;
-  let { content } = message, client = message.client, lowerContent = content.toLowerCase(), prefix = config.prefixes.find((p) => lowerContent.startsWith(p));
-  if (!prefix)
-    return;
-  let [name, ...args] = content.slice(prefix.length).trim().split(/\s+/g);
-  if (!name)
-    return;
-  let command = client.managers.commands.get(name);
-  if (!command)
-    return;
-  let context = new MessageContext(message), { params, quotes } = command.options, rawArgs = quotes ? tokenize(args.join(" ")) : args, resolvedArgs = [];
-  for (let i = 0; i < params.length; i++) {
-    let param = params[i], arg = rawArgs[i];
-    if (!param)
-      break;
-    let resolved = await param.resolve(context, arg);
-    resolvedArgs.push(resolved);
-  }
-  await command.execute(context, ...resolvedArgs);
-});
-chatInputCommandHandler.main(async (_, interaction) => {
-  if (!interaction.isChatInputCommand())
-    return;
-  let { commandName } = interaction, command = interaction.client.managers.commands.get(commandName);
-  if (!command)
-    return;
-  let context = new ChatInputContext(interaction), { params } = command.options, resolvedArgs = [];
-  for (let param of params) {
-    let resolved = await param.resolve(context);
-    resolvedArgs.push(resolved);
-  }
-  await command.execute(context, ...resolvedArgs);
-});
-var ProjectCacheManager = class {
-  rootDir;
-  constructor(root = process.cwd()) {
-    this.rootDir = join(root, ".bakit"), this.ensureRoot();
-  }
-  ensureRoot() {
-    existsSync(this.rootDir) || mkdirSync(this.rootDir, { recursive: true });
-  }
-  getHash(data) {
-    return createHash("sha256").update(JSON.stringify(data)).digest("hex");
-  }
-  async write(path, data) {
-    let fullPath = join(this.rootDir, path), dir = dirname(fullPath);
-    await mkdir(dir, { recursive: true });
-    let content = typeof data == "string" ? data : JSON.stringify(data);
-    await writeFile(fullPath, content, "utf-8");
-  }
-  async read(path) {
-    let fullPath = join(this.rootDir, path);
-    try {
-      let content = await readFile(fullPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  async clear() {
-    await rm(this.rootDir, { recursive: true, force: true });
-  }
-  clearSync() {
-    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
-  }
-};
-
-// src/base/Instance.ts
-var Instance = class {
-  client;
-  cache;
-  constructor() {
-    this.cache = new ProjectCacheManager();
-  }
-  async start() {
-    await loadConfig();
-    let config = getConfig();
-    this.client = new BakitClient2(
-      {
-        intents: [],
-        ...config.clientOptions
-      },
-      this
-    ), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
-  }
-  loadModules() {
-    let { managers } = this.client, { commands, listeners } = managers;
-    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
-  }
-  initIntents() {
-    let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
-    config.intents === "auto" ? intents = listeners.getNeededIntents() : (intents = listeners.getBaseIntents(), typeof config.intents == "bigint" ? intents.bitfield = Number(config.intents) : intents.add(...config.intents)), options.intents = intents;
-  }
-};
-function useApp() {
-  return new Instance();
-}
-
-export { $jiti, ArgumentError, BakitClient2 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, createGatewayManager, createWorker } from '@bakit/gateway';
+export { createREST, createRESTTransportServer } from '@bakit/rest';
+export { Collection, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+export { RPCError, createIPCClient, createIPCServer, createService, createServiceClient, createServiceServer, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';