commandkit 0.1.11-dev.20250306101654 → 0.1.11-dev.20250307192025

package/dist/index.js

@@ -1011,81 +1011,6 @@ var init_components = __esm({
   }
 });
 
-// src/app/i18n/DefaultLocalizationStrategy.ts
-var import_promises, import_node_path, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
-var init_DefaultLocalizationStrategy = __esm({
-  "src/app/i18n/DefaultLocalizationStrategy.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
-    _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
-      }
-      translations = /* @__PURE__ */ new Map();
-      async locateTranslation(scope, locale) {
-        const localesPath = this.commandkit.getPath("locales");
-        if (!localesPath) return null;
-        const path3 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
-        try {
-          const data = await (0, import_promises.readFile)(path3, "utf-8");
-          return JSON.parse(data);
-        } catch {
-          return null;
-        }
-      }
-      async getTranslationStrict(scope, locale) {
-        const key = `${scope}:${locale}`;
-        if (!this.translations.has(key)) {
-          const translation = await this.locateTranslation(scope, locale);
-          if (!translation) {
-            throw new Error(`Translation not found for ${key}`);
-          }
-          this.translations.set(key, translation);
-          return translation;
-        }
-        return this.translations.get(key);
-      }
-      async getTranslation(scope, locale) {
-        try {
-          return this.getTranslationStrict(scope, locale);
-        } catch (e) {
-          return null;
-        }
-      }
-      async translate(request) {
-        const { scope, key, args, locale } = request;
-        const translation = await this.getTranslation(scope, locale);
-        if (!translation) return `${scope}.${key}`;
-        const value = translation.translations[key];
-        const translated = this.applyTranslation(value, args);
-        return translated || `${scope}.${key}`;
-      }
-      applyTranslation(translation, args) {
-        if (!translation || !args) return translation;
-        return translation.replace(/{([^}]+)}/g, (_, key) => {
-          return String(args[key] ?? `{${key}}`);
-        });
-      }
-    };
-    __name(_DefaultLocalizationStrategy, "DefaultLocalizationStrategy");
-    DefaultLocalizationStrategy = _DefaultLocalizationStrategy;
-  }
-});
-
-// src/utils/constants.ts
-var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    init_cjs_shims();
-    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
-    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
-    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
-  }
-});
-
 // src/plugins/PluginCommon.ts
 var _PluginCommon, PluginCommon;
 var init_PluginCommon = __esm({
@@ -1157,11 +1082,83 @@ var init_CompilerPlugin = __esm({
 });
 
 // src/plugins/RuntimePlugin.ts
+function isRuntimePlugin(plugin) {
+  return plugin instanceof RuntimePlugin;
+}
+var _RuntimePlugin, RuntimePlugin;
 var init_RuntimePlugin = __esm({
   "src/plugins/RuntimePlugin.ts"() {
     "use strict";
     init_cjs_shims();
     init_PluginCommon();
+    _RuntimePlugin = class _RuntimePlugin extends PluginCommon {
+      /**
+       * Called before commands are loaded
+       */
+      async onBeforeCommandsLoad(ctx) {
+      }
+      /**
+       * Called after commands are loaded
+       */
+      async onAfterCommandsLoad(ctx) {
+      }
+      /**
+       * Called before events are loaded
+       */
+      async onBeforeEventsLoad(ctx) {
+      }
+      /**
+       * Called after events are loaded
+       */
+      async onAfterEventsLoad(ctx) {
+      }
+      /**
+       * Called before the client logs in
+       */
+      async onBeforeClientLogin(ctx) {
+      }
+      /**
+       * Called after the client logs in
+       */
+      async onAfterClientLogin(ctx) {
+      }
+      /**
+       * Called before interaction is handled
+       * @param interaction The interaction
+       */
+      async onBeforeInteraction(ctx, interaction) {
+      }
+      /**
+       * Called after interaction is handled
+       * @param interaction The interaction that was handled
+       */
+      async onAfterInteraction(ctx, interaction) {
+      }
+      /**
+       * Called before message command is processed
+       * @param message The message
+       */
+      async onBeforeMessageCommand(ctx, message) {
+      }
+      /**
+       * Called before message update command is processed
+       * @param message The message
+       */
+      async onBeforeMessageUpdateCommand(ctx, oldMessage, newMessage) {
+      }
+      /**
+       * Called before command is executed. This method can execute the command itself.
+       * @param source The source that triggered the command
+       * @param command The command
+       * @param execute The function that executes the command
+       */
+      async executeCommand(ctx, source, command, execute) {
+        return false;
+      }
+    };
+    __name(_RuntimePlugin, "RuntimePlugin");
+    RuntimePlugin = _RuntimePlugin;
+    __name(isRuntimePlugin, "isRuntimePlugin");
   }
 });
 
@@ -1386,6 +1383,18 @@ var init_CommandKitPluginRuntime = __esm({
       getPlugin(pluginName) {
         return this.plugins.get(pluginName) ?? null;
       }
+      async softRegisterPlugin(plugin) {
+        const pluginName = plugin.name;
+        if (this.plugins.has(pluginName)) return;
+        try {
+          await plugin.activate(this);
+          this.plugins.set(pluginName, plugin);
+        } catch (e) {
+          throw new Error(
+            `Failed to activate plugin "${pluginName}": ${(e == null ? void 0 : e.stack) || e}`
+          );
+        }
+      }
       async registerPlugin(plugin) {
         const pluginName = plugin.name;
         if (this.plugins.has(pluginName)) {
@@ -1467,12 +1476,12 @@ function fromEsbuildPlugin(plugin) {
   let EsbuildPluginCompat = _EsbuildPluginCompat;
   return EsbuildPluginCompat;
 }
-var import_promises2, pattern, _CompilerPluginRuntime, CompilerPluginRuntime;
+var import_promises, pattern, _CompilerPluginRuntime, CompilerPluginRuntime;
 var init_CompilerPluginRuntime = __esm({
   "src/plugins/runtime/CompilerPluginRuntime.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises2 = require("fs/promises");
+    import_promises = require("fs/promises");
     init_plugins();
     pattern = /\.(c|m)?(t|j)sx?$/;
     _CompilerPluginRuntime = class _CompilerPluginRuntime {
@@ -1485,7 +1494,7 @@ var init_CompilerPluginRuntime = __esm({
       }
       async onLoad(args) {
         var _a;
-        const source = await (0, import_promises2.readFile)(args.path, "utf8");
+        const source = await (0, import_promises.readFile)(args.path, "utf8");
         let contents = source, loader = args.path.split(".").pop();
         for (const plugin of this.plugins) {
           try {
@@ -1956,6 +1965,134 @@ var init_config = __esm({
   }
 });
 
+// src/app/i18n/DefaultLocalizationStrategy.ts
+var import_promises2, import_node_path, import_node_fs, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
+var init_DefaultLocalizationStrategy = __esm({
+  "src/app/i18n/DefaultLocalizationStrategy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises2 = require("fs/promises");
+    import_node_path = require("path");
+    init_config();
+    import_node_fs = require("fs");
+    _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
+      constructor(commandkit) {
+        this.commandkit = commandkit;
+      }
+      translations = /* @__PURE__ */ new Map();
+      async locateTranslation(scope, locale) {
+        const localesPath = this.commandkit.getPath("locales");
+        if (!localesPath) return null;
+        const path3 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
+        try {
+          const data = await (0, import_promises2.readFile)(path3, "utf-8");
+          const localeData = JSON.parse(data);
+          await this.generateLocaleTypes(localeData);
+          return localeData;
+        } catch {
+          return null;
+        }
+      }
+      async generateLocaleTypes(localeData) {
+        const { typedLocales } = getConfig();
+        if (!typedLocales) return;
+        const file = (0, import_node_path.join)(
+          process.cwd(),
+          "node_modules",
+          "commandkit-types",
+          "locale_types.d.ts"
+        );
+        const header = `// auto generated file do not edit
+declare module 'commandkit' {
+  export interface CommandLocalizationTypeData {
+`;
+        const footer = `  }
+}`;
+        const generateType = /* @__PURE__ */ __name((locale) => {
+          return `"${locale.command}": ${JSON.stringify(
+            Object.entries(locale.translations).map(([key, value]) => {
+              const args = value.match(/{([^}]+)}/g);
+              if (!args) return `${JSON.stringify(key)}: null`;
+              return `${JSON.stringify(key)}: ${args.map((arg) => arg.slice(1, -1)).join(" | ")}`;
+            }),
+            null,
+            2
+          )}`;
+        }, "generateType");
+        if (!(0, import_node_fs.existsSync)(file)) {
+          const generated = generateType(localeData);
+          await (0, import_promises2.writeFile)(file, `${header}${generated}${footer}`);
+        } else {
+          const data = await (0, import_promises2.readFile)(file, "utf-8");
+          const lines = data.split("\n");
+          const index = lines.findIndex(
+            (line) => line.includes("CommandLocalizationTypeData")
+          );
+          if (index === -1) {
+            for (const locale of this.translations.values()) {
+              const generated2 = generateType(locale);
+              await (0, import_promises2.writeFile)(file, `${header}${generated2}${footer}`);
+            }
+            return;
+          }
+          const start = index + 2;
+          const end = lines.findIndex((line) => line.includes("}"));
+          const generated = generateType(localeData);
+          lines.splice(start, end - start, generated);
+          await (0, import_promises2.writeFile)(file, lines.join("\n"));
+        }
+      }
+      async getTranslationStrict(scope, locale) {
+        const key = `${scope}:${locale}`;
+        if (!this.translations.has(key)) {
+          const translation = await this.locateTranslation(scope, locale);
+          if (!translation) {
+            throw new Error(`Translation not found for ${key}`);
+          }
+          this.translations.set(key, translation);
+          return translation;
+        }
+        return this.translations.get(key);
+      }
+      async getTranslation(scope, locale) {
+        try {
+          return this.getTranslationStrict(scope, locale);
+        } catch (e) {
+          return null;
+        }
+      }
+      async translate(request) {
+        const { scope, key, args, locale } = request;
+        const translation = await this.getTranslation(scope, locale);
+        if (!translation) return `${scope}.${key}`;
+        const value = translation.translations[key];
+        const translated = this.applyTranslation(value, args);
+        return translated || `${scope}.${key}`;
+      }
+      applyTranslation(translation, args) {
+        if (!translation || !args) return translation;
+        return translation.replace(/{([^}]+)}/g, (_, key) => {
+          return String(args[key] ?? `{${key}}`);
+        });
+      }
+    };
+    __name(_DefaultLocalizationStrategy, "DefaultLocalizationStrategy");
+    DefaultLocalizationStrategy = _DefaultLocalizationStrategy;
+  }
+});
+
+// src/utils/constants.ts
+var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    init_cjs_shims();
+    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
+    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
+    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
+  }
+});
+
 // src/utils/utilities.ts
 function findAppDirectory() {
   if (appDir) return appDir;
@@ -1963,10 +2100,10 @@ function findAppDirectory() {
     process.cwd(),
     COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir
   );
-  if (!(0, import_node_fs.existsSync)(root)) root = process.cwd();
+  if (!(0, import_node_fs2.existsSync)(root)) root = process.cwd();
   const dirs = ["app"].map((dir) => (0, import_node_path2.join)(root, dir));
   for (const dir of dirs) {
-    if ((0, import_node_fs.existsSync)(dir)) {
+    if ((0, import_node_fs2.existsSync)(dir)) {
       appDir = dir;
       return dir;
     }
@@ -1975,22 +2112,31 @@ function findAppDirectory() {
 }
 function debounce(fn, ms2) {
   let timer = null;
+  let resolve = null;
   return (...args) => {
     if (timer) {
       clearTimeout(timer);
+      if (resolve) {
+        resolve(null);
+      }
     }
-    timer = setTimeout(() => {
-      fn(...args);
-      timer = null;
-    }, ms2);
+    return new Promise((res) => {
+      resolve = res;
+      timer = setTimeout(() => {
+        const result = fn(...args);
+        res(result);
+        timer = null;
+        resolve = null;
+      }, ms2);
+    });
   };
 }
-var import_node_fs, import_node_path2, appDir;
+var import_node_fs2, import_node_path2, appDir;
 var init_utilities = __esm({
   "src/utils/utilities.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs = require("fs");
+    import_node_fs2 = require("fs");
     import_node_path2 = require("path");
     init_constants();
     init_config();
@@ -2946,6 +3092,9 @@ var init_CommandRegistrar = __esm({
         const commands = this.commandkit.commandHandler.getCommandsArray();
         return commands.flatMap((cmd) => {
           const json = "toJSON" in cmd.data.command ? cmd.data.command.toJSON() : cmd.data.command;
+          if (cmd.subcommands && cmd.subcommands.length > 0 && (!json.type || json.type === import_discord9.ApplicationCommandType.ChatInput)) {
+            this.processSubcommands(json, cmd.subcommands);
+          }
           const collections = [json];
           if (cmd.data.userContextMenu && json.type !== import_discord9.ApplicationCommandType.User) {
             collections.push({
@@ -2970,6 +3119,70 @@ var init_CommandRegistrar = __esm({
           return collections;
         });
       }
+      /**
+       * Process and merge subcommands into the parent command's options
+       */
+      processSubcommands(commandData, subcommands) {
+        var _a, _b, _c;
+        if (!commandData.options) {
+          commandData.options = [];
+        }
+        const groupedSubcommands = /* @__PURE__ */ new Map();
+        for (const subcommand of subcommands) {
+          const group = subcommand.group || null;
+          if (!groupedSubcommands.has(group)) {
+            groupedSubcommands.set(group, []);
+          }
+          (_a = groupedSubcommands.get(group)) == null ? void 0 : _a.push(subcommand);
+        }
+        const directSubcommands = groupedSubcommands.get(null) || [];
+        for (const subcommand of directSubcommands) {
+          const subcommandData = this.commandkit.commandHandler.getSubcommandData(
+            subcommand.id
+          );
+          if (subcommandData) {
+            const subcommandOption = {
+              type: 1,
+              // SUB_COMMAND
+              name: subcommand.name,
+              description: subcommandData.description || "No description provided",
+              options: subcommandData.options || [],
+              name_localizations: subcommandData.name_localizations,
+              description_localizations: subcommandData.description_localizations
+            };
+            commandData.options.push(subcommandOption);
+          }
+        }
+        for (const [groupName, groupSubcommands] of groupedSubcommands.entries()) {
+          if (groupName === null) continue;
+          const subcommandGroupOption = {
+            type: import_discord9.ApplicationCommandOptionType.SubcommandGroup,
+            // SUB_COMMAND_GROUP
+            name: groupName,
+            description: `${groupName} commands`,
+            options: []
+          };
+          for (const subcommand of groupSubcommands) {
+            const subcommandData = this.commandkit.commandHandler.getSubcommandData(
+              subcommand.id
+            );
+            if (subcommandData) {
+              (_b = subcommandGroupOption.options) == null ? void 0 : _b.push({
+                type: import_discord9.ApplicationCommandOptionType.Subcommand,
+                // SUB_COMMAND
+                name: subcommand.name,
+                description: subcommandData.description || "No description provided",
+                options: subcommandData.options || [],
+                name_localizations: subcommandData.name_localizations,
+                description_localizations: subcommandData.description_localizations
+              });
+            }
+          }
+          if ((((_c = subcommandGroupOption.options) == null ? void 0 : _c.length) || 0) > 0) {
+            commandData.options.push(subcommandGroupOption);
+          }
+        }
+      }
       /**
        * Registers loaded commands.
        */
@@ -3085,14 +3298,26 @@ var init_AppCommandHandler = __esm({
         this.registrar = new CommandRegistrar(this.commandkit);
       }
       loadedCommands = new import_discord10.Collection();
+      loadedSubCommands = new import_discord10.Collection();
       loadedMiddlewares = new import_discord10.Collection();
+      // Name-to-ID mapping for easier lookup
+      commandNameToId = /* @__PURE__ */ new Map();
+      subcommandPathToId = /* @__PURE__ */ new Map();
       registrar;
       onInteraction = null;
       onMessageCreate = null;
       onMessageUpdate = null;
       getCommandsArray() {
-        const loaded = Array.from(this.loadedCommands.values());
-        return loaded;
+        return Array.from(this.loadedCommands.values());
+      }
+      /**
+       * Get subcommand data by ID for the command registrar
+       */
+      getSubcommandData(id) {
+        const subcommand = this.loadedSubCommands.get(id);
+        if (!subcommand) return null;
+        const commandData = subcommand.data.command;
+        return "toJSON" in commandData ? commandData.toJSON() : commandData;
       }
       registerCommandHandler() {
         this.onInteraction ??= async (interaction) => {
@@ -3104,9 +3329,9 @@ var init_AppCommandHandler = __esm({
           if (success) return;
           const isCommandLike = interaction.isCommand() || interaction.isAutocomplete() || interaction.isUserContextMenuCommand() || interaction.isMessageContextMenuCommand();
           if (!isCommandLike) return;
-          const command = await this.prepareCommandRun(interaction);
-          if (!command) return;
-          return this.runCommand(command, interaction);
+          const prepared = await this.prepareCommandRun(interaction);
+          if (!prepared) return;
+          return this.runCommand(prepared, interaction);
         };
         this.onMessageCreate ??= async (message) => {
           const success = await this.commandkit.plugins.execute(
@@ -3116,9 +3341,9 @@ var init_AppCommandHandler = __esm({
           );
           if (success) return;
           if (message.author.bot) return;
-          const command = await this.prepareCommandRun(message);
-          if (!command) return;
-          return this.runCommand(command, message);
+          const prepared = await this.prepareCommandRun(message);
+          if (!prepared) return;
+          return this.runCommand(prepared, message);
         };
         this.onMessageUpdate ??= async (oldMessage, newMessage) => {
           const success = await this.commandkit.plugins.execute(
@@ -3133,9 +3358,9 @@ var init_AppCommandHandler = __esm({
           if (success) return;
           if (oldMessage.partial || newMessage.partial) return;
           if (oldMessage.author.bot) return;
-          const command = await this.prepareCommandRun(newMessage);
-          if (!command) return;
-          return this.runCommand(command, newMessage);
+          const prepared = await this.prepareCommandRun(newMessage);
+          if (!prepared) return;
+          return this.runCommand(prepared, newMessage);
         };
         this.commandkit.client.on(import_discord10.Events.InteractionCreate, this.onInteraction);
         this.commandkit.client.on(import_discord10.Events.MessageCreate, this.onMessageCreate);
@@ -3155,7 +3380,7 @@ var init_AppCommandHandler = __esm({
         }
         return null;
       }
-      async runCommand(command, source) {
+      async runCommand(prepared, source) {
         if (source instanceof import_discord10.Message && (source.editedTimestamp || source.partial)) {
           return;
         }
@@ -3166,13 +3391,14 @@ var init_AppCommandHandler = __esm({
           message: source instanceof import_discord10.Message ? source : null,
           forwarded: false
         });
-        for (const middleware of command.middlewares) {
+        for (const middleware of prepared.middlewares) {
           await middleware.data.beforeExecute(ctx);
         }
-        const fn = command.command.data[executionMode];
+        const targetData = prepared.subcommand ? prepared.subcommand.data : prepared.command.data;
+        const fn = targetData[executionMode];
         if (!fn) {
           Logger.warn(
-            `Command ${command.command.command.name} has no handler for ${executionMode}`
+            `Command ${prepared.command.command.name}${prepared.subcommand ? "/" + prepared.subcommand.subcommand.name : ""} has no handler for ${executionMode}`
           );
         }
         if (fn) {
@@ -3180,7 +3406,7 @@ var init_AppCommandHandler = __esm({
             const executeCommand = /* @__PURE__ */ __name(async () => fn(ctx.clone()), "executeCommand");
             const res = await this.commandkit.plugins.execute(
               async (ctx2, plugin) => {
-                return plugin.executeCommand(ctx2, source, command, executeCommand);
+                return plugin.executeCommand(ctx2, source, prepared, executeCommand);
               }
             );
             if (!res) {
@@ -3190,12 +3416,15 @@ var init_AppCommandHandler = __esm({
             Logger.error(e);
           }
         }
-        for (const middleware of command.middlewares) {
+        for (const middleware of prepared.middlewares) {
           await middleware.data.afterExecute(ctx);
         }
       }
       async prepareCommandRun(source) {
-        let cmd;
+        var _a;
+        let cmdName;
+        let subcommandGroupName = null;
+        let subcommandName = null;
         let parser2;
         if (source instanceof import_discord10.Message) {
           if (source.author.bot) return null;
@@ -3204,13 +3433,14 @@ var init_AppCommandHandler = __esm({
             source,
             Array.isArray(prefix) ? prefix : [prefix],
             (command) => {
-              var _a, _b;
-              const loadedCommand2 = this.loadedCommands.find((c) => {
-                return c.data.command.name === command;
-              });
+              var _a2, _b;
+              const commandId2 = this.commandNameToId.get(command);
+              if (!commandId2) return null;
+              const loadedCommand2 = this.loadedCommands.get(commandId2);
               if (!loadedCommand2) return null;
-              if (source.guildId && ((_a = loadedCommand2.guilds) == null ? void 0 : _a.length) && !loadedCommand2.guilds.includes(source.guildId))
+              if (source.guildId && ((_a2 = loadedCommand2.guilds) == null ? void 0 : _a2.length) && !loadedCommand2.guilds.includes(source.guildId)) {
                 return null;
+              }
               const json = "toJSON" in loadedCommand2.data.command ? loadedCommand2.data.command.toJSON() : loadedCommand2.data.command;
               return ((_b = json.options) == null ? void 0 : _b.reduce(
                 (acc, opt) => {
@@ -3222,7 +3452,17 @@ var init_AppCommandHandler = __esm({
             }
           );
           try {
-            cmd = parser2.getFullCommand();
+            const fullCommand = parser2.getFullCommand();
+            const parts = fullCommand.split(" ");
+            cmdName = parts[0];
+            if (parts.length > 1) {
+              if (parts.length === 3) {
+                subcommandGroupName = parts[1];
+                subcommandName = parts[2];
+              } else {
+                subcommandName = parts[1];
+              }
+            }
           } catch (e) {
             if (isErrorType(e, CommandKitErrorCodes.InvalidCommandPrefix)) {
               return null;
@@ -3232,31 +3472,63 @@ var init_AppCommandHandler = __esm({
           }
         } else {
           if (!source.isCommand()) return null;
-          cmd = source.commandName;
+          cmdName = source.commandName;
           if (source.isChatInputCommand()) {
-            const subcommandGroup = source.options.getSubcommandGroup(false);
-            const subcommand = source.options.getSubcommand(false);
-            if (subcommandGroup) {
-              cmd += ` ${subcommandGroup}`;
-            }
-            if (subcommand) {
-              cmd += ` ${subcommand}`;
-            }
+            subcommandGroupName = source.options.getSubcommandGroup(false);
+            subcommandName = source.options.getSubcommand(false);
           }
         }
-        const loadedCommand = this.loadedCommands.find((c) => {
-          return c.data.command.name === cmd;
-        });
+        const commandId = this.commandNameToId.get(cmdName);
+        if (!commandId) return null;
+        const loadedCommand = this.loadedCommands.get(commandId);
         if (!loadedCommand) return null;
+        if (source instanceof import_discord10.CommandInteraction && source.guildId && ((_a = loadedCommand.guilds) == null ? void 0 : _a.length) && !loadedCommand.guilds.includes(source.guildId)) {
+          return null;
+        }
+        let loadedSubCommand = null;
+        if (subcommandName) {
+          let subcommandPath = `${loadedCommand.command.id}/${subcommandName}`;
+          if (subcommandGroupName) {
+            subcommandPath = `${loadedCommand.command.id}/${subcommandGroupName}/${subcommandName}`;
+          }
+          const subCommandId = this.subcommandPathToId.get(subcommandPath);
+          if (subCommandId) {
+            loadedSubCommand = this.loadedSubCommands.get(subCommandId) || null;
+          }
+        }
+        const middlewares = [];
+        for (const middlewareId of loadedCommand.command.middlewares) {
+          const middleware = this.loadedMiddlewares.get(middlewareId);
+          if (middleware) {
+            middlewares.push(middleware);
+          }
+        }
+        if (loadedSubCommand) {
+          for (const middlewareId of loadedSubCommand.subcommand.middlewares) {
+            const existingIndex = middlewares.findIndex(
+              (m) => m.middleware.id === middlewareId
+            );
+            if (existingIndex === -1) {
+              const middleware = this.loadedMiddlewares.get(middlewareId);
+              if (middleware) {
+                middlewares.push(middleware);
+              }
+            }
+          }
+        }
         return {
           command: loadedCommand,
-          middlewares: loadedCommand.command.middlewares.map((m) => this.loadedMiddlewares.get(m)).filter((m) => !!m),
+          subcommand: loadedSubCommand,
+          middlewares,
           messageCommandParser: parser2
         };
       }
       async reloadCommands() {
         this.loadedCommands.clear();
+        this.loadedSubCommands.clear();
         this.loadedMiddlewares.clear();
+        this.commandNameToId.clear();
+        this.subcommandPathToId.clear();
         await this.loadCommands();
       }
       async loadCommands() {
@@ -3264,9 +3536,33 @@ var init_AppCommandHandler = __esm({
         if (!commandsRouter) {
           throw new Error("Commands router has not yet initialized");
         }
-        const { commands, middleware } = commandsRouter.getData();
-        for (const [id, md] of middleware) {
-          const data = await import(`${toFileURL(md.fullPath)}?t=${Date.now()}`);
+        const { commands, subcommands, middlewares } = commandsRouter.getData();
+        for (const [id, middleware] of middlewares) {
+          await this.loadMiddleware(id, middleware);
+        }
+        for (const [id, command] of commands) {
+          await this.loadCommand(id, command);
+        }
+        for (const [id, subcommand] of subcommands) {
+          await this.loadSubcommand(id, subcommand);
+        }
+        for (const loadedSubCommand of this.loadedSubCommands.values()) {
+          const pathSegments = loadedSubCommand.subcommand.path.split("/");
+          const parentCommandName = pathSegments[pathSegments.length - 3];
+          for (const loadedCommand of this.loadedCommands.values()) {
+            if (loadedCommand.command.name === parentCommandName) {
+              if (!loadedCommand.subcommands) {
+                loadedCommand.subcommands = [];
+              }
+              loadedCommand.subcommands.push(loadedSubCommand.subcommand);
+              break;
+            }
+          }
+        }
+      }
+      async loadMiddleware(id, middleware) {
+        try {
+          const data = await import(`${toFileURL(middleware.path)}?t=${Date.now()}`);
           let handlerCount = 0;
           for (const [key, validator] of Object.entries(middlewareDataSchema)) {
             if (data[key] && !await validator(data[key])) {
@@ -3281,13 +3577,35 @@ var init_AppCommandHandler = __esm({
               `Invalid export for middleware ${id}: at least one handler function must be provided`
             );
           }
-          this.loadedMiddlewares.set(id, { middleware: md, data });
+          this.loadedMiddlewares.set(id, { middleware, data });
+        } catch (error) {
+          Logger.error(
+            `Failed to load middleware ${middleware.name} (${id})`,
+            error
+          );
         }
-        for (const [name, command] of commands) {
-          const data = await import(`${toFileURL(command.fullPath)}?t=${Date.now()}`);
+      }
+      async loadCommand(id, command) {
+        try {
+          if (command.path === null) {
+            this.loadedCommands.set(id, {
+              command,
+              data: {
+                command: {
+                  name: command.name,
+                  description: `${command.name} commands`,
+                  type: 1
+                  // CHAT_INPUT
+                }
+              }
+            });
+            this.commandNameToId.set(command.name, id);
+            return;
+          }
+          const data = await import(`${toFileURL(command.path)}?t=${Date.now()}`);
           if (!data.command) {
             throw new Error(
-              `Invalid export for command ${name}: no command definition found`
+              `Invalid export for command ${command.name}: no command definition found`
             );
           }
           let handlerCount = 0;
@@ -3295,19 +3613,19 @@ var init_AppCommandHandler = __esm({
             if (key !== "command" && data[key]) handlerCount++;
             if (data[key] && !await validator(data[key])) {
               throw new Error(
-                `Invalid export for command ${name}: ${key} does not match expected value`
+                `Invalid export for command ${command.name}: ${key} does not match expected value`
               );
             }
           }
           if (handlerCount === 0) {
             throw new Error(
-              `Invalid export for command ${name}: at least one handler function must be provided`
+              `Invalid export for command ${command.name}: at least one handler function must be provided`
             );
           }
           const localizedCommand = await this.applyLocalizations({
             ...data.command
           });
-          this.loadedCommands.set(name, {
+          this.loadedCommands.set(id, {
             command,
             guilds: data.guilds,
             data: {
@@ -3315,6 +3633,60 @@ var init_AppCommandHandler = __esm({
               command: localizedCommand
             }
           });
+          this.commandNameToId.set(command.name, id);
+        } catch (error) {
+          Logger.error(`Failed to load command ${command.name} (${id})`, error);
+        }
+      }
+      async loadSubcommand(id, subcommand) {
+        try {
+          const data = await import(`${toFileURL(subcommand.path)}?t=${Date.now()}`);
+          if (!data.command) {
+            throw new Error(
+              `Invalid export for subcommand ${subcommand.name}: no command definition found`
+            );
+          }
+          let handlerCount = 0;
+          for (const [key, validator] of Object.entries(commandDataSchema)) {
+            if (key !== "command" && data[key]) handlerCount++;
+            if (data[key] && !await validator(data[key])) {
+              throw new Error(
+                `Invalid export for subcommand ${subcommand.name}: ${key} does not match expected value`
+              );
+            }
+          }
+          if (handlerCount === 0) {
+            throw new Error(
+              `Invalid export for subcommand ${subcommand.name}: at least one handler function must be provided`
+            );
+          }
+          const localizedCommand = await this.applyLocalizations({
+            ...data.command
+          });
+          this.loadedSubCommands.set(id, {
+            subcommand,
+            data: {
+              ...data,
+              command: localizedCommand
+            }
+          });
+          const parentCommandId = subcommand.id.split("/")[0];
+          if (subcommand.group) {
+            this.subcommandPathToId.set(
+              `${parentCommandId}/${subcommand.group}/${subcommand.name}`,
+              id
+            );
+          } else {
+            this.subcommandPathToId.set(
+              `${parentCommandId}/${subcommand.name}`,
+              id
+            );
+          }
+        } catch (error) {
+          Logger.error(
+            `Failed to load subcommand ${subcommand.name} (${id})`,
+            error
+          );
         }
       }
       async applyLocalizations(command) {
@@ -3400,248 +3772,243 @@ var init_AppCommandHandler = __esm({
 });
 
 // src/app/router/CommandsRouter.ts
-var import_node_fs2, import_promises3, import_node_path3, _CommandsRouter, CommandsRouter;
+var import_discord11, import_node_fs3, import_promises3, import_posix, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs2 = require("fs");
+    import_discord11 = require("discord.js");
+    import_node_fs3 = require("fs");
     import_promises3 = require("fs/promises");
-    import_node_path3 = __toESM(require("path"));
+    import_posix = __toESM(require("path/posix"));
     _CommandsRouter = class _CommandsRouter {
-      /**
-       * Creates a new CommandsRouter instance
-       * @param options - Configuration options for the router
-       */
       constructor(options) {
         this.options = options;
-        if (!options.entrypoint) {
-          throw new Error("Entrypoint directory must be provided");
-        }
-        options.matcher ??= {};
-        options.matcher.command ??= /command\.(m|c)?(j|t)sx?$/;
-        options.matcher.middleware ??= /middleware\.(m|c)?(j|t)sx?$/;
       }
-      commands = /* @__PURE__ */ new Map();
-      middlewares = /* @__PURE__ */ new Map();
-      /**
-       * Gets the configured entrypoint directory
-       */
+      commands = new import_discord11.Collection();
+      middlewares = new import_discord11.Collection();
+      subcommands = new import_discord11.Collection();
+      isValidPath() {
+        return (0, import_node_fs3.existsSync)(this.entrypoint);
+      }
       get entrypoint() {
         return this.options.entrypoint;
       }
-      /**
-       * Gets the configured matchers for command and middleware files
-       */
-      get matchers() {
-        return this.options.matcher;
+      clear() {
+        this.commands.clear();
+        this.middlewares.clear();
+        this.subcommands.clear();
+      }
+      async reload() {
+        this.clear();
+        return this.scan();
+      }
+      visualize() {
+        let output = "";
+        const commands = [...this.commands.values()];
+        commands.forEach((command, index) => {
+          const isLast = index === commands.length - 1;
+          const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+          const childPrefix = isLast ? "  " : "\u2502 ";
+          const categoryPrefix = command.category ? `[${command.category}] ` : "";
+          output += `${prefix} ${categoryPrefix}${command.name}
+`;
+          const subcommands = command.subcommands.map((id) => this.subcommands.get(id)).filter(Boolean);
+          const groupedSubs = /* @__PURE__ */ new Map();
+          subcommands.forEach((sub) => {
+            if (!groupedSubs.has(sub.group)) {
+              groupedSubs.set(sub.group, []);
+            }
+            groupedSubs.get(sub.group).push(sub);
+          });
+          const groups = [...groupedSubs.entries()];
+          groups.forEach(([group, subs], groupIndex) => {
+            const isLastGroup = groupIndex === groups.length - 1;
+            if (group) {
+              const groupPrefix = isLastGroup ? `${childPrefix}\u2514\u2500` : `${childPrefix}\u251C\u2500`;
+              output += `${groupPrefix} Group: ${group}
+`;
+            }
+            const subPrefix = group ? `${childPrefix}${isLastGroup ? "  " : "\u2502 "}` : childPrefix;
+            subs.forEach((subcommand, subIndex) => {
+              const isLastSub = subIndex === subs.length - 1;
+              const subCommandPrefix = isLastSub ? `${subPrefix}\u2514\u2500` : `${subPrefix}\u251C\u2500`;
+              output += `${subCommandPrefix} ${subcommand.name}
+`;
+              const middlewares = subcommand.middlewares.map((id) => this.middlewares.get(id)).filter(Boolean);
+              middlewares.forEach((middleware, mwIndex) => {
+                const isLastMw = mwIndex === middlewares.length - 1;
+                const mwPrefix = isLastMw ? `${subPrefix}${isLastSub ? "  " : "\u2502 "}\u2514\u2500` : `${subPrefix}${isLastSub ? "  " : "\u2502 "}\u251C\u2500`;
+                output += `${mwPrefix} \u2699\uFE0F ${middleware.name}
+`;
+              });
+            });
+          });
+          const commandMiddlewares = command.middlewares.map((id) => this.middlewares.get(id)).filter(Boolean);
+          if (commandMiddlewares.length > 0) {
+            output += `${childPrefix}\u2514\u2500 Middlewares:
+`;
+            commandMiddlewares.forEach((middleware, mwIndex) => {
+              const isLastMw = mwIndex === commandMiddlewares.length - 1;
+              const mwPrefix = isLastMw ? `${childPrefix}  \u2514\u2500` : `${childPrefix}  \u251C\u2500`;
+              output += `${mwPrefix} \u2699\uFE0F ${middleware.name}
+`;
+            });
+          }
+          output += "\n";
+        });
+        return output;
       }
-      /**
-       * Returns the cached data of the commands and middleware
-       */
       getData() {
         return {
           commands: this.commands,
-          middleware: this.middlewares
+          middlewares: this.middlewares,
+          subcommands: this.subcommands
         };
       }
-      /**
-       * Checks if the entrypoint path is valid
-       */
-      isValidPath() {
-        return (0, import_node_fs2.existsSync)(this.entrypoint);
-      }
-      /**
-       * Executes a matcher against a file path
-       * @param matcher - The matcher to use
-       * @param path - The file path to test
-       * @returns boolean indicating if the path matches
-       */
-      execMatcher(matcher, path3) {
-        if (typeof matcher === "string") {
-          return path3.endsWith(matcher);
-        }
-        if (matcher instanceof RegExp) {
-          return matcher.test(path3);
-        }
-        return matcher(path3);
-      }
-      /**
-       * Converts an absolute path to a path relative to the entrypoint
-       * @param path - The absolute path to convert
-       */
-      resolveRelativePath(path3) {
-        const regex = new RegExp(`^${this.entrypoint}`);
-        return path3.replace(regex, "");
-      }
-      /**
-       * Matches a command by name or path segments
-       * @param commandOrSegment - Command name or array of path segments
-       * @returns Matched command and its middlewares, or null if no match
-       */
-      match(commandOrSegment) {
-        if (!(commandOrSegment == null ? void 0 : commandOrSegment.length)) return null;
-        if (Array.isArray(commandOrSegment) && commandOrSegment.length === 1) {
-          commandOrSegment = commandOrSegment[0];
-        }
-        if (!Array.isArray(commandOrSegment) && !commandOrSegment.includes(" ")) {
-          const command2 = this.commands.get(commandOrSegment);
-          if (!command2) return null;
-          const middlewares2 = command2.middlewares.map((id) => this.middlewares.get(id)).filter((m) => !!m);
-          return {
-            command: command2,
-            middlewares: middlewares2
-          };
-        }
-        const segments = Array.isArray(commandOrSegment) ? commandOrSegment : commandOrSegment.split(" ");
-        const command = Array.from(this.commands.values()).find((cmd) => {
-          const commandSegments = cmd.parentSegments;
-          if (commandSegments.length !== segments.length) return false;
-          return commandSegments.every((segment, index) => {
-            if (/^\[.+\]$/.test(segment)) return true;
-            return segment === segments[index];
-          });
-        });
-        if (!command) return null;
-        const middlewares = command.middlewares.map((id) => this.middlewares.get(id)).filter((m) => !!m);
+      toJSON() {
         return {
-          command,
-          middlewares
+          commands: Object.fromEntries(this.commands.entries()),
+          middlewares: Object.fromEntries(this.middlewares.entries()),
+          subcommands: Object.fromEntries(this.subcommands.entries())
         };
       }
-      /**
-       * Reloads the commands tree by re-scanning the entrypoint directory
-       */
-      async reload() {
-        this.clear();
-        return this.scan();
-      }
-      /**
-       * Clears the internal commands and middleware maps
-       */
-      clear() {
-        this.commands.clear();
-        this.middlewares.clear();
-      }
-      /**
-       * Scans the entrypoint directory for commands and middleware
-       * @returns Promise resolving to the complete commands tree
-       */
       async scan() {
-        this.clear();
-        const files = await this.scanDirectory(this.entrypoint, []);
-        const commandFiles = files.filter((file) => {
-          const basename = import_node_path3.default.basename(file);
-          return !this.isIgnoredFile(basename) && this.isCommandFile(file);
-        });
-        const middlewareFiles = files.filter(
-          (file) => this.execMatcher(this.matchers.middleware, file)
-        );
-        for (const file of commandFiles) {
-          const parsedPath = this.parseCommandPath(file);
-          const location = this.resolveRelativePath(file);
-          const command = {
-            name: parsedPath.name,
-            path: location,
-            fullPath: file,
-            parent: parsedPath.parent,
-            parentSegments: parsedPath.parentSegments,
-            category: parsedPath.category,
-            middlewares: []
-          };
-          this.commands.set(parsedPath.name, command);
-        }
-        for (const file of middlewareFiles) {
-          const location = this.resolveRelativePath(file);
-          const dirname = import_node_path3.default.dirname(location);
-          const id = crypto.randomUUID();
-          const parts = location.split(import_node_path3.default.sep).filter((p) => p);
-          const categories = this.parseCategories(parts);
-          const middleware = {
-            id,
-            name: dirname,
-            path: location,
-            fullPath: file,
-            category: categories.length ? categories.join("/") : null
-          };
-          this.middlewares.set(id, middleware);
-          const isGlobalMiddleware = import_node_path3.default.parse(file).name === "middleware";
-          const commands = Array.from(this.commands.values());
-          for (const command of commands) {
-            const commandDir = import_node_path3.default.dirname(command.path);
-            if (isGlobalMiddleware) {
-              if (commandDir === dirname || commandDir.startsWith(dirname + import_node_path3.default.sep)) {
-                command.middlewares.push(id);
-              }
+        if (!this.isValidPath()) return this.toJSON();
+        const root = this.entrypoint;
+        await this.scanDeep(root);
+        return this.toJSON();
+      }
+      async scanDeep(entry, currentDepth = 2) {
+        const normalizedPath = import_posix.default.normalize(entry);
+        const content = await (0, import_promises3.readdir)(normalizedPath, { withFileTypes: true });
+        for (const item of content) {
+          const itemPath = import_posix.default.join(normalizedPath, item.name);
+          if (this.shouldIgnore(itemPath, item.isDirectory())) continue;
+          if (item.isDirectory()) {
+            const isCategoryDir = this.isCategoryDirectory(item.name);
+            if (currentDepth > 0 || isCategoryDir) {
+              const nextDepth = isCategoryDir ? currentDepth : currentDepth - 1;
+              await this.scanDeep(itemPath, nextDepth);
+            }
+          } else {
+            const isInnerSubCommand = currentDepth === 0;
+            const isSubCommandGroup = currentDepth === 1;
+            const category = this.extractCategory(itemPath);
+            const fileName = this.extractName(itemPath);
+            const isIndexFile = fileName === "index" && normalizedPath !== this.entrypoint;
+            if (this.isMiddleware(itemPath)) {
+              this.processMiddleware(itemPath, category);
+            } else if (isInnerSubCommand || isSubCommandGroup) {
+              this.processSubcommand(
+                itemPath,
+                import_posix.default.basename(normalizedPath),
+                isSubCommandGroup,
+                isIndexFile
+              );
             } else {
-              const commandName = command.name;
-              const middlewareName = import_node_path3.default.basename(file).replace(/\.middleware\.(m|c)?(j|t)sx?$/, "");
-              if (commandName === middlewareName && commandDir === dirname) {
-                command.middlewares.push(id);
-              }
+              this.processCommand(
+                itemPath,
+                category,
+                isIndexFile ? normalizedPath : null
+              );
             }
           }
         }
-        return this.toJSON();
+      }
+      processMiddleware(filePath, category) {
+        const middleware = {
+          id: crypto.randomUUID(),
+          name: this.getAppropriateFileName(filePath),
+          path: filePath,
+          relativePath: this.getRelativePath(filePath),
+          category
+        };
+        this.middlewares.set(middleware.id, middleware);
+        this.applyMiddlewareToCommands(middleware);
+      }
+      processSubcommand(filePath, parentDirName, isGrouped, isIndexFile = false) {
+        const subcommand = {
+          id: crypto.randomUUID(),
+          name: isIndexFile ? this.getDirectoryName(filePath) : this.extractName(filePath),
+          group: isGrouped ? parentDirName : null,
+          middlewares: [],
+          path: filePath,
+          relativePath: this.getRelativePath(filePath)
+        };
+        this.subcommands.set(subcommand.id, subcommand);
+        this.applySubcommandToCommands(subcommand);
+      }
+      processCommand(filePath, category, parentPath = null) {
+        const command = {
+          id: crypto.randomUUID(),
+          name: parentPath ? this.getDirectoryName(parentPath) : this.extractName(filePath),
+          path: filePath,
+          relativePath: this.getRelativePath(filePath),
+          category,
+          middlewares: [],
+          subcommands: []
+        };
+        this.commands.set(command.id, command);
       }
       /**
-       * Converts the internal maps to a serializable object
-       * @returns CommandsTree containing all commands and middleware
+       * Gets the appropriate file name, handling index files specially
+       * For index files, it returns the parent directory name (excluding category markers)
        */
-      toJSON() {
-        return {
-          commands: Object.fromEntries(this.commands),
-          middleware: Object.fromEntries(this.middlewares)
-        };
+      getAppropriateFileName(filePath) {
+        const fileName = this.extractName(filePath);
+        if (fileName === "index" && import_posix.default.dirname(filePath) !== this.entrypoint) {
+          return this.getDirectoryName(filePath);
+        }
+        return fileName;
       }
       /**
-       * Recursively scans a directory for files
-       * @param dir - Directory to scan
-       * @param entries - Accumulator for found files
-       * @returns Promise resolving to array of file paths
+       * Extract the clean directory name, removing any category markers
        */
-      async scanDirectory(dir, entries) {
-        const files = await (0, import_promises3.readdir)(dir, {
-          withFileTypes: true
-        });
-        for (const file of files) {
-          if (file.name === "node_modules" || file.parentPath.includes("node_modules")) {
-            continue;
-          }
-          if (file.isDirectory()) {
-            const next = (0, import_node_path3.join)(dir, file.name);
-            await this.scanDirectory(next, entries);
-            continue;
-          }
-          entries.push((0, import_node_path3.join)(dir, file.name));
+      getDirectoryName(filePath) {
+        const dirName = import_posix.default.basename(import_posix.default.dirname(filePath));
+        return dirName.replace(/^\((\w+)\)$/, "$1");
+      }
+      // Helper method to identify category directories
+      isCategoryDirectory(dirName) {
+        return /^\(\w+\)$/.test(dirName);
+      }
+      applyMiddlewareToCommands(middleware) {
+        for (const command of this.commands.values()) {
+          const middlewareFileName = import_posix.default.basename(middleware.path);
+          const match = middlewareFileName.startsWith(command.name) || middlewareFileName === "middleware";
+          if (!match) continue;
+          if (command.middlewares.includes(middleware.id)) continue;
+          command.middlewares.push(middleware.id);
         }
-        return entries;
       }
-      isIgnoredFile(filename) {
-        return filename.startsWith("_");
+      applySubcommandToCommands(subcommand) {
+        for (const command of this.commands.values()) {
+          if (!subcommand.path.startsWith(command.path)) continue;
+          if (command.subcommands.includes(subcommand.id)) continue;
+          command.subcommands.push(subcommand.id);
+        }
       }
-      isCommandFile(path3) {
-        if (this.execMatcher(this.matchers.middleware, path3)) return false;
-        return /index\.(m|c)?(j|t)sx?$/.test(path3) || /\.(m|c)?(j|t)sx?$/.test(path3);
+      extractCategory(entry) {
+        return entry.split(import_posix.default.sep).map((segment) => {
+          const match = segment.match(/^\((\w+)\)$/);
+          return match ? match[1] : null;
+        }).filter(Boolean).join(":");
       }
-      parseCategories(parts) {
-        return parts.filter((part) => part.startsWith("(") && part.endsWith(")")).map((part) => part.slice(1, -1));
+      getRelativePath(entry) {
+        return import_posix.default.relative(this.entrypoint, entry);
       }
-      parseCommandPath(filepath) {
-        const location = this.resolveRelativePath(filepath);
-        const parts = location.split(import_node_path3.default.sep).filter((p) => p);
-        const categories = this.parseCategories(parts);
-        const segments = parts.filter(
-          (part) => !(part.startsWith("(") && part.endsWith(")"))
-        );
-        let name = segments.pop() || "";
-        name = name.replace(/\.(m|c)?(j|t)sx?$/, "").replace(/^index$/, "");
-        return {
-          name,
-          category: categories.length ? categories.join("/") : null,
-          parent: segments.length ? segments.join(" ") : null,
-          parentSegments: segments
-        };
+      isMiddleware(entry) {
+        return !this.shouldIgnore(entry) && ["middleware", ".middleware."].some((ext) => entry.includes(ext));
+      }
+      shouldIgnore(entry, dir = false) {
+        const fileName = import_posix.default.basename(entry);
+        if (fileName.startsWith("_")) return true;
+        if (!dir) return !/.(c|m)?(j|t)sx?$/.test(fileName);
+        return false;
+      }
+      extractName(entry) {
+        return import_posix.default.basename(entry).replace(/\.(c|m)?(j|t)sx?$/, "");
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -3650,14 +4017,14 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_node_fs3, import_promises4, import_node_path4, _EventsRouter, EventsRouter;
+var import_node_fs4, import_promises4, import_node_path3, _EventsRouter, EventsRouter;
 var init_EventsRouter = __esm({
   "src/app/router/EventsRouter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs3 = require("fs");
+    import_node_fs4 = require("fs");
     import_promises4 = require("fs/promises");
-    import_node_path4 = require("path");
+    import_node_path3 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
        * Creates a new EventsRouter instance
@@ -3691,7 +4058,7 @@ var init_EventsRouter = __esm({
        * Checks if the entrypoint path is valid
        */
       isValidPath() {
-        return (0, import_node_fs3.existsSync)(this.entrypoint);
+        return (0, import_node_fs4.existsSync)(this.entrypoint);
       }
       /**
        * Clear all parsed events
@@ -3715,7 +4082,7 @@ var init_EventsRouter = __esm({
         const dirs = await (0, import_promises4.readdir)(this.entrypoint, { withFileTypes: true });
         for (const dir of dirs) {
           if (dir.isDirectory()) {
-            const path3 = (0, import_node_path4.join)(this.entrypoint, dir.name);
+            const path3 = (0, import_node_path3.join)(this.entrypoint, dir.name);
             const event = await this.scanEvent(dir.name, path3);
             this.events.set(event.event, event);
           }
@@ -3742,12 +4109,12 @@ var init_EventsRouter = __esm({
         for (const file of files) {
           if (/node_modules/.test(file.name)) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path4.join)(path3, file.name);
+            const nextPath = (0, import_node_path3.join)(path3, file.name);
             await this.scanEvent(event, nextPath, listeners);
             continue;
           }
           if (file.isFile() && /\.(m|c)?(j|t)sx?$/.test(file.name)) {
-            listeners.push((0, import_node_path4.join)(file.parentPath, file.name));
+            listeners.push((0, import_node_path3.join)(file.parentPath, file.name));
           }
         }
         const maybeNamespace = path3.replace(this.entrypoint, "").replaceAll("\\", "/").split("/").shift();
@@ -3799,7 +4166,10 @@ var init_AppEventsHandler = __esm({
                 `Event handler for ${event.event}${event.namespace ? ` of namespace ${event.namespace}` : ""} does not have a default export or is not a function`
               );
             }
-            listeners.push(handler.default);
+            listeners.push({
+              handler: handler.default,
+              once: !!handler.once
+            });
           }
           const len = listeners.length;
           if (!len) {
@@ -3827,11 +4197,28 @@ var init_AppEventsHandler = __esm({
       registerAllClientEvents() {
         const client = this.commandkit.client;
         for (const [key, data] of this.loadedEvents.entries()) {
-          const { name, listeners, namespace, mainListener } = data;
-          const main = mainListener || (async (...args) => {
-            for (const listener of listeners) {
+          const { name, listeners, namespace } = data;
+          const onceListeners = listeners.filter((listener) => listener.once);
+          const onListeners = listeners.filter((listener) => !listener.once);
+          const executedOnceListeners = /* @__PURE__ */ new Set();
+          const mainHandler = /* @__PURE__ */ __name(async (...args) => {
+            for (const listener of onListeners) {
+              try {
+                await listener.handler(...args);
+              } catch (e) {
+                Logger.error(
+                  `Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`,
+                  e
+                );
+              }
+            }
+          }, "mainHandler");
+          const onceHandler = /* @__PURE__ */ __name(async (...args) => {
+            for (const listener of onceListeners) {
               try {
-                await listener(...args);
+                if (executedOnceListeners.has(listener.handler)) continue;
+                await listener.handler(...args);
+                executedOnceListeners.add(listener.handler);
               } catch (e) {
                 Logger.error(
                   `Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`,
@@ -3839,16 +4226,35 @@ var init_AppEventsHandler = __esm({
                 );
               }
             }
+            if (executedOnceListeners.size === onceListeners.length && onListeners.length === 0) {
+              this.loadedEvents.delete(key);
+              Logger.info(
+                `\u{1F9F9} Cleaned up completed once-only event ${name}${namespace ? ` of namespace ${namespace}` : ""}`
+              );
+            }
+          }, "onceHandler");
+          this.loadedEvents.set(key, {
+            ...data,
+            mainListener: onListeners.length > 0 ? { handler: mainHandler, once: false } : void 0,
+            executedOnceListeners
           });
-          if (!mainListener) {
-            this.loadedEvents.set(key, {
-              ...data,
-              mainListener: main
-            });
+          if (namespace) {
+            if (onListeners.length > 0) {
+              this.commandkit.events.on(namespace, name, mainHandler);
+            }
+            if (onceListeners.length > 0) {
+              this.commandkit.events.once(namespace, name, onceHandler);
+            }
+          } else {
+            if (onListeners.length > 0) {
+              client.on(name, mainHandler);
+            }
+            if (onceListeners.length > 0) {
+              client.once(name, onceHandler);
+            }
           }
-          client.on(name, main);
           Logger.info(
-            `\u{1F50C} Registered event ${name}${namespace ? ` of namespace ${namespace}` : ""}`
+            `\u{1F50C} Registered event ${name}${namespace ? ` of namespace ${namespace}` : ""} (${onListeners.length} regular, ${onceListeners.length} once-only)`
           );
         }
       }
@@ -3859,9 +4265,17 @@ var init_AppEventsHandler = __esm({
           { name, mainListener, namespace }
         ] of this.loadedEvents.entries()) {
           if (mainListener) {
-            client.off(name, mainListener);
+            if (namespace) {
+              this.commandkit.events.off(namespace, name, mainListener.handler);
+            } else {
+              client.off(name, mainListener.handler);
+            }
           } else {
-            client.removeAllListeners(name);
+            if (namespace) {
+              this.commandkit.events.removeAllListeners(namespace, name);
+            } else {
+              client.removeAllListeners(name);
+            }
           }
           this.loadedEvents.delete(key);
           Logger.info(
@@ -3875,6 +4289,54 @@ var init_AppEventsHandler = __esm({
   }
 });
 
+// src/utils/types-package.ts
+async function generateTypesPackage() {
+  const location = (0, import_node_path4.join)(process.cwd(), "node_modules", "commandkit-types");
+  const packageJSON = (0, import_node_path4.join)(location, "package.json");
+  const index = (0, import_node_path4.join)(location, "index.js");
+  const types = (0, import_node_path4.join)(location, "index.d.ts");
+  const locale = (0, import_node_path4.join)(location, "locale.d.ts");
+  const command = (0, import_node_path4.join)(location, "command.d.ts");
+  const exists = (0, import_node_fs5.existsSync)(packageJSON);
+  if (exists) return location;
+  const packageJSONContent = {
+    name: "commandkit-types",
+    version: "1.0.0",
+    description: "CommandKit types package",
+    type: "commonjs",
+    main: "index.js",
+    types: "index.d.ts"
+  };
+  const indexContent = `module.exports = {};`;
+  const typesContent = `import { CommandLocalizationTypeData } from './locale.d.ts';
+  import { CommandTypeData } from './command.d.ts';
+  
+  declare module 'commandkit' {
+    export interface CommandKitTypeReferences {
+      locale: CommandLocalizationTypeData;
+      command: CommandTypeData;
+    }
+  }`;
+  await (0, import_promises5.mkdir)(location, { recursive: true });
+  await (0, import_promises5.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+  await (0, import_promises5.writeFile)(index, indexContent);
+  await (0, import_promises5.writeFile)(types, typesContent);
+  await (0, import_promises5.writeFile)(locale, "");
+  await (0, import_promises5.writeFile)(command, "");
+  return location;
+}
+var import_node_fs5, import_promises5, import_node_path4;
+var init_types_package = __esm({
+  "src/utils/types-package.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs5 = require("fs");
+    import_promises5 = require("fs/promises");
+    import_node_path4 = require("path");
+    __name(generateTypesPackage, "generateTypesPackage");
+  }
+});
+
 // src/cli/common.ts
 function write(message) {
   process.stdout.write(message);
@@ -3902,7 +4364,7 @@ async function loadConfigFileFromPath(target) {
   const isTs = await ensureTypeScript(target);
   if (isTs && ts) {
     const { transpileModule } = ts;
-    const src = import_node_fs4.default.readFileSync(target, "utf8");
+    const src = import_node_fs6.default.readFileSync(target, "utf8");
     const { outputText } = transpileModule(src, {
       compilerOptions: {
         module: ts.ModuleKind.ESNext,
@@ -3911,14 +4373,9 @@ async function loadConfigFileFromPath(target) {
       },
       fileName: target
     });
-    const nodeModulesPath = (0, import_node_path5.join)(
-      process.cwd(),
-      "node_modules",
-      ".commandkit_tmp"
-    );
-    import_node_fs4.default.mkdirSync(nodeModulesPath, { recursive: true });
+    const nodeModulesPath = await generateTypesPackage();
     const tmpFile = (0, import_node_path5.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
-    import_node_fs4.default.writeFileSync(tmpFile, outputText);
+    import_node_fs6.default.writeFileSync(tmpFile, outputText);
     target = tmpFile;
   }
   const config = await import(`file://${target}`).then(
@@ -3927,20 +4384,21 @@ async function loadConfigFileFromPath(target) {
   return config;
 }
 async function ensureExists(loc) {
-  const exists = import_node_fs4.default.existsSync(loc);
+  const exists = import_node_fs6.default.existsSync(loc);
   if (!exists) {
     throw new Error(`File not found: ${loc}`);
   }
 }
-var import_rimraf, import_node_path5, import_node_fs4, ts;
+var import_rimraf, import_node_path5, import_node_fs6, ts;
 var init_common = __esm({
   "src/cli/common.ts"() {
     "use strict";
     init_cjs_shims();
     import_rimraf = require("rimraf");
     import_node_path5 = require("path");
-    import_node_fs4 = __toESM(require("fs"));
+    import_node_fs6 = __toESM(require("fs"));
     init_colors();
+    init_types_package();
     __name(write, "write");
     __name(panic, "panic");
     __name(ensureTypeScript, "ensureTypeScript");
@@ -3953,7 +4411,7 @@ var init_common = __esm({
 function findConfigFile(cwd) {
   const locations = CONFIG_FILE_NAMES.map((name) => (0, import_node_path6.join)(cwd, name));
   for (const location of locations) {
-    if ((0, import_node_fs5.existsSync)(location)) {
+    if ((0, import_node_fs7.existsSync)(location)) {
       return {
         path: location,
         isTypeScript: /\.ts$/.test(location)
@@ -3970,12 +4428,12 @@ async function loadConfigFile(entrypoint = process.cwd()) {
   loadedConfig = config;
   return config;
 }
-var import_node_fs5, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
+var import_node_fs7, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs5 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_path6 = require("path");
     init_common();
     init_config();
@@ -3994,12 +4452,13 @@ var init_loader = __esm({
 // src/utils/dev-hooks.ts
 function registerDevHooks(commandkit) {
   if (!COMMANDKIT_IS_DEV) return;
-  process.stdin.on("data", (chunk) => {
-    const input = chunk.toString().trim();
-    const match = input.match(EVENT_PATTERN);
-    if (!match) return;
-    const [, event, , path3] = match;
-    Logger.info(`Received HMR event: ${event}${path3 ? ` for ${path3}` : ""}`);
+  process.on("message", (message) => {
+    if (typeof message !== "object" || message === null) return;
+    const { event, path: path3 } = message;
+    if (!event) return;
+    if (process.env.COMMANDKIT_DEBUG_HMR === "true") {
+      Logger.info(`Received HMR event: ${event}${path3 ? ` for ${path3}` : ""}`);
+    }
     switch (event) {
       case "reload-commands":
         commandkit.commandHandler.reloadCommands();
@@ -4013,31 +4472,75 @@ function registerDevHooks(commandkit) {
     }
   });
 }
-var EVENT_PATTERN;
 var init_dev_hooks = __esm({
   "src/utils/dev-hooks.ts"() {
     "use strict";
     init_cjs_shims();
     init_Logger();
     init_constants();
-    EVENT_PATTERN = /^COMMANDKIT_EVENT=(\w+)(\|(.+))?$/;
     __name(registerDevHooks, "registerDevHooks");
   }
 });
 
+// src/events/CommandKitEventsChannel.ts
+var import_node_events, _CommandKitEventsChannel, CommandKitEventsChannel;
+var init_CommandKitEventsChannel = __esm({
+  "src/events/CommandKitEventsChannel.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_events = __toESM(require("events"));
+    _CommandKitEventsChannel = class _CommandKitEventsChannel {
+      constructor(commandkit) {
+        this.commandkit = commandkit;
+      }
+      emitter = new import_node_events.default();
+      to(namespace) {
+        return {
+          on: this.on.bind(this, namespace),
+          off: this.off.bind(this, namespace),
+          once: this.once.bind(this, namespace),
+          emit: this.emit.bind(this, namespace),
+          removeAllListeners: this.removeAllListeners.bind(this, namespace)
+        };
+      }
+      on(namespace, event, listener) {
+        this.emitter.on(`${namespace}:${event}`, listener);
+      }
+      off(namespace, event, listener) {
+        this.emitter.off(`${namespace}:${event}`, listener);
+      }
+      once(namespace, event, listener) {
+        this.emitter.once(`${namespace}:${event}`, listener);
+      }
+      emit(namespace, event, ...args) {
+        return this.emitter.emit(`${namespace}:${event}`, ...args);
+      }
+      removeAllListeners(namespace, event) {
+        if (event) {
+          this.emitter.removeAllListeners(`${namespace}:${event}`);
+        } else {
+          this.emitter.removeAllListeners(namespace);
+        }
+      }
+    };
+    __name(_CommandKitEventsChannel, "CommandKitEventsChannel");
+    CommandKitEventsChannel = _CommandKitEventsChannel;
+  }
+});
+
 // src/CommandKit.ts
-var import_node_events, import_discord11, import_node_path7, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
+var import_node_events2, import_discord12, import_node_path7, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_events = __toESM(require("events"));
+    import_node_events2 = __toESM(require("events"));
     init_colors();
     init_CacheProvider();
     init_MemoryCache();
     init_components();
     init_EventInterceptor();
-    import_discord11 = require("discord.js");
+    import_discord12 = require("discord.js");
     init_DefaultLocalizationStrategy();
     init_utilities();
     import_node_path7 = require("path");
@@ -4048,7 +4551,11 @@ var init_CommandKit = __esm({
     init_loader();
     init_constants();
     init_dev_hooks();
-    _CommandKit = class _CommandKit extends import_node_events.default {
+    init_CommandKitEventsChannel();
+    init_plugins();
+    init_types_package();
+    init_Logger();
+    _CommandKit = class _CommandKit extends import_node_events2.default {
       /**
        * Create a new command and event handler with CommandKit.
        *
@@ -4080,7 +4587,7 @@ var init_CommandKit = __esm({
         __privateAdd(this, _started, false);
         __publicField(this, "eventInterceptor");
         __publicField(this, "config", {
-          defaultLocale: import_discord11.Locale.EnglishUS,
+          defaultLocale: import_discord12.Locale.EnglishUS,
           localizationStrategy: new DefaultLocalizationStrategy(this),
           getMessageCommandPrefix: /* @__PURE__ */ __name(() => "!", "getMessageCommandPrefix")
         });
@@ -4089,6 +4596,7 @@ var init_CommandKit = __esm({
         __publicField(this, "commandHandler", new AppCommandHandler(this));
         __publicField(this, "eventHandler", new AppEventsHandler(this));
         __publicField(this, "plugins");
+        __publicField(this, "events", new CommandKitEventsChannel(this));
         options.debugCommands ??= process.env.NODE_ENV !== "production";
         if (options.cacheProvider !== null && (!options.cacheProvider || !(options.cacheProvider instanceof CacheProvider))) {
           options.cacheProvider = new MemoryCache();
@@ -4104,8 +4612,18 @@ var init_CommandKit = __esm({
        * @param token The application token to connect to the discord gateway. If not provided, it will use the `TOKEN` or `DISCORD_TOKEN` environment variable. If set to `false`, it will not login.
        */
       async start(token) {
-        await loadConfigFile();
         if (__privateGet(this, _started)) return;
+        if (COMMANDKIT_IS_DEV) {
+          try {
+            registerDevHooks(this);
+            await generateTypesPackage();
+          } catch (e) {
+            if (process.env.COMMANDKIT_DEBUG_TYPEGEN) {
+              Logger.error(e);
+            }
+          }
+        }
+        await this.loadPlugins();
         await __privateMethod(this, _CommandKit_instances, init_fn).call(this);
         this.incrementClientListenersCount();
         if (token !== false && !this.options.client.isReady()) {
@@ -4114,11 +4632,19 @@ var init_CommandKit = __esm({
           );
         }
         __privateSet(this, _started, true);
-        if (COMMANDKIT_IS_DEV) {
-          registerDevHooks(this);
-        }
         await this.commandHandler.registrar.register();
       }
+      /**
+       * Loads all the plugins.
+       */
+      async loadPlugins() {
+        const config = await loadConfigFile();
+        const plugins = config.plugins.filter((p) => isRuntimePlugin(p));
+        if (!plugins.length) return;
+        for (const plugin of plugins) {
+          await this.plugins.softRegisterPlugin(plugin);
+        }
+      }
       /**
        * Whether or not the commandkit application has started.
        */
@@ -4275,6 +4801,10 @@ var init_CommandKit = __esm({
     initCommands_fn = /* @__PURE__ */ __name(async function() {
       if (this.commandsRouter.isValidPath()) {
         await this.commandsRouter.scan();
+        if (COMMANDKIT_IS_DEV) {
+          const visual = this.commandsRouter.visualize();
+          console.log(visual);
+        }
       }
       await this.commandHandler.loadCommands();
     }, "#initCommands");
@@ -4303,7 +4833,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250306101654";
+    "0.1.11-dev.20250307192025";
   }
 });
 
@@ -4337,11 +4867,18 @@ var init_env = __esm({
 });
 
 // src/cli/app-process.ts
+function getStdio(supportsCommands) {
+  if (supportsCommands) {
+    return ["pipe", "pipe", "pipe", "ipc"];
+  }
+  return ["pipe", "pipe", "pipe"];
+}
 function createAppProcess(fileName, cwd, isDev) {
   var _a, _b;
-  if (!(0, import_node_fs6.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
+  if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
     panic(`Could not locate the entrypoint file: ${fileName}`);
   }
+  const stdio = getStdio(isDev);
   const ps = (0, import_node_child_process.spawn)(
     "node",
     [
@@ -4353,14 +4890,14 @@ function createAppProcess(fileName, cwd, isDev) {
       cwd,
       windowsHide: true,
       env: DevEnv(),
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio
     }
   );
   (_a = ps.stdout) == null ? void 0 : _a.pipe(process.stdout);
   (_b = ps.stderr) == null ? void 0 : _b.pipe(process.stderr);
   return ps;
 }
-var import_node_child_process, import_node_path8, import_node_fs6;
+var import_node_child_process, import_node_path8, import_node_fs8;
 var init_app_process = __esm({
   "src/cli/app-process.ts"() {
     "use strict";
@@ -4368,8 +4905,9 @@ var init_app_process = __esm({
     import_node_child_process = require("child_process");
     init_env();
     import_node_path8 = require("path");
-    import_node_fs6 = require("fs");
+    import_node_fs8 = require("fs");
     init_common();
+    __name(getStdio, "getStdio");
     __name(createAppProcess, "createAppProcess");
   }
 });
@@ -4454,9 +4992,9 @@ async function main() {
 await main();
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
-  await (0, import_promises5.writeFile)((0, import_node_path9.join)(configPath, dist, "index.js"), code);
+  await (0, import_promises6.writeFile)((0, import_node_path9.join)(configPath, dist, "index.js"), code);
 }
-var import_tsup, import_promises5, import_node_path9, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
+var import_tsup, import_promises6, import_node_path9, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -4464,7 +5002,7 @@ var init_build = __esm({
     import_tsup = require("tsup");
     init_plugins();
     init_loader();
-    import_promises5 = require("fs/promises");
+    import_promises6 = require("fs/promises");
     import_node_path9 = require("path");
     init_env();
     __name(buildApplication, "buildApplication");
@@ -4531,7 +5069,11 @@ async function buildAndStart(configPath, skipStart = false) {
     esbuildPlugins: config.esbuildPlugins
   });
   if (skipStart) return null;
-  return createAppProcess(mainFile, configPath, true);
+  const ps = createAppProcess(mainFile, configPath, true);
+  ps.on("message", (message) => {
+    console.log(`Received message from child process: ${message}`);
+  });
+  return ps;
 }
 async function bootstrapDevelopmentServer(configPath) {
   const start = performance.now();
@@ -4542,13 +5084,13 @@ async function bootstrapDevelopmentServer(configPath) {
   let ps = null;
   const performHMR = debounce(async (path3) => {
     if (!path3 || !ps) return false;
+    if (!ps.send) return false;
     if (isCommandSource(path3)) {
       console.log(
         `${colors_default.cyanBright("Reloading command(s) at ")} ${colors_default.yellowBright(path3)}`
       );
       await buildAndStart(cwd, true);
-      ps.stdin.write(`COMMANDKIT_EVENT=reload-commands|${path3}
-`);
+      ps.send({ event: "reload-commands", path: path3 });
       return true;
     }
     if (isEventSource(path3)) {
@@ -4556,8 +5098,7 @@ async function bootstrapDevelopmentServer(configPath) {
         `${colors_default.cyanBright("Reloading event(s) at ")} ${colors_default.yellowBright(path3)}`
       );
       await buildAndStart(cwd, true);
-      ps.stdin.write(`COMMANDKIT_EVENT=reload-events|${path3}
-`);
+      ps.send({ event: "reload-events", path: path3 });
       return true;
     }
     if (isLocaleSource(path3)) {
@@ -4565,14 +5106,17 @@ async function bootstrapDevelopmentServer(configPath) {
         `${colors_default.cyanBright("Reloading locale(s) at ")} ${colors_default.yellowBright(path3)}`
       );
       await buildAndStart(cwd, true);
-      ps.stdin.write(`COMMANDKIT_EVENT=reload-locales|${path3}
-`);
+      ps.send({ event: "reload-locales", path: path3 });
       return true;
     }
     return false;
   }, 300);
   const hmrHandler = /* @__PURE__ */ __name(async (path3) => {
-    if (await performHMR(path3)) return;
+    const hmr = await performHMR(path3);
+    if (hmr) return;
+    console.log(
+      `${colors_default.yellowBright("\u26A1\uFE0F Performing full restart due to the changes in")} ${colors_default.cyanBright(path3)}`
+    );
     ps == null ? void 0 : ps.kill();
     ps = await buildAndStart(cwd);
   }, "hmrHandler");
@@ -4587,18 +5131,15 @@ async function bootstrapDevelopmentServer(configPath) {
         break;
       case "rc":
         console.log(`Received reload commands command, reloading...`);
-        ps == null ? void 0 : ps.stdin.write(`COMMANDKIT_EVENT=reload-commands
-`);
+        ps == null ? void 0 : ps.send({ event: "reload-commands" });
         break;
       case "re":
         console.log(`Received reload events command, reloading...`);
-        ps == null ? void 0 : ps.stdin.write(`COMMANDKIT_EVENT=reload-events
-`);
+        ps == null ? void 0 : ps.send({ event: "reload-events" });
         break;
       case "rl":
         console.log(`Received reload locales command, reloading...`);
-        ps == null ? void 0 : ps.stdin.write(`COMMANDKIT_EVENT=reload-locales
-`);
+        ps == null ? void 0 : ps.send({ event: "reload-locales" });
         break;
     }
   });
@@ -4606,7 +5147,7 @@ async function bootstrapDevelopmentServer(configPath) {
   watcher.on("add", hmrHandler);
   watcher.on("unlink", hmrHandler);
   watcher.on("unlinkDir", (path3) => {
-    const hasChild = (0, import_node_fs7.readdirSync)(path3).length > 0;
+    const hasChild = (0, import_node_fs9.readdirSync)(path3).length > 0;
     if (hasChild) return hmrHandler(path3);
   });
   watcher.on("error", (e) => {
@@ -4625,7 +5166,7 @@ ${colors_default.yellowBright("re")} - Reload all events
 ${colors_default.yellowBright("rl")} - Reload all locales`
   );
 }
-var import_path2, import_chokidar, import_node_fs7, isCommandSource, isEventSource, isLocaleSource;
+var import_path2, import_chokidar, import_node_fs9, isCommandSource, isEventSource, isLocaleSource;
 var init_development = __esm({
   "src/cli/development.ts"() {
     "use strict";
@@ -4636,7 +5177,7 @@ var init_development = __esm({
     init_app_process();
     init_build();
     import_chokidar = require("chokidar");
-    import_node_fs7 = require("fs");
+    import_node_fs9 = require("fs");
     init_utilities();
     init_colors();
     __name(buildAndStart, "buildAndStart");
@@ -4723,7 +5264,7 @@ __export(generators_exports, {
 });
 async function generateCommand(name, customPath) {
   const cmdPath = (0, import_path4.join)(customPath || COMMANDS_DIR, name);
-  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises6.mkdir)(cmdPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises7.mkdir)(cmdPath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(cmdPath, "command.ts"))) {
     panic(`Command ${name} already exists.`);
   }
@@ -4743,7 +5284,7 @@ export const message: MessageCommand = async (ctx) => {
   await ctx.message.reply('Hello from ${name}!');
 };
 `.trim();
-  await (0, import_promises6.writeFile)((0, import_path4.join)(cmdPath, "command.ts"), commandFile);
+  await (0, import_promises7.writeFile)((0, import_path4.join)(cmdPath, "command.ts"), commandFile);
   console.log(
     colors_default.green(
       `Command ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(cmdPath))}/command.ts`
@@ -4752,10 +5293,10 @@ export const message: MessageCommand = async (ctx) => {
 }
 async function generateEvent(name, customPath) {
   const eventPath = (0, import_path4.join)(customPath || EVENTS_DIR, name);
-  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises6.mkdir)(eventPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises7.mkdir)(eventPath, { recursive: true });
   let filename = "event.ts";
   if ((0, import_fs2.existsSync)((0, import_path4.join)(eventPath, filename))) {
-    const count = (await (0, import_promises6.readdir)(eventPath)).length;
+    const count = (await (0, import_promises7.readdir)(eventPath)).length;
     filename = `${String(count).padStart(2, "0")}_${filename}`;
   }
   const eventFile = `
@@ -4763,7 +5304,7 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
   console.log('${name} event fired!');
 };
 `.trim();
-  await (0, import_promises6.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
+  await (0, import_promises7.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
   console.log(
     colors_default.green(
       `Event ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(eventPath))}/${colors_default.magenta(filename)}`
@@ -4772,7 +5313,7 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
 }
 async function generateLocale(locale, commandName, customPath) {
   const localeNames = Object.fromEntries(
-    Object.entries(import_discord12.Locale).map(([k, v]) => [v, k])
+    Object.entries(import_discord13.Locale).map(([k, v]) => [v, k])
   );
   if (!localeNames[locale]) {
     panic(`Invalid locale: ${locale}`);
@@ -4781,7 +5322,7 @@ async function generateLocale(locale, commandName, customPath) {
     panic("Command name is required.");
   }
   const localePath = (0, import_path4.join)(customPath || LOCALES_DIR, locale);
-  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises6.mkdir)(localePath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises7.mkdir)(localePath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(localePath, `${commandName}.json`))) {
     panic(`Locale file for ${commandName} already exists.`);
   }
@@ -4792,7 +5333,7 @@ async function generateLocale(locale, commandName, customPath) {
     },
     translations: {}
   };
-  await (0, import_promises6.writeFile)(
+  await (0, import_promises7.writeFile)(
     (0, import_path4.join)(localePath, `${commandName}.json`),
     JSON.stringify(localeFile, null, 2)
   );
@@ -4804,14 +5345,14 @@ async function generateLocale(locale, commandName, customPath) {
     )
   );
 }
-var import_promises6, import_path4, import_discord12, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
+var import_promises7, import_path4, import_discord13, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
 var init_generators = __esm({
   "src/cli/generators.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises6 = require("fs/promises");
+    import_promises7 = require("fs/promises");
     import_path4 = require("path");
-    import_discord12 = require("discord.js");
+    import_discord13 = require("discord.js");
     init_common();
     import_fs2 = require("fs");
     init_colors();