bakit 2.0.0-alpha.14 → 2.0.0-alpha.16

package/dist/{bin/bakit.js → cli.js}

@@ -2,34 +2,16 @@ import { config } from 'dotenv';
 import { program } from 'commander';
 import { fork } from 'child_process';
 import chokidar from 'chokidar';
-import path, { resolve, relative, sep } from 'path';
+import path, { relative, sep } from 'path';
 import { createJiti } from 'jiti';
 
-// src/bin/bakit.ts
-var Module = class {
-  static jiti = createJiti(process.cwd());
-  static async import(module, defaultImport = false) {
-    let path2 = resolve(module);
-    try {
-      return await this.jiti.import(path2, { default: defaultImport });
-    } catch (error) {
-      return console.error(`[Module] Import failed for ${path2}:`, error), null;
-    }
-  }
-  static isLoaded(module) {
-    let path2 = resolve(module);
-    return !!path2 && !!this.jiti.cache[path2];
-  }
-  static unload(module) {
-    let path2 = resolve(module);
-    return !path2 || !this.jiti.cache[path2] ? false : (delete this.jiti.cache[path2], true);
-  }
-  static getTopLevel(path2, entryDir) {
-    return relative(entryDir, path2).split(sep)[0] ?? null;
-  }
-};
+// src/cli/bin.ts
+createJiti(process.cwd());
+function getTopLevelDirectory(path2, entryDir) {
+  return relative(entryDir, path2).split(sep)[0] ?? null;
+}
 
-// src/base/process/DevProcessManager.ts
+// src/cli/process/DevProcessManager.ts
 var DevProcessManager = class {
   constructor(options) {
     this.options = options;
@@ -74,7 +56,7 @@ var DevProcessManager = class {
   onFileChanged(file) {
     if (!this.child)
       return;
-    let top = Module.getTopLevel(file, this.options.rootDir);
+    let top = getTopLevelDirectory(file, this.options.rootDir);
     if (top && this.options.hotDirs.includes(top)) {
       this.child.connected && this.child.send({ type: `hmr:${top}`, file });
       return;
@@ -88,7 +70,7 @@ var DevProcessManager = class {
   }
 };
 
-// src/bin/bakit.ts
+// src/cli/bin.ts
 program.name("bakit");
 program.command("dev").action(() => {
   config({ path: [".env.local", ".env"], quiet: true }), new DevProcessManager({

package/dist/index.d.ts

@@ -1,52 +1,41 @@
 import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client } from 'discord.js';
-import z$1, { z } from 'zod';
-import * as jiti from 'jiti';
+import { ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client, ClientOptions } from 'discord.js';
 import { inspect } from 'node:util';
+import z from 'zod';
 
-declare const ProjectConfigSchema: z.ZodObject<{
-    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
-    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
-    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    token: z.ZodString;
-}, z.core.$strip>;
-type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
-type ProjectConfig = z.output<typeof ProjectConfigSchema>;
-/**
- * Define config object for your project. This is just a cleaner way to define config.
- * @param config The partial version of project config.
- * @returns The same config you provided earlier.
- */
-declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
-/**
- * Load the config file and save them for later usage.
- * @param cwd The location of the config file, uses root by default.
- * @returns The complete config with default values from the validation.
- */
-declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
-/**
- * Get the loaded config of the project.
- * @returns The project config.
- */
-declare function getConfig(): ProjectConfig;
-
-declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
-
-declare function tokenize(content: string): string[];
-/**
- * Extracts a valid Discord Snowflake (User ID, Channel ID, etc.) from a string.
- * @param input The raw string to parse
- * @returns The extracted ID string, or null if invalid
- */
-declare function extractSnowflakeId(input: string): string | null;
-
-declare class Module {
-    static jiti: jiti.Jiti;
-    static import<T>(module: string, defaultImport?: boolean): Promise<T | null>;
-    static isLoaded(module: string): boolean;
-    static unload(module: string): boolean;
-    static getTopLevel(path: string, entryDir: string): string | null;
+declare enum ParamUserType {
+    Bot = "bot",
+    Normal = "normal",
+    Any = "any"
 }
+declare const BaseParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+declare const StringParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+}, z.z.core.$strip>;
+declare const NumberParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxValue: z.ZodOptional<z.ZodNumber>;
+    minValue: z.ZodOptional<z.ZodNumber>;
+}, z.z.core.$strip>;
+declare const UserParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+type BaseParamOptions = z.input<typeof BaseParamSchema>;
+type StringOptions = z.input<typeof StringParamSchema>;
+type NumberOptions = z.input<typeof NumberParamSchema>;
+type UserOptions = z.input<typeof UserParamSchema>;
 
 declare class Context {
     canceled: boolean;
@@ -82,68 +71,6 @@ declare class MessageContext<Cached extends boolean = boolean, InGuild extends b
 }
 type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
-declare enum HookState {
-    Pre = "PRE",
-    Main = "MAIN",
-    Post = "POST",
-    Error = "ERROR"
-}
-declare enum HookOrder {
-    First = 0,
-    Last = 1
-}
-type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
-type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
-declare class LifecycleManager<C extends Context, Args extends unknown[]> {
-    id: string;
-    private readonly hooks;
-    constructor(id: string);
-    getName(name: string): string;
-    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
-    main(callback: MainHookCallback<C, Args>): this;
-    pre(callback: MainHookCallback<C, Args>): this;
-    post(callback: MainHookCallback<C, Args>): this;
-    error(callback: ErrorHookCallback<C, Args>): this;
-    execute(context: C, ...args: Args): Promise<void>;
-}
-
-declare enum ParamUserType {
-    Bot = "bot",
-    Normal = "normal",
-    Any = "any"
-}
-declare const BaseParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const StringParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const NumberParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxValue: z.ZodOptional<z.ZodNumber>;
-    minValue: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const UserParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type BaseParamOptions = z.input<typeof BaseParamSchema>;
-type StringOptions = z.input<typeof StringParamSchema>;
-type NumberOptions = z.input<typeof NumberParamSchema>;
-type UserOptions = z.input<typeof UserParamSchema>;
-
 type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
 declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
     private schema;
@@ -159,7 +86,7 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
      * @internal
      */
     readonly _type: Required extends true ? OutputType : OutputType | null;
-    constructor(options: Options, schema: z$1.ZodObject);
+    constructor(options: Options, schema: z.ZodObject);
     protected setOption(key: keyof Options, value: any): this;
     name(value: string): this;
     description(value: string): this;
@@ -223,6 +150,34 @@ type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
     [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
 };
 
+declare enum HookState {
+    Pre = "PRE",
+    Main = "MAIN",
+    Post = "POST",
+    Error = "ERROR"
+}
+declare enum HookOrder {
+    First = 0,
+    Last = 1
+}
+type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
+type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
+declare class LifecycleManager<C extends Context, Args extends unknown[]> {
+    id: string;
+    private readonly hooks;
+    constructor(id: string);
+    getName(name: string): string;
+    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
+    main(callback: MainHookCallback<C, Args>): this;
+    pre(callback: MainHookCallback<C, Args>): this;
+    post(callback: MainHookCallback<C, Args>): this;
+    error(callback: ErrorHookCallback<C, Args>): this;
+    execute(context: C, ...args: Args): Promise<void>;
+}
+
 declare function validateParamsOrder(params: readonly AnyParam<boolean>[]): boolean;
 declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
     name: z.ZodReadonly<z.ZodString>;
@@ -238,7 +193,7 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
         required?: boolean | undefined;
     }, unknown, boolean>>>>>;
     quotes: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
-}, z.core.$strip>, z.ZodTransform<{
+}, z.z.core.$strip>, z.ZodTransform<{
     description: string;
     name: string;
     nsfw: boolean;
@@ -321,6 +276,7 @@ declare class CommandManager extends BaseClientManager {
      * @returns The command object if unloaded successfully.
      */
     unload(path: string): Promise<Command | undefined>;
+    reload(path: string): Promise<Command<any[]> | undefined>;
     /**
      * Add a command to the registry.
      * @param command Command to add.
@@ -340,11 +296,11 @@ declare class CommandManager extends BaseClientManager {
     get(name: string): Command<any[]> | undefined;
 }
 
-declare const ListenerOptionsSchema: z$1.ZodObject<{
-    name: z$1.ZodEnum<typeof Events>;
-    once: z$1.ZodDefault<z$1.ZodBoolean>;
-}, z$1.z.core.$strip>;
-type ListenerOptions<K extends EventKey = EventKey> = Omit<z$1.input<typeof ListenerOptionsSchema>, "name"> & {
+declare const ListenerOptionsSchema: z.ZodObject<{
+    name: z.ZodEnum<typeof Events>;
+    once: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+type ListenerOptions<K extends EventKey = EventKey> = Omit<z.input<typeof ListenerOptionsSchema>, "name"> & {
     name: K;
 };
 type EventKey = keyof BakitClientEvents;
@@ -373,6 +329,7 @@ declare class ListenerManager extends BaseClientManager {
      * @returns The listener object if unloaded successfully.
      */
     unload(path: string): Promise<Listener | undefined>;
+    reload(path: string): Promise<Listener<keyof BakitClientEvents> | undefined>;
     /**
      * Add a listener to the registry and create a listener for client.
      * @param listener Listener to add.
@@ -470,23 +427,7 @@ declare const Params: {
     }) => UserParam<Required>;
 };
 
-interface DevManagerOptions {
-    rootDir: string;
-    entry: string;
-    hotDirs: string[];
-}
-declare class DevProcessManager {
-    private options;
-    private child;
-    private restartTimer;
-    constructor(options: DevManagerOptions);
-    start(): void;
-    private startChild;
-    private restartChild;
-    private startWatcher;
-    private onFileChanged;
-    private scheduleRestart;
-}
+declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
 
 declare class BakitError extends Error {
     constructor(message: string);
@@ -498,4 +439,21 @@ declare class ArgumentError extends BakitError {
     constructor(target: string, reason: string);
 }
 
-export { type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, DevProcessManager, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, Module, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+declare function tokenize(content: string): string[];
+/**
+ * Extracts a valid Discord Snowflake (User ID, Channel ID, etc.) from a string.
+ * @param input The raw string to parse
+ * @returns The extracted ID string, or null if invalid
+ */
+declare function extractSnowflakeId(input: string): string | null;
+
+declare function importModule<T>(modulePath: string, defaultImport?: boolean): Promise<T | null>;
+declare function isModuleLoaded(modulePath: string): boolean;
+declare function unloadModule(modulePath: string): boolean;
+declare function getTopLevelDirectory(path: string, entryDir: string): string | null;
+
+declare const messageCommandHandler: Listener<Events.MessageCreate>;
+declare const chatInputCommandHandler: Listener<Events.InteractionCreate>;
+declare const registerCommandsHandler: Listener<Events.ClientReady>;
+
+export { type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, ProjectCacheManager, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineListener, extractSnowflakeId, getTopLevelDirectory, importModule, isModuleLoaded, messageCommandHandler, registerCommandsHandler, tokenize, unloadModule, useApp, validateParamsOrder };

package/dist/index.js

@@ -1,16 +1,25 @@
 import { GatewayIntentBits, Events, Client, Collection, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
-import z4, { z } from 'zod';
+import { inspect } from 'util';
+import { posix, resolve, relative, sep, join, dirname } from 'path';
 import glob from 'tiny-glob';
+import z4 from 'zod';
 import { createJiti } from 'jiti';
-import path, { resolve, relative, sep, posix, join, dirname } from 'path';
-import { inspect } from 'util';
-import { fork } from 'child_process';
-import chokidar from 'chokidar';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import { mkdir, writeFile, readFile, rm } from 'fs/promises';
 import { createHash } from 'crypto';
 
-// src/config.ts
+// src/core/client/BakitClient.ts
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  required: z4.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z4.number().min(1).optional(),
+  minLength: z4.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z4.number().optional(),
+  minValue: z4.number().optional()
+}), UserParamSchema = BaseParamSchema.extend({});
 var INTENT_GROUPS = {
   [GatewayIntentBits.Guilds]: [
     Events.GuildCreate,
@@ -107,7 +116,23 @@ for (let [intentStr, events] of Object.entries(INTENT_GROUPS)) {
     EVENT_INTENT_MAPPING[event] ??= [], EVENT_INTENT_MAPPING[event].includes(intent) || EVENT_INTENT_MAPPING[event].push(intent);
 }
 
-// src/utils/string.ts
+// 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++) {
@@ -134,247 +159,28 @@ function extractSnowflakeId(input) {
   let idMatch = /^(\d{17,20})$/.exec(input);
   return idMatch?.[1] ? idMatch[1] : null;
 }
-var Module = class {
-  static jiti = createJiti(process.cwd());
-  static async import(module, defaultImport = false) {
-    let path2 = resolve(module);
-    try {
-      return await this.jiti.import(path2, { default: defaultImport });
-    } catch (error) {
-      return console.error(`[Module] Import failed for ${path2}:`, error), null;
-    }
-  }
-  static isLoaded(module) {
-    let path2 = resolve(module);
-    return !!path2 && !!this.jiti.cache[path2];
-  }
-  static unload(module) {
-    let path2 = resolve(module);
-    return !path2 || !this.jiti.cache[path2] ? false : (delete this.jiti.cache[path2], true);
-  }
-  static getTopLevel(path2, entryDir) {
-    return relative(entryDir, path2).split(sep)[0] ?? null;
+var jiti = createJiti(process.cwd());
+async function importModule(modulePath, defaultImport = false) {
+  let path = resolve(modulePath);
+  try {
+    return await jiti.import(path, { default: defaultImport });
+  } catch (error) {
+    return console.error(`[Module] Import failed for ${path}:`, error), null;
   }
-};
-
-// 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(),
-  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 Module.import(configPath, true);
-  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
+function isModuleLoaded(modulePath) {
+  let path = resolve(modulePath);
+  return !!path && !!jiti.cache[path];
 }
-function getConfig() {
-  if (!_config)
-    throw new Error("Project config is not loaded.");
-  return _config;
+function unloadModule(modulePath) {
+  let path = resolve(modulePath);
+  return !path || !jiti.cache[path] ? false : (delete jiti.cache[path], true);
+}
+function getTopLevelDirectory(path, entryDir) {
+  return relative(entryDir, path).split(sep)[0] ?? null;
 }
 
-// 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()
-}), UserParamSchema = BaseParamSchema.extend({});
-
-// src/errors/BakitError.ts
-var BakitError = class extends Error {
-  constructor(message) {
-    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/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
+// src/core/structures/param/Param.ts
 var BaseParam = class {
   constructor(options, schema) {
     this.schema = schema;
@@ -511,6 +317,78 @@ var BaseParam = class {
     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)
@@ -521,12 +399,12 @@ function validateParamsOrder(params) {
       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()
+var CommandOptionsSchema = z4.object({
+  name: z4.string().readonly(),
+  description: z4.string().min(1).max(100).optional().readonly(),
+  nsfw: z4.boolean().default(false).readonly(),
+  params: z4.array(z4.instanceof(BaseParam)).default([]).readonly(),
+  quotes: z4.boolean().default(true).readonly()
 }).transform((data) => ({
   ...data,
   description: data.description ?? `Command ${data.name}`
@@ -577,48 +455,54 @@ function defineCommand(options) {
   return new Command(options);
 }
 
-// src/base/client/BaseClientManager.ts
+// src/core/managers/BaseClientManager.ts
 var BaseClientManager = class {
   constructor(client) {
     this.client = client;
   }
 };
 
-// src/base/command/CommandManager.ts
+// src/core/managers/CommandManager.ts
 var CommandManager = class extends BaseClientManager {
   commands = new Collection();
   entries = new Collection();
   async loadModules(entryDir) {
     let pattern = posix.join(posix.resolve(entryDir), "commands", "**/*.{ts,js}"), files = await glob(pattern, { cwd: process.cwd() }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((c) => !!c);
-    return console.log(`[Loader] Loaded ${filtered.length}/${files.length}`), filtered;
+    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(path2) {
-    let command = await Module.import(path2, true);
+  async load(path) {
+    let command = await importModule(path, true);
     if (!command) {
-      console.warn(`[Loader] File has no default export: ${path2}`);
+      console.warn(`[Loader] File has no default export: ${path}`);
       return;
     }
     if (!(command instanceof Command)) {
-      console.warn(`[Loader] Default export is not a Command: ${path2}`);
+      console.warn(`[Loader] Default export is not a Command: ${path}`);
       return;
     }
-    return this.add(command), this.entries.set(path2, command), command;
+    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(path2) {
-    let command = this.entries.get(path2);
-    if (Module.isLoaded(path2) && (command ??= await Module.import(path2, true), Module.unload(path2)), this.entries.delete(path2), !!command)
+  async unload(path) {
+    let command = this.entries.get(path);
+    if (isModuleLoaded(path) && (command ??= await importModule(path, true), unloadModule(path)), this.entries.delete(path), !!command)
       return this.remove(command);
   }
+  async reload(path) {
+    await this.unload(path);
+    let command = await this.load(path);
+    if (command)
+      return console.log(`[Loader] Reloaded command '${command.options.name}' at '${path}'`), command;
+  }
   /**
    * Add a command to the registry.
    * @param command Command to add.
@@ -667,41 +551,57 @@ var ListenerOptionsSchema = z4.object({
 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 BaseClientManager {
   listeners = [];
   entries = new Collection();
   executors = /* @__PURE__ */ new WeakMap();
   async loadModules(entryDir) {
     let pattern = posix.join(posix.resolve(entryDir), "listeners", "**/*.{ts,js}"), files = await glob(pattern, { cwd: process.cwd() }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((l) => !!l);
-    return console.log(`[Loader] Loaded ${filtered.length}/${files.length}`), filtered;
+    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(path2) {
-    let listener = await Module.import(path2, true);
+  async load(path) {
+    let listener = await importModule(path, true);
     if (!listener) {
-      console.warn(`[Loader] File has no default export: ${path2}`);
+      console.warn(`[Loader] File has no default export: ${path}`);
       return;
     }
     if (!(listener instanceof Listener)) {
-      console.warn(`[Loader] Default export is not a Listener: ${path2}`);
+      console.warn(`[Loader] Default export is not a Listener: ${path}`);
       return;
     }
-    return this.add(listener), this.entries.set(path2, listener), listener;
+    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(path2) {
-    let listener = this.entries.get(path2);
-    if (Module.isLoaded(path2) && (listener ??= await Module.import(path2, true), Module.unload(path2)), this.entries.delete(path2), !!listener)
+  async unload(path) {
+    let listener = this.entries.get(path);
+    if (isModuleLoaded(path) && (listener ??= await importModule(path, true), unloadModule(path)), this.entries.delete(path), !!listener)
       return this.remove(listener)?.[0];
   }
+  async reload(path) {
+    await this.unload(path);
+    let listener = await this.load(path);
+    if (listener)
+      return console.log(`[Loader] Reloaded listener '${listener.options.name}' at '${path}'`), listener;
+  }
   /**
    * Add a listener to the registry and create a listener for client.
    * @param listener Listener to add.
@@ -750,8 +650,8 @@ var ListenerManager = class extends BaseClientManager {
   }
 };
 
-// src/base/client/BakitClient.ts
-var BakitClient2 = class extends Client {
+// src/core/client/BakitClient.ts
+var BakitClient = class extends Client {
   constructor(options, instance) {
     super(options);
     this.instance = instance;
@@ -793,73 +693,111 @@ var BakitClient2 = class extends Client {
     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),
-  user: createFactory(UserParam)
-};
-var DevProcessManager = class {
-  constructor(options) {
-    this.options = options;
-  }
-  child = null;
-  restartTimer = null;
-  start() {
-    console.log("Starting bakit in dev mode..."), this.startChild(), this.startWatcher();
-  }
-  startChild() {
-    if (this.child) return;
-    let entry = path.resolve(this.options.entry);
-    this.child = fork(entry, {
-      execArgv: ["--import", "tsx"],
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        NODE_ENV: "development"
-      }
-    }), this.child.on("exit", () => {
-      this.child = null;
-    });
+var BaseCommandContext = class extends Context {
+  constructor(source) {
+    super();
+    this.source = source;
   }
-  restartChild() {
-    if (!this.child)
-      return this.startChild();
-    let old = this.child;
-    old.once("exit", () => {
-      this.child = null, this.startChild();
-    }), old.kill("SIGTERM");
-  }
-  startWatcher() {
-    let { rootDir } = this.options;
-    chokidar.watch(rootDir, {
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 200,
-        pollInterval: 50
-      }
-    }).on("change", (file) => this.onFileChanged(file));
+  get client() {
+    return this.source.client;
   }
-  onFileChanged(file) {
-    if (!this.child)
-      return;
-    let top = Module.getTopLevel(file, this.options.rootDir);
-    if (top && this.options.hotDirs.includes(top)) {
-      this.child.connected && this.child.send({ type: `hmr:${top}`, file });
-      return;
-    }
-    this.scheduleRestart();
+  get channel() {
+    return this.source.channel;
   }
-  scheduleRestart() {
-    this.restartTimer && clearTimeout(this.restartTimer), this.restartTimer = setTimeout(() => {
-      console.log("Detected changes, restarting..."), this.restartChild(), this.restartTimer = null;
-    }, 150);
+  get channelId() {
+    return this.source.channelId;
+  }
+  get guild() {
+    return this.source.guild;
+  }
+  get guildId() {
+    return this.source.guildId;
+  }
+  get member() {
+    return this.source.member;
+  }
+  inGuild() {
+    return !!this.guildId;
+  }
+  inCachedGuild() {
+    if (this.isChatInput())
+      return this.source.inCachedGuild();
+    if (this.isMessage())
+      return this.source.inGuild();
+    throw new Error("Invalid source");
+  }
+  get user() {
+    if (this.isChatInput())
+      return this.source.user;
+    if (this.isMessage())
+      return this.source.author;
+    throw new Error("Invalid source");
+  }
+  isChatInput() {
+    return this.source instanceof ChatInputCommandInteraction;
+  }
+  isMessage() {
+    return this.source instanceof Message;
+  }
+}, ChatInputContext = class extends BaseCommandContext {
+  async send(options) {
+    typeof options == "string" && (options = { content: options });
+    let sendOptions = {
+      ...options,
+      withResponse: true
+    };
+    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
+  }
+}, MessageContext = class extends BaseCommandContext {
+  async send(options) {
+    let { channel } = this;
+    if (!channel?.isSendable())
+      throw new Error("Invalid channel or channel is not sendable");
+    return await channel.send(options);
   }
 };
+var ProjectConfigSchema = z4.object({
+  /**
+   * The gateway intents to use for the Discord client.
+   *
+   * - `auto` — automatically determine the required intents.
+   * - bigint — a raw bitfield value representing the combined intents.
+   * - array — a list of individual intent flags from `GatewayIntentBits`.
+   *
+   * @defaultvalue `auto`
+   */
+  intents: z4.union([z4.literal("auto"), z4.bigint(), z4.array(z4.enum(GatewayIntentBits))]).default("auto"),
+  /**
+   * Optional custom client options for Discord.js (excluding `intents`).
+   *
+   * These are passed directly to the `Client` constructor when initializing the bot.
+   *
+   * @see {@link https://discord.js.org/docs/packages/discord.js/main/ClientOptions:Interface}
+   */
+  clientOptions: z4.custom().optional(),
+  prefixes: z4.array(z4.string()).default([]),
+  token: z4.string()
+});
+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 importModule(configPath, true);
+  return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
+}
+function getConfig() {
+  if (!_config)
+    throw new Error("Project config is not loaded.");
+  return _config;
+}
 var messageCommandHandler = defineListener(Events.MessageCreate), chatInputCommandHandler = defineListener(Events.InteractionCreate), registerCommandsHandler = defineListener({
   name: Events.ClientReady,
   once: true
@@ -929,14 +867,14 @@ var ProjectCacheManager = class {
   getHash(data) {
     return createHash("sha256").update(JSON.stringify(data)).digest("hex");
   }
-  async write(path2, data) {
-    let fullPath = join(this.rootDir, path2), dir = dirname(fullPath);
+  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(path2) {
-    let fullPath = join(this.rootDir, path2);
+  async read(path) {
+    let fullPath = join(this.rootDir, path);
     try {
       let content = await readFile(fullPath, "utf-8");
       return JSON.parse(content);
@@ -952,7 +890,7 @@ var ProjectCacheManager = class {
   }
 };
 
-// src/base/process/Instance.ts
+// src/core/internal/Instance.ts
 var Instance = class {
   client;
   cache;
@@ -962,7 +900,7 @@ var Instance = class {
   async start() {
     await loadConfig();
     let config = getConfig();
-    this.client = new BakitClient2(
+    this.client = new BakitClient(
       {
         intents: [],
         ...config.clientOptions
@@ -989,10 +927,10 @@ var Instance = class {
     let target = type.split(":")[1], { listeners, commands } = this.client.managers;
     switch (target) {
       case "listeners":
-        listeners.unload(file), await listeners.load(file);
+        await listeners.reload(file);
         break;
       case "commands":
-        commands.unload(file), await listeners.load(file);
+        await commands.reload(file);
         break;
     }
   }
@@ -1001,4 +939,14 @@ function useApp() {
   return new Instance();
 }
 
-export { ArgumentError, BakitClient2 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, DevProcessManager, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, Module, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectCacheManager, ProjectConfigSchema, StringParam, StringParamSchema, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+// 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, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectCacheManager, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineListener, extractSnowflakeId, getTopLevelDirectory, importModule, isModuleLoaded, messageCommandHandler, registerCommandsHandler, tokenize, unloadModule, useApp, validateParamsOrder };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.14",
+	"version": "2.0.0-alpha.16",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",
@@ -11,7 +11,7 @@
 		"test": "vitest run --pass-with-no-tests"
 	},
 	"bin": {
-		"bakit": "./dist/bin/bakit.js"
+		"bakit": "./dist/cli.js"
 	},
 	"files": [
 		"dist"
@@ -41,7 +41,6 @@
 		"commander": "^14.0.2",
 		"dotenv": "^17.2.1",
 		"jiti": "^2.6.1",
-		"nodemon": "^3.1.11",
 		"tiny-glob": "^0.2.9",
 		"type-fest": "^4.41.0",
 		"zod": "^4.1.12"