bakit 2.0.0-alpha.24 → 2.0.0-alpha.26

package/dist/cli.js

@@ -1,71 +1,61 @@
 import { config } from 'dotenv';
 import { program } from 'commander';
 import { fork } from 'child_process';
-import path, { resolve, relative, sep } from 'path';
+import path, { resolve } from 'path';
 import chokidar from 'chokidar';
+import { RPC } from 'bakit';
 
 // src/cli/bin.ts
-function getTopLevelDirectory(path2, entryDir) {
-  return relative(entryDir, path2).split(sep)[0] ?? null;
-}
-
-// src/cli/process/DevProcessManager.ts
 var DevProcessManager = class {
   constructor(options) {
     this.options = options;
   }
-  child = null;
+  rpc = 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, {
+    if (this.rpc)
+      return;
+    let entry = path.resolve(this.options.entry), child = fork(entry, {
       execArgv: ["--import", "bakit/register"],
       stdio: "inherit",
       env: {
         ...process.env,
         NODE_ENV: "development"
       }
-    }), this.child.on("exit", () => {
-      this.child = null;
     });
+    this.rpc = new RPC(child), this.rpc.on("restart", (fileUpdated) => this.scheduleRestart(fileUpdated));
   }
   restartChild() {
-    if (!this.child)
+    if (!this.rpc)
       return this.startChild();
-    let old = this.child;
-    old.once("exit", () => {
-      this.child = null, this.startChild();
-    }), old.kill("SIGTERM");
+    let child = this.rpc.transport;
+    child.once("exit", () => {
+      this.rpc = null, this.startChild();
+    }), child.kill("SIGTERM");
   }
   startWatcher() {
-    let { rootDir } = this.options;
-    chokidar.watch(rootDir, {
+    let { rootDir } = this.options, watcher = chokidar.watch(rootDir, {
       ignoreInitial: true,
       awaitWriteFinish: {
         stabilityThreshold: 200,
         pollInterval: 50
       }
-    }).on("change", (path2) => {
-      this.onFileChanged(path2);
     });
+    watcher.on("change", (path2) => this.onFileUpdate("fileChange", path2)), watcher.on("unlink", (path2) => this.onFileUpdate("fileRemove", path2));
   }
-  onFileChanged(path2) {
-    if (!this.child)
-      return;
-    let top = getTopLevelDirectory(path2, this.options.rootDir);
-    if (top && this.options.hotDirs.includes(top)) {
-      this.child.connected && this.child.send({ type: `hmr:${top}`, path: resolve(path2) });
-      return;
+  onFileUpdate(type, path2) {
+    try {
+      this.rpc?.send(type, resolve(path2));
+    } catch {
+      this.scheduleRestart(true);
     }
-    this.scheduleRestart();
   }
-  scheduleRestart() {
+  scheduleRestart(fileUpdated = false) {
     this.restartTimer && clearTimeout(this.restartTimer), this.restartTimer = setTimeout(() => {
-      console.log("Detected changes, restarting..."), this.restartChild(), this.restartTimer = null;
+      fileUpdated && console.log("File changes detected, restarting..."), this.restartChild(), this.restartTimer = null;
     }, 150);
   }
 };

package/dist/hooks.js

@@ -3,14 +3,15 @@ import { readFile } from 'fs/promises';
 import { Module } from 'module';
 import { dirname, resolve as resolve$1, basename } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { RPC } from 'bakit';
 
 // src/lib/loader/hooks.ts
-var EXTENSIONS = [".js", ".ts"], parentPort, versions, esbuild;
+var EXTENSIONS = [".js", ".ts"], rpc, versions, esbuild;
 function isDevelopment() {
   return process.env.NODE_ENV === "development";
 }
 async function initialize({ port }) {
-  isDevelopment() && (parentPort = port, parentPort.on("message", onMessage), versions = /* @__PURE__ */ new Map(), esbuild = await import('esbuild'));
+  rpc = new RPC(port), versions = /* @__PURE__ */ new Map(), rpc.on("message", onUnload), isDevelopment() && (esbuild = await import('esbuild'));
 }
 async function resolve(specifier, context, nextResolve) {
   if (shouldSkip(specifier))
@@ -27,10 +28,9 @@ async function resolve(specifier, context, nextResolve) {
   let urlObj = new URL(url);
   if (isDevelopment()) {
     let filePath = fileURLToPath(urlObj), version = createVersion(filePath);
-    urlObj.searchParams.set("hmr", version), parentURL && parentPort && parentPort.postMessage({
-      type: "dependency",
-      parent: parentURL,
-      child: url
+    urlObj.searchParams.set("hmr", version), parentURL && rpc.send("dependencyAdd", {
+      parentURL,
+      url
     });
   }
   return {
@@ -62,8 +62,8 @@ async function load(url, context, nextLoad) {
   return nextLoad(url, context);
 }
 function createVersion(filename) {
-  let version = versions?.get(filename);
-  return version || (version = Date.now().toString(), versions?.set(filename, version)), version;
+  let version = versions.get(filename);
+  return version || (version = Date.now().toString(), versions.set(filename, version)), version;
 }
 function shouldSkip(specifier) {
   if (Module.isBuiltin(specifier) || specifier.includes("/node_modules/"))
@@ -74,19 +74,9 @@ function shouldSkip(specifier) {
   }
   return true;
 }
-function onMessage(message) {
-  let { type, data, id } = message;
-  if (type !== "unload") {
-    parentPort?.postMessage({
-      id,
-      data: false
-    });
-    return;
-  }
-  versions?.delete(data), parentPort?.postMessage({
-    id,
-    data: true
-  });
+function onUnload(id, path) {
+  let deleted = versions.delete(resolve$1(path));
+  rpc.success(id, deleted);
 }
 
 export { initialize, load, resolve };

package/dist/index.d.ts

@@ -2,6 +2,9 @@ import * as discord_js from 'discord.js';
 import { ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client, ClientOptions, GatewayIntentBits } from 'discord.js';
 import { inspect } from 'node:util';
 import z from 'zod';
+import EventEmitter from 'node:events';
+import { Serializable, ChildProcess } from 'node:child_process';
+import { MessagePort as MessagePort$1 } from 'node:worker_threads';
 
 declare enum ParamUserType {
     Bot = "bot",
@@ -367,12 +370,20 @@ declare class ProjectCacheManager {
 declare class Instance {
     client: BakitClient;
     cache: ProjectCacheManager;
+    private rpc;
     constructor();
     start(): Promise<void>;
     private initProcess;
     private loadModules;
     private initIntents;
-    private onProcessMessage;
+    private isInHotDirectory;
+    private restart;
+    shutdown(): Promise<void>;
+    private containsEntryPoint;
+    private containsHotModule;
+    private onFileRemove;
+    private onFileChange;
+    private unloadModule;
 }
 declare function useApp(): Instance;
 
@@ -449,20 +460,52 @@ declare function extractSnowflakeId(input: string): string | null;
 
 declare function getTopLevelDirectory(path: string, entryDir: string): string | null;
 
-interface PostMessage<Data> {
-    id: number;
+declare function $initLoader(): void;
+declare function $unloadFile(path: string): Promise<boolean>;
+declare function getImporters(path: string, createNew: true): Set<string>;
+declare function getImporters(path: string, createNew?: false): Set<string> | undefined;
+declare function getDependencyChain(path: string): string[];
+declare function isImported(path: string): boolean;
+declare function isImportedBy(path: string, matcher: string | RegExp | ((path: string) => boolean)): boolean;
+
+declare const RPC_RESPONSE_MARK = "$DONE:";
+declare const RPC_RESPONSE_TIMEOUT = 5000;
+interface BaseRPCMessage {
+    id: string;
+}
+interface BaseRPCResponse {
+    id: `${typeof RPC_RESPONSE_MARK}${string}`;
+}
+interface RPCRequest<Data extends Serializable = Serializable> extends BaseRPCMessage {
     type: string;
     data: Data;
 }
-interface ResponseMessage<Data> {
-    id: number;
-    error?: string;
-    data?: Data;
+interface RPCSuccessResponse<Data extends Serializable = Serializable> extends BaseRPCResponse {
+    data: Data;
+}
+interface RPCErrorResponse extends BaseRPCResponse {
+    error: string;
+}
+type RPCResponse<Data extends Serializable = Serializable> = RPCSuccessResponse<Data> | RPCErrorResponse;
+type RPCMessage<Data extends Serializable = Serializable> = RPCRequest<Data> | RPCResponse<Data>;
+interface RPCPendingPromise {
+    resolve: (data: any) => void;
+    reject: (error: unknown) => void;
+    timeout: NodeJS.Timeout;
+}
+declare class RPC extends EventEmitter {
+    transport: MessagePort$1 | NodeJS.Process | ChildProcess;
+    requests: Map<string, RPCPendingPromise>;
+    constructor(transport: MessagePort$1 | NodeJS.Process | ChildProcess);
+    postMessage(message: Serializable): void;
+    private onMessage;
+    private handleResponseMessage;
+    private handleRequestMessage;
+    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>;
 }
-declare function $initLoader(): void;
-declare function $postLoaderMessage<Data>(type: string, data: Data, wait?: false): void;
-declare function $postLoaderMessage<Data, Output = unknown>(type: string, data: Data, wait: true): Promise<Output>;
-declare function $unloadFile(path: string): Promise<boolean>;
 
 declare const messageCommandHandler: Listener<Events.MessageCreate>;
 declare const chatInputCommandHandler: Listener<Events.InteractionCreate>;
@@ -494,4 +537,36 @@ declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
  */
 declare function getConfig(): ProjectConfig;
 
-export { $initLoader, $postLoaderMessage, $unloadFile, 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, type PostMessage, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type ResponseMessage, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };
+interface InitializeData {
+	port: MessagePort;
+}
+
+interface ResolveContext {
+	conditions: string[];
+	importAttributes: Record<string, string>;
+	parentURL?: string;
+}
+
+interface ResolveResult {
+	url: string;
+	shortCircuit?: boolean;
+	format?: string | null | undefined;
+	importAttributes?: Record<string, string>;
+}
+
+interface LoadContext {
+	conditions: string[];
+	format: string | null | undefined;
+	importAttributes: Record<string, string>;
+}
+
+interface LoadResult {
+	source: string | ArrayBuffer | Uint8Array;
+	format: string;
+	shortCircuit?: boolean;
+}
+
+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 };

package/dist/index.js

@@ -1,14 +1,15 @@
 import { GatewayIntentBits, Events, Client, Collection, IntentsBitField, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
 import { inspect } from 'util';
-import { posix, resolve, relative, sep, join, dirname } from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { resolve, posix, relative, sep, join, dirname } from 'path';
 import glob from 'tiny-glob';
 import z4 from 'zod';
 import { register } from 'module';
 import { MessageChannel } from 'worker_threads';
-import { pathToFileURL } from 'url';
+import { randomUUID, createHash } from 'crypto';
+import EventEmitter from 'events';
 import { existsSync, mkdirSync, rmSync } from 'fs';
 import { mkdir, writeFile, readFile, rm } from 'fs/promises';
-import { createHash } from 'crypto';
 
 // src/core/client/BakitClient.ts
 var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z4.object({
@@ -164,34 +165,118 @@ function extractSnowflakeId(input) {
 function getTopLevelDirectory(path, entryDir) {
   return relative(entryDir, path).split(sep)[0] ?? null;
 }
-var port1, port2, messageId = 0, pending = /* @__PURE__ */ new Map();
+var RPC_RESPONSE_MARK = "$DONE:", RPC_RESPONSE_TIMEOUT = 5e3, RPC = class extends EventEmitter {
+  constructor(transport) {
+    super();
+    this.transport = transport;
+    this.transport.on("message", (message) => this.onMessage(message));
+  }
+  requests = /* @__PURE__ */ new Map();
+  postMessage(message) {
+    let { transport } = this;
+    "send" in transport ? transport.send(message) : "postMessage" in transport ? transport.postMessage(message) : console.warn(`${transport.constructor.name} doesn't support IPC`);
+  }
+  onMessage(message) {
+    if (message.id.startsWith(RPC_RESPONSE_MARK)) {
+      this.handleResponseMessage(message);
+      return;
+    }
+    if ("type" in message) {
+      this.handleRequestMessage(message);
+      return;
+    }
+  }
+  handleResponseMessage(message) {
+    let id = message.id.slice(RPC_RESPONSE_MARK.length), request = this.requests.get(id);
+    if (!request)
+      return;
+    let { reject, resolve: resolve5, timeout } = request;
+    this.requests.delete(id), clearTimeout(timeout), "data" in message ? resolve5(message.data) : reject(new Error(message.error));
+  }
+  handleRequestMessage(message) {
+    this.emit("message", message), this.emit(message.type, message.id, message.data);
+  }
+  send(type, data, id = randomUUID()) {
+    let message = {
+      id,
+      type,
+      data
+    };
+    this.postMessage(message);
+  }
+  success(id, data) {
+    let message = {
+      id: `${RPC_RESPONSE_MARK}${id}`,
+      data
+    };
+    this.postMessage(message);
+  }
+  error(id, error) {
+    let message = {
+      id: `${RPC_RESPONSE_MARK}${id}`,
+      error
+    };
+    this.postMessage(message);
+  }
+  request(type, data, id = randomUUID()) {
+    return new Promise((resolve5, reject) => {
+      let timeout = setTimeout(() => {
+        this.requests.delete(id) && reject(new Error("Request timed out"));
+      }, RPC_RESPONSE_TIMEOUT);
+      this.requests.set(id, {
+        resolve: resolve5,
+        reject,
+        timeout
+      }), this.send(type, data, id);
+    });
+  }
+};
+
+// src/lib/loader/loader.ts
+var rpc, reverseDependencyGraph = /* @__PURE__ */ new Map();
 function $initLoader() {
-  let channel = new MessageChannel();
-  port1 = channel.port1, port2 = channel.port2;
-  let hookPath = new URL("./hooks.js", import.meta.url).href;
+  let { port1, port2 } = new MessageChannel(), hookPath = new URL("./hooks.js", import.meta.url).href;
   register(hookPath, import.meta.url, {
     data: { port: port1 },
     transferList: [port1]
-  }), port2.on("message", onMessage), port2.unref();
+  }), rpc = new RPC(port2), rpc.on("dependencyAdd", (_id, data) => onDependencyAdd(data)), port2.unref();
 }
-function onMessage(message) {
-  let { id, error, data } = message, request = pending.get(id);
-  request && (pending.delete(id), error ? request.reject(new Error(error)) : request.resolve(data));
+function $unloadFile(path) {
+  if (!rpc)
+    throw new Error("Loader isn't initialized");
+  return rpc.request("unload", resolve(path));
 }
-function $postLoaderMessage(type, data, wait = false) {
-  let id = messageId++, message = { id, type, data };
-  if (!wait) {
-    port2?.postMessage(message);
-    return;
+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 getDependencyChain(path) {
+  path = resolve(path);
+  let queue = [path], visited = /* @__PURE__ */ new Set();
+  for (; queue.length > 0; ) {
+    let current = queue.shift();
+    if (!current || visited.has(current) || (visited.add(current), current.includes("/node_modules/")))
+      continue;
+    let parents = getImporters(current);
+    if (parents)
+      for (let parent of parents)
+        visited.has(parent) || queue.push(parent);
   }
-  return new Promise((resolve4, reject) => {
-    if (!port2)
-      return reject(new Error("Loader is not initialized"));
-    pending.set(id, { resolve: resolve4, reject }), port2.postMessage(message);
+  return Array.from(visited);
+}
+function isImported(path) {
+  return !!getImporters(path)?.size;
+}
+function isImportedBy(path, matcher) {
+  return getDependencyChain(path).slice(1).some((p) => {
+    let isMatch = false;
+    return typeof matcher == "string" && (isMatch = resolve(matcher) === p), typeof matcher == "function" && (isMatch = matcher(p)), matcher instanceof RegExp && (isMatch = matcher.test(p)), isMatch;
   });
 }
-function $unloadFile(path) {
-  return $postLoaderMessage("unload", resolve(path), true);
+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);
 }
 
 // src/core/structures/param/Param.ts
@@ -475,6 +560,8 @@ var BaseClientManager = class {
     this.client = client;
   }
 };
+
+// src/core/managers/CommandManager.ts
 var CommandManager = class extends BaseClientManager {
   commands = new Collection();
   entries = new Collection();
@@ -573,6 +660,8 @@ var Context = class {
     this.canceled = true;
   }
 };
+
+// src/core/managers/ListenerManager.ts
 var ListenerManager = class extends BaseClientManager {
   listeners = [];
   entries = new Collection();
@@ -770,7 +859,7 @@ var BaseCommandContext = class extends Context {
     return await channel.send(options);
   }
 };
-var ProjectConfigSchema = z4.object({
+var CONFIG_EXTENSIONS = ["ts", "js"], ProjectConfigSchema = z4.object({
   /**
    * The gateway intents to use for the Discord client.
    *
@@ -789,7 +878,13 @@ var ProjectConfigSchema = z4.object({
    * @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) {
@@ -799,7 +894,7 @@ var _config;
 async function loadConfig(cwd = process.cwd()) {
   if (_config)
     return console.warn("loadConfig() was called more than once. This shouldn't happen."), _config;
-  let globPattern = `bakit.config.{${["ts", "js"].join(",")}}`, [configPath, other] = await glob(globPattern, {
+  let globPattern = `bakit.config.{${CONFIG_EXTENSIONS.join(",")}}`, [configPath, other] = await glob(globPattern, {
     cwd: cwd.replace(/\\/g, "/"),
     // ensure the path uses `/` instead of `\` on Windows
     absolute: true
@@ -815,6 +910,39 @@ function getConfig() {
     throw new Error("Project config is not loaded.");
   return _config;
 }
+var ProjectCacheManager = class {
+  rootDir;
+  constructor(root = process.cwd()) {
+    this.rootDir = join(root, ".bakit"), this.ensureRoot();
+  }
+  ensureRoot() {
+    existsSync(this.rootDir) || mkdirSync(this.rootDir, { recursive: true });
+  }
+  getHash(data) {
+    return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+  }
+  async write(path, data) {
+    let fullPath = join(this.rootDir, path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: true });
+    let content = typeof data == "string" ? data : JSON.stringify(data);
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async read(path) {
+    let fullPath = join(this.rootDir, path);
+    try {
+      let content = await readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    await rm(this.rootDir, { recursive: true, force: true });
+  }
+  clearSync() {
+    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
+  }
+};
 var messageCommandHandler = defineListener(Events.MessageCreate), chatInputCommandHandler = defineListener(Events.InteractionCreate), registerCommandsHandler = defineListener({
   name: Events.ClientReady,
   once: true
@@ -873,46 +1001,14 @@ chatInputCommandHandler.main(async (_, interaction) => {
   }
   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/core/internal/Instance.ts
-var Instance = class {
+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 {
   client;
   cache;
+  rpc;
   constructor() {
-    this.cache = new ProjectCacheManager();
+    this.cache = new ProjectCacheManager(), this.rpc = new RPC(process);
   }
   async start() {
     await loadConfig();
@@ -926,7 +1022,7 @@ var Instance = class {
     ), await this.loadModules(), this.initIntents(), await this.client.login(config.token), this.initProcess();
   }
   initProcess() {
-    process.on("message", (msg) => this.onProcessMessage(msg));
+    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());
   }
   loadModules() {
     let { managers } = this.client, { commands, listeners } = managers;
@@ -936,18 +1032,59 @@ var Instance = class {
     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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async onProcessMessage(message) {
-    let { type, path } = message;
-    if (!type.startsWith("hmr:"))
+  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 (!isImported(path))
+      return;
+    let chain = getDependencyChain(path);
+    if (this.containsEntryPoint(chain)) {
+      this.restart();
       return;
-    let target = type.split(":")[1], { listeners, commands } = this.client.managers;
-    switch (target) {
+    }
+    if (this.containsHotModule(chain))
+      for (let path2 of chain.reverse())
+        await this.unloadModule(path2);
+  }
+  async onFileChange(path) {
+    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(path);
+        await listeners[reload ? "reload" : "unload"](path);
         break;
       case "commands":
-        await commands.reload(path);
+        await commands[reload ? "reload" : "unload"](path);
+        break;
+      default:
+        await $unloadFile(path);
         break;
     }
   }
@@ -966,4 +1103,4 @@ var Params = {
   user: createFactory(UserParam)
 };
 
-export { $initLoader, $postLoaderMessage, $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, StringParam, StringParamSchema, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };
+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 };

package/package.json

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