bakit 2.0.0-alpha.27 → 2.0.0-alpha.29

package/dist/cli.js

@@ -1,11 +1,12 @@
+#!/usr/bin/env node
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
 import { config } from 'dotenv';
 import { program } from 'commander';
 import { fork } from 'child_process';
-import path, { resolve } from 'path';
 import chokidar from 'chokidar';
-import { RPC } from 'bakit';
+import { loadConfig, RPC } from 'bakit';
 
-// src/cli/bin.ts
 var DevProcessManager = class {
   constructor(options) {
     this.options = options;
@@ -18,12 +19,13 @@ var DevProcessManager = class {
   startChild() {
     if (this.rpc)
       return;
-    let entry = path.resolve(this.options.entry), child = fork(entry, {
+    let { entryFile } = this.options, child = fork(this.options.entryFile, {
       execArgv: ["--import", "bakit/register"],
       stdio: "inherit",
       env: {
         ...process.env,
-        NODE_ENV: "development"
+        NODE_ENV: "development",
+        BAKIT_ENTRY_FILE: entryFile
       }
     });
     this.rpc = new RPC(child), this.rpc.on("restart", (fileUpdated) => this.scheduleRestart(fileUpdated));
@@ -37,18 +39,18 @@ var DevProcessManager = class {
     }), child.kill("SIGTERM");
   }
   startWatcher() {
-    let { rootDir } = this.options, watcher = chokidar.watch(rootDir, {
+    let { entryDirectory } = this.options, watcher = chokidar.watch(entryDirectory, {
       ignoreInitial: true,
       awaitWriteFinish: {
         stabilityThreshold: 200,
         pollInterval: 50
       }
     });
-    watcher.on("change", (path2) => this.onFileUpdate("fileChange", path2)), watcher.on("unlink", (path2) => this.onFileUpdate("fileRemove", path2));
+    watcher.on("change", (path) => this.onFileUpdate("fileChange", path)), watcher.on("unlink", (path) => this.onFileUpdate("fileRemove", path));
   }
-  onFileUpdate(type, path2) {
+  onFileUpdate(type, path) {
     try {
-      this.rpc?.send(type, resolve(path2));
+      this.rpc?.send(type, resolve(path));
     } catch {
       this.scheduleRestart(true);
     }
@@ -59,14 +61,17 @@ var DevProcessManager = class {
     }, 150);
   }
 };
-
-// src/cli/bin.ts
 program.name("bakit");
-program.command("dev").action(() => {
-  config({ path: [".env.local", ".env"], quiet: true }), new DevProcessManager({
-    rootDir: "src",
-    entry: "src/index.ts",
-    hotDirs: ["commands", "listeners"]
+program.command("dev").action(async () => {
+  config({ path: [".env.local", ".env"], quiet: true });
+  let config$1 = await loadConfig(), entryDirectory = resolve(config$1.entryDirectory);
+  new DevProcessManager({
+    entryFile: getEntryFile(entryDirectory),
+    entryDirectory
   }).start();
 });
+function getEntryFile(entryDirectory) {
+  let index = join(entryDirectory, "index");
+  return existsSync(index + ".ts") ? index : index + ".js";
+}
 program.parse();

package/dist/index.d.ts

@@ -258,15 +258,21 @@ declare function defineCommand<const ParamsList extends readonly AnyParam<any>[]
     params?: ParamsList;
 }) | string): Command<ParamsList>;
 
-declare class BaseClientManager {
-    client: BakitClient;
-    constructor(client: BakitClient);
+declare abstract class HotReloadable {
+    entryDirectory: string;
+    constructor(entryDirectory: string);
+    abstract unload(path: string): Promise<unknown>;
+    abstract load(path: string): Promise<unknown>;
+    abstract reload(path: string): Promise<unknown>;
+    protected unloadFile(path: string): Promise<boolean>;
 }
 
-declare class CommandManager extends BaseClientManager {
+declare class CommandManager extends HotReloadable {
+    client: BakitClient;
     commands: Collection<string, Command<any[]>>;
     entries: Collection<string, Command<any[]>>;
-    loadModules(entryDir: string): Promise<Command[]>;
+    constructor(client: BakitClient);
+    loadModules(): Promise<Command[]>;
     /**
      * Load the file and add the command to the registry.
      * @param path The path to the command file.
@@ -315,11 +321,13 @@ declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<C
 }
 declare function defineListener<const K extends EventKey = EventKey>(options: K | ListenerOptions<K>): Listener<K>;
 
-declare class ListenerManager extends BaseClientManager {
+declare class ListenerManager extends HotReloadable {
+    client: BakitClient;
     listeners: Listener[];
     entries: Collection<string, Listener<keyof BakitClientEvents>>;
     private executors;
-    loadModules(entryDir: string): Promise<Listener[]>;
+    constructor(client: BakitClient);
+    loadModules(): Promise<Listener[]>;
     /**
      * Load the file and add the listener to the registry.
      * @param path The path to the listener file.
@@ -370,20 +378,12 @@ declare class ProjectCacheManager {
 declare class Instance {
     client: BakitClient;
     cache: ProjectCacheManager;
-    private rpc;
     constructor();
     start(): Promise<void>;
     private initProcess;
     private loadModules;
     private initIntents;
-    private isInHotDirectory;
-    private restart;
     shutdown(): Promise<void>;
-    private containsEntryPoint;
-    private containsHotModule;
-    private onFileRemove;
-    private onFileChange;
-    private unloadModule;
 }
 declare function useApp(): Instance;
 
@@ -416,6 +416,11 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     [inspect.custom](): string;
 }
 
+declare class BaseClientManager {
+    client: BakitClient;
+    constructor(client: BakitClient);
+}
+
 declare const Params: {
     readonly string: <Required extends boolean = true>(options: string | {
         name: string;
@@ -459,14 +464,74 @@ declare function tokenize(content: string): string[];
 declare function extractSnowflakeId(input: string): string | null;
 
 declare function getTopLevelDirectory(path: string, entryDir: string): string | null;
+declare function getEntryDirectory(): string;
+declare function getEntryFile(): string;
 
-declare function $initLoader(): void;
-declare function $unloadFile(path: string): Promise<boolean>;
-declare function getImporters(path: string, createNew: true): Set<string>;
+declare const hotReloaders: Collection<string, HotReloadable>;
+/**
+ * Initliazie the loader
+ */
+declare function init(): void;
+/**
+ * Register a reloader for HMR.
+ * @param reloader Reloader extended from HotReloadable.
+ */
+declare function addHotReloader(reloader: HotReloadable): void;
+/**
+ * Remove the previous version of the file.
+ * @param path Path to unload.
+ * @returns `true` for unloaded successfully, `false` for unload failed.
+ */
+declare function unload(path: string): Promise<boolean>;
+/**
+ * Get a list of the files which imported the target.
+ * @param path Target file path to get.
+ * @param createNew Create a new Set cache for the target path.
+ */
 declare function getImporters(path: string, createNew?: false): Set<string> | undefined;
+declare function getImporters(path: string, createNew: true): Set<string>;
+/**
+ * Get a list of the files which imported the target.
+ * @param path Target file path to get.
+ * @param createNew Create a new Set cache for the target path.
+ */
+declare function getImports(path: string): string[];
+/**
+ * Get a chain of dependencies for affected files.
+ * @param path
+ * @returns An array of affected dependencies.
+ */
 declare function getDependencyChain(path: string): string[];
+/**
+ * Checks if the target file imports any of the files in the 'targets' set.
+ * @param path The file path to check.
+ * @param targets The list of the files to check.
+ */
+declare function importsAny(path: string, targets: Set<string>): boolean;
 declare function isImported(path: string): boolean;
 declare function isImportedBy(path: string, matcher: string | RegExp | ((path: string) => boolean)): boolean;
+declare function isInHotDirectory(path: string): boolean;
+declare function isEntryFile(path: string): boolean;
+declare function containsEntryFile(chain: string[]): boolean;
+declare function containsHotModule(chain: string[]): boolean;
+
+declare const loader_addHotReloader: typeof addHotReloader;
+declare const loader_containsEntryFile: typeof containsEntryFile;
+declare const loader_containsHotModule: typeof containsHotModule;
+declare const loader_getDependencyChain: typeof getDependencyChain;
+declare const loader_getImporters: typeof getImporters;
+declare const loader_getImports: typeof getImports;
+declare const loader_hotReloaders: typeof hotReloaders;
+declare const loader_importsAny: typeof importsAny;
+declare const loader_init: typeof init;
+declare const loader_isEntryFile: typeof isEntryFile;
+declare const loader_isImported: typeof isImported;
+declare const loader_isImportedBy: typeof isImportedBy;
+declare const loader_isInHotDirectory: typeof isInHotDirectory;
+declare const loader_unload: typeof unload;
+declare namespace loader {
+  export { loader_addHotReloader as addHotReloader, loader_containsEntryFile as containsEntryFile, loader_containsHotModule as containsHotModule, loader_getDependencyChain as getDependencyChain, loader_getImporters as getImporters, loader_getImports as getImports, loader_hotReloaders as hotReloaders, loader_importsAny as importsAny, loader_init as init, loader_isEntryFile as isEntryFile, loader_isImported as isImported, loader_isImportedBy as isImportedBy, loader_isInHotDirectory as isInHotDirectory, loader_unload as unload };
+}
 
 declare const RPC_RESPONSE_MARK = "$DONE:";
 declare const RPC_RESPONSE_TIMEOUT = 5000;
@@ -501,7 +566,7 @@ declare class RPC extends EventEmitter {
     private onMessage;
     private handleResponseMessage;
     private handleRequestMessage;
-    send<Data extends Serializable>(type: string, data: Data, id?: string): void;
+    send<Data extends Serializable>(type: string, data?: Data, id?: string): void;
     success<Data extends Serializable>(id: string, data: Data): void;
     error(id: string, error: string): void;
     request<Data extends Serializable, Output extends Serializable>(type: string, data: Data, id?: string): Promise<Output>;
@@ -516,6 +581,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
     clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
     prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
     token: z.ZodString;
+    entryDirectory: z.ZodDefault<z.ZodString>;
 }, z.z.core.$strip>;
 type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
 type ProjectConfig = z.output<typeof ProjectConfigSchema>;
@@ -569,4 +635,4 @@ interface LoadResult {
 type NextResolve = (specifier: string, context: ResolveContext) => Promise<ResolveResult>;
 type NextLoad = (url: string, context: LoadContext) => Promise<LoadResult>;
 
-export { $initLoader, $unloadFile, type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, type BaseRPCMessage, type BaseRPCResponse, 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, type InitializeData, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type LoadContext, type LoadResult, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NextLoad, type NextResolve, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, RPC, type RPCErrorResponse, type RPCMessage, type RPCPendingPromise, type RPCRequest, type RPCResponse, type RPCSuccessResponse, RPC_RESPONSE_MARK, RPC_RESPONSE_TIMEOUT, type ResolveContext, type ResolveResult, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getDependencyChain, getImporters, getTopLevelDirectory, isImported, isImportedBy, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };
+export { type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, type BaseRPCMessage, type BaseRPCResponse, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, HotReloadable, type InferParamTuple, type InferParamValue, type InitializeData, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type LoadContext, type LoadResult, loader as Loader, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NextLoad, type NextResolve, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, RPC, type RPCErrorResponse, type RPCMessage, type RPCPendingPromise, type RPCRequest, type RPCResponse, type RPCSuccessResponse, RPC_RESPONSE_MARK, RPC_RESPONSE_TIMEOUT, type ResolveContext, type ResolveResult, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getEntryDirectory, getEntryFile, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };

package/dist/index.js

@@ -1,9 +1,9 @@
-import { GatewayIntentBits, Events, Client, Collection, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
+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 { resolve, posix, relative, sep, join, dirname } from 'path';
+import { join, resolve, relative, sep, dirname } from 'path';
 import glob from 'tiny-glob';
-import z4 from 'zod';
+import z2 from 'zod';
 import { register } from 'module';
 import { MessageChannel } from 'worker_threads';
 import { randomUUID, createHash } from 'crypto';
@@ -11,17 +11,21 @@ import EventEmitter from 'events';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import { mkdir, writeFile, readFile, rm } from 'fs/promises';
 
-// 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)
+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: z4.number().min(1).optional(),
-  minLength: z4.number().min(1).optional()
+  maxLength: z2.number().min(1).optional(),
+  minLength: z2.number().min(1).optional()
 }), NumberParamSchema = BaseParamSchema.extend({
-  maxValue: z4.number().optional(),
-  minValue: z4.number().optional()
+  maxValue: z2.number().optional(),
+  minValue: z2.number().optional()
 }), UserParamSchema = BaseParamSchema.extend({});
 var INTENT_GROUPS = {
   [GatewayIntentBits.Guilds]: [
@@ -162,9 +166,90 @@ function extractSnowflakeId(input) {
   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,
+  unload: () => unload
+});
 var RPC_RESPONSE_MARK = "$DONE:", RPC_RESPONSE_TIMEOUT = 5e3, RPC = class extends EventEmitter {
   constructor(transport) {
     super();
@@ -190,13 +275,13 @@ var RPC_RESPONSE_MARK = "$DONE:", RPC_RESPONSE_TIMEOUT = 5e3, RPC = class extend
     let id = message.id.slice(RPC_RESPONSE_MARK.length), request = this.requests.get(id);
     if (!request)
       return;
-    let { reject, resolve: resolve5, timeout } = request;
-    this.requests.delete(id), clearTimeout(timeout), "data" in message ? resolve5(message.data) : reject(new Error(message.error));
+    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()) {
+  send(type, data = {}, id = randomUUID()) {
     let message = {
       id,
       type,
@@ -219,38 +304,52 @@ var RPC_RESPONSE_MARK = "$DONE:", RPC_RESPONSE_TIMEOUT = 5e3, RPC = class extend
     this.postMessage(message);
   }
   request(type, data, id = randomUUID()) {
-    return new Promise((resolve5, reject) => {
+    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: resolve5,
+        resolve: resolve6,
         reject,
         timeout
       }), this.send(type, data, id);
     });
   }
 };
-
-// src/lib/loader/loader.ts
-var rpc, reverseDependencyGraph = /* @__PURE__ */ new Map();
-function $initLoader() {
+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]
-  }), rpc = new RPC(port2), rpc.on("dependencyAdd", (_id, data) => onDependencyAdd(data)), port2.unref();
+  }), hooksRPC = new RPC(port2), hooksRPC.on("dependencyAdd", (_, data) => onDependencyAdd(data)), port2.unref();
 }
-function $unloadFile(path) {
-  if (!rpc)
+function addHotReloader(reloader) {
+  hotReloaders.set(reloader.entryDirectory, reloader);
+}
+function unload(path) {
+  if (!hooksRPC)
     throw new Error("Loader isn't initialized");
-  return rpc.request("unload", resolve(path));
+  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();
@@ -259,12 +358,19 @@ function getDependencyChain(path) {
     if (!current || visited.has(current) || (visited.add(current), current.includes("/node_modules/")))
       continue;
     let parents = getImporters(current);
-    if (parents)
-      for (let parent of parents)
-        visited.has(parent) || queue.push(parent);
+    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;
 }
@@ -275,8 +381,72 @@ function isImportedBy(path, matcher) {
   });
 }
 function onDependencyAdd(data) {
-  let { url, parentURL } = data, path = fileURLToPath(url), parentPath = fileURLToPath(parentURL), entry = reverseDependencyGraph.get(path);
-  entry || (entry = /* @__PURE__ */ new Set(), reverseDependencyGraph.set(path, entry)), entry.add(parentPath);
+  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);
+  return !!topLevelDir && hotReloaders.some((m) => m.entryDirectory === topLevelDir);
+}
+function isEntryFile(path) {
+  return path === getEntryFile();
+}
+function containsEntryFile(chain) {
+  return chain.some((x) => isEntryFile(x));
+}
+function containsHotModule(chain) {
+  return chain.some((x) => isInHotDirectory(x));
+}
+function restartProcess() {
+  processRPC?.send("restart");
+}
+async function unloadModule(path, reload = false) {
+  let topLevel = getTopLevelDirectory(path, getEntryFile());
+  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
@@ -498,12 +668,12 @@ function validateParamsOrder(params) {
       seenOptional = true;
   return true;
 }
-var CommandOptionsSchema = z4.object({
-  name: z4.string().readonly(),
-  description: z4.string().min(1).max(100).optional().readonly(),
-  nsfw: z4.boolean().default(false).readonly(),
-  params: z4.array(z4.instanceof(BaseParam)).default([]).readonly(),
-  quotes: z4.boolean().default(true).readonly()
+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}`
@@ -553,20 +723,26 @@ var CommandOptionsSchema = z4.object({
 function defineCommand(options) {
   return new Command(options);
 }
-
-// src/core/managers/BaseClientManager.ts
-var BaseClientManager = class {
-  constructor(client) {
-    this.client = client;
+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 BaseClientManager {
+var CommandManager = class extends HotReloadable2 {
+  constructor(client) {
+    super(join(getEntryDirectory(), "commands"));
+    this.client = client;
+  }
   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(), absolute: true }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((c) => !!c);
+  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;
   }
   /**
@@ -595,7 +771,7 @@ var CommandManager = class extends BaseClientManager {
   async unload(path) {
     path = resolve(path);
     let command = this.entries.get(path);
-    if (this.entries.delete(path), await $unloadFile(path), !!command)
+    if (this.entries.delete(path), await this.unloadFile(path), !!command)
       return this.remove(command);
   }
   async reload(path) {
@@ -639,9 +815,9 @@ var CommandManager = class extends BaseClientManager {
     return this.commands.get(name);
   }
 };
-var ListenerOptionsSchema = z4.object({
-  name: z4.enum(Events),
-  once: z4.boolean().default(false)
+var ListenerOptionsSchema = z2.object({
+  name: z2.enum(Events),
+  once: z2.boolean().default(false)
 }), Listener = class extends LifecycleManager {
   options;
   constructor(options) {
@@ -662,12 +838,16 @@ var Context = class {
 };
 
 // src/core/managers/ListenerManager.ts
-var ListenerManager = class extends BaseClientManager {
+var ListenerManager = class extends HotReloadable2 {
+  constructor(client) {
+    super(join(getEntryDirectory(), "listeners"));
+    this.client = client;
+  }
   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(), absolute: true }), filtered = (await Promise.all(files.map((file) => this.load(file)))).filter((l) => !!l);
+  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;
   }
   /**
@@ -696,7 +876,7 @@ var ListenerManager = class extends BaseClientManager {
   async unload(path) {
     path = resolve(path);
     let listener = this.entries.get(path);
-    if (this.entries.delete(path), await $unloadFile(path), !!listener)
+    if (this.entries.delete(path), await this.unloadFile(path), !!listener)
       return this.remove(listener)?.[0];
   }
   async reload(path) {
@@ -796,6 +976,13 @@ var BakitClient = class extends Client {
     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();
@@ -859,57 +1046,6 @@ var BaseCommandContext = class extends Context {
     return await channel.send(options);
   }
 };
-var CONFIG_EXTENSIONS = ["ts", "js"], 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(),
-  /**
-   * Your bot prefixes to trigger the commands.
-   */
-  prefixes: z4.array(z4.string()).default([]),
-  /**
-   * Your Discord bot token.
-   */
-  token: z4.string()
-});
-function defineConfig(config) {
-  return config;
-}
-var _config;
-async function loadConfig(cwd = process.cwd()) {
-  if (_config)
-    return console.warn("loadConfig() was called more than once. This shouldn't happen."), _config;
-  let globPattern = `bakit.config.{${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;
-}
 var ProjectCacheManager = class {
   rootDir;
   constructor(root = process.cwd()) {
@@ -1003,12 +1139,11 @@ chatInputCommandHandler.main(async (_, interaction) => {
 });
 
 // src/core/internal/Instance.ts
-var HOT_DIRECTORIES = ["listeners", "commands"], SOURCE_ROOT = resolve(process.cwd(), "src"), APP_ENTRY_POINTS = /* @__PURE__ */ new Set([resolve(SOURCE_ROOT, "index.ts"), resolve(SOURCE_ROOT, "index.js")]), Instance = class {
+var Instance = class {
   client;
   cache;
-  rpc;
   constructor() {
-    this.cache = new ProjectCacheManager(), this.rpc = new RPC(process);
+    this.cache = new ProjectCacheManager();
   }
   async start() {
     await loadConfig();
@@ -1022,80 +1157,19 @@ var HOT_DIRECTORIES = ["listeners", "commands"], SOURCE_ROOT = resolve(process.c
     ), await this.loadModules(), this.initIntents(), await this.client.login(config.token), this.initProcess();
   }
   initProcess() {
-    process.env.NODE_ENV === "development" && (this.rpc.on("fileRemove", (_id, path) => this.onFileRemove(path)), this.rpc.on("fileChange", (_id, path) => this.onFileChange(path))), process.on("SIGINT", () => this.shutdown()), process.on("SIGTERM", () => this.shutdown());
+    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), Promise.all([commands.loadModules("src"), listeners.loadModules("src")]);
+    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;
   }
-  isInHotDirectory(path) {
-    if (!path.startsWith(SOURCE_ROOT))
-      return false;
-    let topLevelDir = getTopLevelDirectory(path, SOURCE_ROOT);
-    return !!topLevelDir && HOT_DIRECTORIES.includes(topLevelDir);
-  }
-  restart() {
-    this.rpc.send("restart", {});
-  }
   async shutdown() {
     this.client && await this.client.destroy().catch(() => null), process.exit(0);
   }
-  containsEntryPoint(chain) {
-    return chain.some((x) => APP_ENTRY_POINTS.has(x));
-  }
-  containsHotModule(chain) {
-    return chain.some((x) => this.isInHotDirectory(x));
-  }
-  async onFileRemove(path) {
-    if (APP_ENTRY_POINTS.has(path)) {
-      this.restart();
-      return;
-    }
-    if (!isImported(path))
-      return;
-    let chain = getDependencyChain(path);
-    if (this.containsEntryPoint(chain)) {
-      this.restart();
-      return;
-    }
-    if (this.containsHotModule(chain))
-      for (let path2 of chain.reverse())
-        await this.unloadModule(path2);
-  }
-  async onFileChange(path) {
-    if (APP_ENTRY_POINTS.has(path)) {
-      this.restart();
-      return;
-    }
-    if (!isImported(path))
-      return;
-    let chain = getDependencyChain(path);
-    if (this.containsEntryPoint(chain)) {
-      this.restart();
-      return;
-    }
-    if (this.containsHotModule(chain))
-      for (let path2 of chain.reverse())
-        await this.unloadModule(path2, true);
-  }
-  async unloadModule(path, reload = false) {
-    let { listeners, commands } = this.client.managers;
-    switch (getTopLevelDirectory(path, SOURCE_ROOT)) {
-      case "listeners":
-        await listeners[reload ? "reload" : "unload"](path);
-        break;
-      case "commands":
-        await commands[reload ? "reload" : "unload"](path);
-        break;
-      default:
-        await $unloadFile(path);
-        break;
-    }
-  }
 };
 function useApp() {
   return new Instance();
@@ -1111,4 +1185,4 @@ var Params = {
   user: createFactory(UserParam)
 };
 
-export { $initLoader, $unloadFile, ArgumentError, BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectCacheManager, ProjectConfigSchema, RPC, RPC_RESPONSE_MARK, RPC_RESPONSE_TIMEOUT, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getDependencyChain, getImporters, getTopLevelDirectory, isImported, isImportedBy, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };
+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 };

package/dist/register.js

@@ -1,4 +1,4 @@
-import { $initLoader } from 'bakit';
+import { Loader } from 'bakit';
 
 // src/lib/loader/register.ts
-$initLoader();
+Loader.init();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.27",
+	"version": "2.0.0-alpha.29",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {