commandkit 0.1.11-dev.20250309035914 → 0.1.11-dev.20250327153237

package/dist/index.js

@@ -1372,9 +1372,9 @@ var init_CommandKitPluginRuntime = __esm({
     init_Logger();
     init_runtime_events();
     _CommandKitPluginRuntime = class _CommandKitPluginRuntime extends EventTarget {
-      constructor(commandkit) {
+      constructor(commandkit2) {
         super();
-        this.commandkit = commandkit;
+        this.commandkit = commandkit2;
       }
       plugins = new import_discord7.Collection();
       onClientLogin = /* @__PURE__ */ __name(() => {
@@ -1493,12 +1493,12 @@ var init_CompilerPluginRuntime = __esm({
         return !this.plugins.length;
       }
       async onLoad(args) {
-        var _a;
+        var _a, _b;
         const source = await (0, import_promises.readFile)(args.path, "utf8");
-        let contents = source, loader = args.path.split(".").pop();
+        let contents = source, loader = (_a = args.path) == null ? void 0 : _a.split(".").pop();
         for (const plugin of this.plugins) {
           try {
-            const res = await ((_a = plugin.transform) == null ? void 0 : _a.call(plugin, {
+            const res = await ((_b = plugin.transform) == null ? void 0 : _b.call(plugin, {
               contents,
               path: args.path,
               loader,
@@ -1695,6 +1695,7 @@ var init_UseCacheTransformer = __esm({
       ).join("");
     }, "generateRandomString");
     cacheDirectivePlugin = /* @__PURE__ */ __name(async (source, args) => {
+      var _a;
       const ast = parser.parse(source, {
         sourceType: "module",
         plugins: ["typescript", "jsx"]
@@ -1707,22 +1708,22 @@ var init_UseCacheTransformer = __esm({
       };
       traverse(ast, {
         Program: {
-          enter(path3) {
-            const binding = path3.scope.getBinding(CACHE_IDENTIFIER);
+          enter(path2) {
+            const binding = path2.scope.getBinding(CACHE_IDENTIFIER);
             if (binding) {
               state.cacheIdentifierName = `${CACHE_IDENTIFIER}_${generateRandomString()}`;
             }
           }
         },
-        ImportDeclaration(path3) {
-          if (path3.node.source.value === IMPORT_PATH && path3.node.specifiers.some(
+        ImportDeclaration(path2) {
+          if (path2.node.source.value === IMPORT_PATH && path2.node.specifiers.some(
             (spec) => t.isImportSpecifier(spec) && // @ts-ignore
             spec.imported.name === CACHE_IDENTIFIER
           )) {
             state.hasExistingImport = true;
             if (state.cacheIdentifierName !== CACHE_IDENTIFIER) {
               state.modifications.push(() => {
-                path3.node.specifiers.forEach((spec) => {
+                path2.node.specifiers.forEach((spec) => {
                   if (t.isImportSpecifier(spec) && // @ts-ignore
                   spec.imported.name === CACHE_IDENTIFIER) {
                     spec.local.name = state.cacheIdentifierName;
@@ -1732,14 +1733,14 @@ var init_UseCacheTransformer = __esm({
             }
           }
         },
-        "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod"(path3) {
-          var _a, _b, _c;
-          const body = t.isBlockStatement(path3.node.body) ? path3.node.body : null;
-          const hasUseCache = (_a = body == null ? void 0 : body.directives) == null ? void 0 : _a.some(
+        "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod"(path2) {
+          var _a2, _b, _c;
+          const body = t.isBlockStatement(path2.node.body) ? path2.node.body : null;
+          const hasUseCache = (_a2 = body == null ? void 0 : body.directives) == null ? void 0 : _a2.some(
             (d) => d.value.value === DIRECTIVE
           );
-          if (!hasUseCache && !t.isBlockStatement(path3.node.body)) {
-            const parentFunction = path3.findParent(
+          if (!hasUseCache && !t.isBlockStatement(path2.node.body)) {
+            const parentFunction = path2.findParent(
               (p) => (p.isFunction() || p.isProgram()) && "directives" in p.node
             );
             if (!((_b = parentFunction == null ? void 0 : parentFunction.node.directives) == null ? void 0 : _b.some(
@@ -1748,35 +1749,35 @@ var init_UseCacheTransformer = __esm({
               return;
             }
           }
-          if (hasUseCache || !t.isBlockStatement(path3.node.body)) {
-            if (!path3.node.async) {
+          if (hasUseCache || !t.isBlockStatement(path2.node.body)) {
+            if (!path2.node.async) {
               throw new Error(
                 `"${DIRECTIVE}" directive may only be used in async functions at ${args.path}
 
-${path3.toString()}
+${path2.toString()}
 ^^^^${"-".repeat(6)} This function must be async`
               );
             }
             state.needsImport = true;
-            const isDeclaration = t.isFunctionDeclaration(path3.node);
-            const name = isDeclaration ? (_c = path3.node.id) == null ? void 0 : _c.name : void 0;
-            const newBody = t.isBlockStatement(path3.node.body) ? t.blockStatement(
-              path3.node.body.body,
-              path3.node.body.directives.filter(
+            const isDeclaration = t.isFunctionDeclaration(path2.node);
+            const name = isDeclaration ? (_c = path2.node.id) == null ? void 0 : _c.name : void 0;
+            const newBody = t.isBlockStatement(path2.node.body) ? t.blockStatement(
+              path2.node.body.body,
+              path2.node.body.directives.filter(
                 (d) => d.value.value !== DIRECTIVE
               )
-            ) : path3.node.body;
+            ) : path2.node.body;
             const wrapped = t.callExpression(
               t.identifier(state.cacheIdentifierName),
-              [t.arrowFunctionExpression(path3.node.params, newBody, true)]
+              [t.arrowFunctionExpression(path2.node.params, newBody, true)]
             );
             state.modifications.push(() => {
-              if (t.isObjectMethod(path3.node)) {
-                path3.replaceWith(
-                  t.objectProperty(t.identifier(path3.node.key.name), wrapped)
+              if (t.isObjectMethod(path2.node)) {
+                path2.replaceWith(
+                  t.objectProperty(t.identifier(path2.node.key.name), wrapped)
                 );
               } else if (name) {
-                path3.replaceWith(
+                path2.replaceWith(
                   t.variableDeclaration(
                     "const",
                     [
@@ -1784,10 +1785,10 @@ ${path3.toString()}
                     ]
                   )
                 );
-              } else if (!t.isVariableDeclarator(path3.parent)) {
-                path3.replaceWith(wrapped);
+              } else if (!t.isVariableDeclarator(path2.parent)) {
+                path2.replaceWith(wrapped);
               } else {
-                path3.parent.init = wrapped;
+                path2.parent.init = wrapped;
               }
             });
           }
@@ -1812,7 +1813,7 @@ ${path3.toString()}
       const { code } = generate(ast);
       return {
         contents: code,
-        loader: args.path.split(".").pop()
+        loader: (_a = args.path) == null ? void 0 : _a.split(".").pop()
       };
     }, "cacheDirectivePlugin");
   }
@@ -1888,7 +1889,10 @@ var init_default = __esm({
     init_CachePlugin();
     init_MacroPlugin();
     defaultConfig = {
-      plugins: [new CachePlugin({}), new MacroPlugin({})],
+      plugins: [
+        new CachePlugin({ enabled: true }),
+        new MacroPlugin({ enabled: true })
+      ],
       esbuildPlugins: [],
       compilerOptions: {
         macro: {
@@ -1914,42 +1918,45 @@ var init_default = __esm({
   }
 });
 
-// src/config/utils.ts
-var mergeDeep;
-var init_utils = __esm({
-  "src/config/utils.ts"() {
-    "use strict";
-    init_cjs_shims();
-    mergeDeep = /* @__PURE__ */ __name((target, source) => {
-      const isObject = /* @__PURE__ */ __name((obj) => obj && typeof obj === "object" && !Array.isArray(obj), "isObject");
-      const output = { ...target };
-      if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach((key) => {
-          if (isObject(source[key])) {
-            if (!(key in target)) {
-              Object.assign(output, { [key]: source[key] });
-            } else {
-              output[key] = mergeDeep(target[key], source[key]);
-            }
-          } else {
-            Object.assign(output, { [key]: source[key] });
-          }
-        });
-      }
-      return output;
-    }, "mergeDeep");
-  }
-});
-
 // src/config/config.ts
 function getConfig() {
   return defined;
 }
 function defineConfig(config = {}) {
-  defined = mergeDeep(
-    config,
-    mergeDeep({}, defaultConfig)
-  );
+  var _a, _b;
+  defined = {
+    compilerOptions: {
+      cache: {
+        ...defaultConfig.compilerOptions.cache,
+        ...(_a = config.compilerOptions) == null ? void 0 : _a.cache
+      },
+      macro: {
+        ...defaultConfig.compilerOptions.macro,
+        ...(_b = config.compilerOptions) == null ? void 0 : _b.macro
+      }
+    },
+    distDir: config.distDir ?? defaultConfig.distDir,
+    env: {
+      ...defaultConfig.env,
+      ...config.env
+    },
+    esbuildPlugins: [
+      ...config.esbuildPlugins ?? [],
+      ...defaultConfig.esbuildPlugins ?? []
+    ],
+    plugins: [...config.plugins ?? [], ...defaultConfig.plugins ?? []],
+    sourceMap: {
+      ...defaultConfig.sourceMap,
+      ...config.sourceMap
+    },
+    static: config.static ?? defaultConfig.static,
+    typedCommands: config.typedCommands ?? defaultConfig.typedCommands,
+    typedLocales: config.typedLocales ?? defaultConfig.typedLocales,
+    typescript: {
+      ...defaultConfig.typescript,
+      ...config.typescript
+    }
+  };
   return defined;
 }
 var defined;
@@ -1958,7 +1965,6 @@ var init_config = __esm({
     "use strict";
     init_cjs_shims();
     init_default();
-    init_utils();
     defined = defaultConfig;
     __name(getConfig, "getConfig");
     __name(defineConfig, "defineConfig");
@@ -1976,16 +1982,16 @@ var init_DefaultLocalizationStrategy = __esm({
     init_config();
     import_node_fs = require("fs");
     _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
       }
       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`);
+        const path2 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
         try {
-          const data = await (0, import_promises2.readFile)(path3, "utf-8");
+          const data = await (0, import_promises2.readFile)(path2, "utf-8");
           const localeData = JSON.parse(data);
           await this.generateLocaleTypes(localeData);
           return localeData;
@@ -2146,213 +2152,524 @@ var init_utilities = __esm({
   }
 });
 
-// src/app/i18n/Localization.ts
-var _Localization, Localization;
-var init_Localization = __esm({
-  "src/app/i18n/Localization.ts"() {
+// src/utils/resolve-file-url.ts
+function toFileURL(filePath, withTs = false) {
+  const resolvedPath = import_path.default.resolve(filePath);
+  return `${"file://" + resolvedPath.replace(/\\\\|\\/g, "/")}${withTs ? `?ts=${Date.now()}` : ""}`;
+}
+var import_path;
+var init_resolve_file_url = __esm({
+  "src/utils/resolve-file-url.ts"() {
     "use strict";
     init_cjs_shims();
-    _Localization = class _Localization {
-      /**
-       * Creates a new localization instance.
-       * @param commandkit The command kit instance.
-       * @param config The localization configuration.
-       */
-      constructor(commandkit, config) {
-        this.commandkit = commandkit;
-        this.config = config;
-        const strategy = this.commandkit.config.localizationStrategy;
-        const { locale, target } = this.config;
-        this.t = (translatable, args) => {
-          return strategy.translate({
-            args,
-            key: translatable,
-            locale,
-            scope: target
-          });
-        };
-      }
-      /**
-       * Translates the given translatable object.
-       * @param translatable The translatable object to translate.
-       */
-      t;
-      /**
-       * Get the localization strategy.
-       */
-      getStrategy() {
-        return this.commandkit.config.localizationStrategy;
-      }
-      /**
-       * Get the default locale
-       */
-      getDefaultLocale() {
-        return this.commandkit.config.defaultLocale;
-      }
-      /**
-       * Get the current locale
-       */
-      getLocale() {
-        return this.config.locale;
-      }
-      /**
-       * Get the localization target
-       */
-      getTarget() {
-        return this.config.target;
-      }
-    };
-    __name(_Localization, "Localization");
-    Localization = _Localization;
+    import_path = __toESM(require("path"));
+    __name(toFileURL, "toFileURL");
   }
 });
 
-// src/context/environment.ts
-function afterCommand(fn) {
-  const env = getContext();
-  if (!env) {
-    throw new Error("after must be called inside commandkit handler.");
-  }
-  return env.registerDeferredFunction(fn);
-}
-function cancelAfterCommand(id) {
-  const env = getContext();
-  if (!env) {
-    throw new Error("cancelAfter must be called inside commandkit handler.");
-  }
-  env.clearDeferredFunction(id);
-}
-var import_node_crypto, _data, _CommandKitEnvironment, CommandKitEnvironment, CommandKitEnvironmentType;
-var init_environment = __esm({
-  "src/context/environment.ts"() {
+// src/app/commands/MessageCommandParser.ts
+var import_discord8, _parsed, _options, _args, _MessageCommandParser, MessageCommandParser, _MessageCommandOptions, MessageCommandOptions;
+var init_MessageCommandParser = __esm({
+  "src/app/commands/MessageCommandParser.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto = require("crypto");
-    init_async_context();
-    _CommandKitEnvironment = class _CommandKitEnvironment {
-      /**
-       * Creates the commandkit execution environment.
-       * @param commandkit - The commandkit instance.
-       */
-      constructor(commandkit) {
-        this.commandkit = commandkit;
-        __privateAdd(this, _data, {
-          executionError: null,
-          type: null,
-          variables: /* @__PURE__ */ new Map(),
-          deferredFunctions: /* @__PURE__ */ new Map(),
-          marker: "",
-          markStart: 0,
-          markEnd: 0
-        });
-      }
-      /**
-       * Get the execution error.
-       * @internal
-       */
-      getExecutionError() {
-        return __privateGet(this, _data).executionError;
+    import_discord8 = require("discord.js");
+    init_error_codes();
+    _MessageCommandParser = class _MessageCommandParser {
+      constructor(message, prefix, schema) {
+        this.message = message;
+        this.prefix = prefix;
+        this.schema = schema;
+        __privateAdd(this, _parsed, null);
+        __privateAdd(this, _options, null);
+        __privateAdd(this, _args, []);
       }
-      /**
-       * Set the execution error.
-       * @param error - The error to set.
-       * @internal
-       */
-      setExecutionError(error) {
-        if (__privateGet(this, _data).executionError) {
-          throw new Error("Execution error already set.");
-        }
-        __privateGet(this, _data).executionError = error;
+      getArgs() {
+        void this.parse();
+        return __privateGet(this, _args);
       }
-      /**
-       * Get the environment type.
-       */
-      getType() {
-        const type = __privateGet(this, _data).type;
-        if (!type) {
-          throw new Error("Environment type not set.");
+      get options() {
+        if (!__privateGet(this, _options)) {
+          __privateSet(this, _options, new MessageCommandOptions(this));
         }
-        return type;
+        return __privateGet(this, _options);
       }
-      /**
-       * Set the environment type.
-       * @param type - The environment type to set.
-       * @internal
-       */
-      setType(type) {
-        __privateGet(this, _data).type = type;
+      getOption(name) {
+        var _a;
+        return (_a = this.parse().options.find((o) => o.name === name)) == null ? void 0 : _a.value;
       }
-      /**
-       * The variables store for this environment.
-       */
-      get variables() {
-        return __privateGet(this, _data).variables;
+      getCommand() {
+        return this.parse().command;
       }
-      /**
-       * Register a deferred function.
-       * @param fn - The deferred function to register.
-       * @returns The deferred function id.
-       * @internal
-       */
-      registerDeferredFunction(fn) {
-        const id = (0, import_node_crypto.randomUUID)();
-        __privateGet(this, _data).deferredFunctions.set(id, fn);
-        return id;
+      getSubcommand() {
+        return this.parse().subcommand;
       }
-      /**
-       * Clear a deferred function by id.
-       * @param id - The deferred function id to clear.
-       * @internal
-       */
-      clearDeferredFunction(id) {
-        __privateGet(this, _data).deferredFunctions.delete(id);
+      getSubcommandGroup() {
+        return this.parse().subcommandGroup;
       }
-      /**
-       * Run all deferred functions sequentially.
-       * @internal
-       */
-      async runDeferredFunctions() {
-        for (const [id, fn] of __privateGet(this, _data).deferredFunctions) {
-          try {
-            await fn(this);
-          } catch (e) {
-            this.commandkit.emit("unhandledDeferredFunctionRejection", e);
-          } finally {
-            this.clearDeferredFunction(id);
+      getPrefix() {
+        for (const p of this.prefix) {
+          if (this.message.content.startsWith(p)) {
+            return p;
           }
         }
       }
-      /**
-       * Clear all deferred functions.
-       * @internal
-       */
-      clearAllDeferredFunctions() {
-        __privateGet(this, _data).deferredFunctions.clear();
-      }
-      /**
-       * Mark the start of a command execution.
-       * @param marker - The marker to set.
-       * @internal
-       */
-      markStart(marker) {
-        __privateGet(this, _data).marker = marker;
-        __privateGet(this, _data).markStart = performance.now();
-      }
-      /**
-       * Mark the end of a command execution.
-       * @internal
-       */
-      markEnd() {
-        if (!__privateGet(this, _data).markEnd) __privateGet(this, _data).markEnd = performance.now();
-      }
-      /**
-       * Get the marker.
-       * @internal
-       */
-      getMarker() {
-        return __privateGet(this, _data).marker;
+      getFullCommand() {
+        return [this.getCommand(), this.getSubcommandGroup(), this.getSubcommand()].filter((v) => v).join(" ");
       }
-      /**
+      parse() {
+        if (__privateGet(this, _parsed)) {
+          return __privateGet(this, _parsed);
+        }
+        const content = this.message.content;
+        const prefix = this.getPrefix();
+        if (!prefix) {
+          throw createCommandKitError(CommandKitErrorCodes.InvalidCommandPrefix);
+        }
+        const parts = content.slice(prefix.length).trim().split(" ");
+        const command = parts.shift();
+        __privateSet(this, _args, parts);
+        let subcommandGroup;
+        let subcommand;
+        if (command == null ? void 0 : command.includes(":")) {
+          const [, group, cmd] = command.split(":");
+          if (!cmd && group) {
+            subcommand = group;
+          } else if (cmd && group) {
+            subcommandGroup = group;
+            subcommand = cmd;
+          }
+        }
+        const schema = this.schema(
+          [command, subcommandGroup, subcommand].filter(Boolean).join(" ").trim()
+        );
+        const options = parts.map((part) => {
+          try {
+            const [name, value] = part.split(":");
+            if (!(name in schema)) return null;
+            switch (schema[name]) {
+              case import_discord8.ApplicationCommandOptionType.Boolean:
+                return { name, value: value === "true" };
+              case import_discord8.ApplicationCommandOptionType.Integer:
+                return { name, value: parseInt(value, 10) };
+              case import_discord8.ApplicationCommandOptionType.Number:
+                return { name, value: parseFloat(value) };
+              case import_discord8.ApplicationCommandOptionType.String:
+                return { name, value };
+              case import_discord8.ApplicationCommandOptionType.User:
+                return {
+                  name,
+                  value: this.message.mentions.users.find((u) => {
+                    return u.id === value.replace(/[<@!>]/g, "");
+                  })
+                };
+              case import_discord8.ApplicationCommandOptionType.Channel:
+                return {
+                  name,
+                  value: this.message.mentions.channels.find((c) => {
+                    return c.id === value.replace(/[<#>]/g, "");
+                  })
+                };
+              case import_discord8.ApplicationCommandOptionType.Role:
+                return {
+                  name,
+                  value: this.message.mentions.roles.find((r) => {
+                    return r.id === value.replace(/[<@&>]/g, "");
+                  })
+                };
+              case import_discord8.ApplicationCommandOptionType.Attachment:
+                return {
+                  name,
+                  value: this.message.attachments.find((a) => {
+                    return a.name === value;
+                  })
+                };
+              default:
+                return null;
+            }
+          } catch {
+            return null;
+          }
+        }).filter((v) => v !== null);
+        __privateSet(this, _parsed, {
+          command,
+          options,
+          subcommand,
+          subcommandGroup
+        });
+        return __privateGet(this, _parsed);
+      }
+    };
+    _parsed = new WeakMap();
+    _options = new WeakMap();
+    _args = new WeakMap();
+    __name(_MessageCommandParser, "MessageCommandParser");
+    MessageCommandParser = _MessageCommandParser;
+    _MessageCommandOptions = class _MessageCommandOptions {
+      constructor(parser2) {
+        this.parser = parser2;
+      }
+      assertOption(name, required = false) {
+        const option = this.parser.getOption(name);
+        if (required && option === void 0) {
+          throw new Error(`Option "${name}" is required.`);
+        }
+        return option ?? null;
+      }
+      getMember(name, required = false) {
+        var _a;
+        const user = this.assertOption(name, required);
+        const member = (_a = this.parser.message.guild) == null ? void 0 : _a.members.cache.get(user == null ? void 0 : user.id);
+        if (required && !member) {
+          throw new Error(`Member "${name}" is required.`);
+        }
+        return member ?? null;
+      }
+      getAttachment(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getBoolean(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getNumber(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getString(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getInteger(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getUser(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getChannel(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getRole(name, required = false) {
+        return this.assertOption(name, required);
+      }
+      getMentionable(name, required = false) {
+        const target = this.assertOption(name, required);
+        if (target instanceof import_discord8.GuildMember || target instanceof import_discord8.User || target instanceof import_discord8.Role) {
+          return target;
+        }
+        if (required) {
+          throw new Error(`Mentionable "${name}" is required.`);
+        }
+        return null;
+      }
+      getSubcommand(required = false) {
+        const sub = this.parser.getSubcommand();
+        if (required && sub === void 0) {
+          throw new Error("Subcommand is required.");
+        }
+        return sub ?? null;
+      }
+      getSubcommandGroup(required = false) {
+        const sub = this.parser.getSubcommandGroup();
+        if (required && sub === void 0) {
+          throw new Error("Subcommand group is required.");
+        }
+        return sub ?? null;
+      }
+    };
+    __name(_MessageCommandOptions, "MessageCommandOptions");
+    MessageCommandOptions = _MessageCommandOptions;
+  }
+});
+
+// src/app/register/CommandRegistrar.ts
+var import_discord9, _CommandRegistrar, CommandRegistrar;
+var init_CommandRegistrar = __esm({
+  "src/app/register/CommandRegistrar.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_discord9 = require("discord.js");
+    init_Logger();
+    _CommandRegistrar = class _CommandRegistrar {
+      /**
+       * Creates an instance of CommandRegistrar.
+       * @param commandkit The commandkit instance.
+       */
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
+        this.api.setToken(
+          this.commandkit.client.token ?? process.env.DISCORD_TOKEN ?? process.env.TOKEN ?? ""
+        );
+      }
+      api = new import_discord9.REST();
+      /**
+       * Gets the commands data.
+       */
+      getCommandsData() {
+        const handler = this.commandkit.commandHandler;
+        const commands = handler.getCommandsArray();
+        return commands.flatMap((cmd) => {
+          const json = "toJSON" in cmd.data.command ? cmd.data.command.toJSON() : cmd.data.command;
+          const collections = [json];
+          if (cmd.data.userContextMenu && json.type !== import_discord9.ApplicationCommandType.User) {
+            collections.push({
+              ...json,
+              type: import_discord9.ApplicationCommandType.User,
+              options: void 0,
+              description_localizations: void 0,
+              // @ts-ignore
+              description: void 0
+            });
+          }
+          if (cmd.data.messageContextMenu && json.type !== import_discord9.ApplicationCommandType.Message) {
+            collections.push({
+              ...json,
+              type: import_discord9.ApplicationCommandType.Message,
+              description_localizations: void 0,
+              // @ts-ignore
+              description: void 0,
+              options: void 0
+            });
+          }
+          return collections;
+        });
+      }
+      /**
+       * Registers loaded commands.
+       */
+      async register() {
+        if (!this.commandkit.client.isReady()) {
+          throw new Error("Cannot register commands before the client is ready");
+        }
+        const commands = this.getCommandsData();
+        const guildCommands = commands.filter((command) => {
+          var _a;
+          return (_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length;
+        }).map((c) => {
+          var _a;
+          return {
+            ...c,
+            guilds: Array.from(new Set((_a = c.guilds) == null ? void 0 : _a.filter(Boolean)))
+          };
+        });
+        const globalCommands = commands.filter(
+          (command) => {
+            var _a;
+            return !((_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length);
+          }
+        );
+        await this.updateGlobalCommands(globalCommands);
+        await this.updateGuildCommands(guildCommands);
+      }
+      /**
+       * Updates the global commands.
+       */
+      async updateGlobalCommands(commands) {
+        if (!commands.length) return;
+        try {
+          const data = await this.api.put(
+            import_discord9.Routes.applicationCommands(this.commandkit.client.user.id),
+            {
+              body: commands.map((c) => ({
+                ...c,
+                guilds: void 0
+              }))
+            }
+          );
+          Logger.info(
+            `\u2728 Refreshed ${data.length} global application (/) commands`
+          );
+        } catch (e) {
+          Logger.error("Failed to update global application (/) commands", e);
+        }
+      }
+      /**
+       * Updates the guild commands.
+       */
+      async updateGuildCommands(commands) {
+        try {
+          const guildCommandsMap = /* @__PURE__ */ new Map();
+          commands.forEach((command) => {
+            var _a;
+            if (!((_a = command.guilds) == null ? void 0 : _a.length)) return;
+            command.guilds.forEach((guild) => {
+              if (!guildCommandsMap.has(guild)) {
+                guildCommandsMap.set(guild, []);
+              }
+              guildCommandsMap.get(guild).push(command);
+            });
+          });
+          if (!guildCommandsMap.size) return;
+          let count = 0;
+          for (const [guild, guildCommands] of guildCommandsMap) {
+            const data = await this.api.put(
+              import_discord9.Routes.applicationGuildCommands(
+                this.commandkit.client.user.id,
+                guild
+              ),
+              {
+                body: guildCommands.map((b) => ({
+                  ...b,
+                  guilds: void 0
+                }))
+              }
+            );
+            count += data.length;
+          }
+          Logger.info(`\u2728 Refreshed ${count} guild application (/) commands`);
+        } catch (e) {
+          Logger.error("Failed to update guild application (/) commands", e);
+        }
+      }
+    };
+    __name(_CommandRegistrar, "CommandRegistrar");
+    CommandRegistrar = _CommandRegistrar;
+  }
+});
+
+// src/context/environment.ts
+function afterCommand(fn) {
+  const env = getContext();
+  if (!env) {
+    throw new Error("after must be called inside commandkit handler.");
+  }
+  return env.registerDeferredFunction(fn);
+}
+function cancelAfterCommand(id) {
+  const env = getContext();
+  if (!env) {
+    throw new Error("cancelAfter must be called inside commandkit handler.");
+  }
+  env.clearDeferredFunction(id);
+}
+var import_node_crypto, _data, _CommandKitEnvironment, CommandKitEnvironment, CommandKitEnvironmentType;
+var init_environment = __esm({
+  "src/context/environment.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto = require("crypto");
+    init_async_context();
+    _CommandKitEnvironment = class _CommandKitEnvironment {
+      /**
+       * Creates the commandkit execution environment.
+       * @param commandkit - The commandkit instance.
+       */
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
+        __privateAdd(this, _data, {
+          executionError: null,
+          type: null,
+          variables: /* @__PURE__ */ new Map(),
+          deferredFunctions: /* @__PURE__ */ new Map(),
+          marker: "",
+          markStart: 0,
+          markEnd: 0
+        });
+      }
+      /**
+       * Get the execution error.
+       * @internal
+       */
+      getExecutionError() {
+        return __privateGet(this, _data).executionError;
+      }
+      /**
+       * Set the execution error.
+       * @param error - The error to set.
+       * @internal
+       */
+      setExecutionError(error) {
+        if (__privateGet(this, _data).executionError) {
+          throw new Error("Execution error already set.");
+        }
+        __privateGet(this, _data).executionError = error;
+      }
+      /**
+       * Get the environment type.
+       */
+      getType() {
+        const type = __privateGet(this, _data).type;
+        if (!type) {
+          throw new Error("Environment type not set.");
+        }
+        return type;
+      }
+      /**
+       * Set the environment type.
+       * @param type - The environment type to set.
+       * @internal
+       */
+      setType(type) {
+        __privateGet(this, _data).type = type;
+      }
+      /**
+       * The variables store for this environment.
+       */
+      get variables() {
+        return __privateGet(this, _data).variables;
+      }
+      /**
+       * Register a deferred function.
+       * @param fn - The deferred function to register.
+       * @returns The deferred function id.
+       * @internal
+       */
+      registerDeferredFunction(fn) {
+        const id = (0, import_node_crypto.randomUUID)();
+        __privateGet(this, _data).deferredFunctions.set(id, fn);
+        return id;
+      }
+      /**
+       * Clear a deferred function by id.
+       * @param id - The deferred function id to clear.
+       * @internal
+       */
+      clearDeferredFunction(id) {
+        __privateGet(this, _data).deferredFunctions.delete(id);
+      }
+      /**
+       * Run all deferred functions sequentially.
+       * @internal
+       */
+      async runDeferredFunctions() {
+        for (const [id, fn] of __privateGet(this, _data).deferredFunctions) {
+          try {
+            await fn(this);
+          } catch (e) {
+            this.commandkit.emit("unhandledDeferredFunctionRejection", e);
+          } finally {
+            this.clearDeferredFunction(id);
+          }
+        }
+      }
+      /**
+       * Clear all deferred functions.
+       * @internal
+       */
+      clearAllDeferredFunctions() {
+        __privateGet(this, _data).deferredFunctions.clear();
+      }
+      /**
+       * Mark the start of a command execution.
+       * @param marker - The marker to set.
+       * @internal
+       */
+      markStart(marker) {
+        __privateGet(this, _data).marker = marker;
+        __privateGet(this, _data).markStart = performance.now();
+      }
+      /**
+       * Mark the end of a command execution.
+       * @internal
+       */
+      markEnd() {
+        if (!__privateGet(this, _data).markEnd) __privateGet(this, _data).markEnd = performance.now();
+      }
+      /**
+       * Get the marker.
+       * @internal
+       */
+      getMarker() {
+        return __privateGet(this, _data).marker;
+      }
+      /**
        * Get the execution time in milliseconds.
        * @internal
        */
@@ -2372,6 +2689,67 @@ var init_environment = __esm({
   }
 });
 
+// src/app/i18n/Localization.ts
+var _Localization, Localization;
+var init_Localization = __esm({
+  "src/app/i18n/Localization.ts"() {
+    "use strict";
+    init_cjs_shims();
+    _Localization = class _Localization {
+      /**
+       * Creates a new localization instance.
+       * @param commandkit The command kit instance.
+       * @param config The localization configuration.
+       */
+      constructor(commandkit2, config) {
+        this.commandkit = commandkit2;
+        this.config = config;
+        const strategy = this.commandkit.config.localizationStrategy;
+        const { locale, target } = this.config;
+        this.t = (translatable, args) => {
+          return strategy.translate({
+            args,
+            key: translatable,
+            locale,
+            scope: target
+          });
+        };
+      }
+      /**
+       * Translates the given translatable object.
+       * @param translatable The translatable object to translate.
+       */
+      t;
+      /**
+       * Get the localization strategy.
+       */
+      getStrategy() {
+        return this.commandkit.config.localizationStrategy;
+      }
+      /**
+       * Get the default locale
+       */
+      getDefaultLocale() {
+        return this.commandkit.config.defaultLocale;
+      }
+      /**
+       * Get the current locale
+       */
+      getLocale() {
+        return this.config.locale;
+      }
+      /**
+       * Get the localization target
+       */
+      getTarget() {
+        return this.config.target;
+      }
+    };
+    __name(_Localization, "Localization");
+    Localization = _Localization;
+  }
+});
+
 // src/app/middleware/signals.ts
 function exitMiddleware() {
   throw createCommandKitError(CommandKitErrorCodes.ExitMiddleware);
@@ -2398,8 +2776,8 @@ function md5(data) {
   return (0, import_node_crypto2.createHash)("md5").update(data).digest("hex");
 }
 function getCacheProvider() {
-  const commandkit = getCommandKit(true);
-  const provider = commandkit.getCacheProvider();
+  const commandkit2 = getCommandKit(true);
+  const provider = commandkit2.getCacheProvider();
   if (!provider) {
     throw new Error(
       `Cache provider was not found, please provide a cache provider to commandkit.`
@@ -2566,8 +2944,8 @@ var init_Context = __esm({
        * @param commandkit The command kit instance.
        * @param config The context parameters.
        */
-      constructor(commandkit, config) {
-        this.commandkit = commandkit;
+      constructor(commandkit2, config) {
+        this.commandkit = commandkit2;
         this.config = config;
         /**
          * The interaction that triggered the command.
@@ -2585,7 +2963,7 @@ var init_Context = __esm({
         __publicField(this, "_locale", null);
         this.interaction = config.interaction;
         this.message = config.message;
-        this.client = commandkit.client;
+        this.client = commandkit2.client;
         __privateSet(this, _store, config.store ?? /* @__PURE__ */ new Map());
       }
       /**
@@ -2674,639 +3052,317 @@ var init_Context = __esm({
       }
       /**
        * Whether the command was triggered by an autocomplete interaction.
-       */
-      isAutocomplete() {
-        return this.executionMode === CommandExecutionMode.Autocomplete;
-      }
-      /**
-       * Whether the command was triggered by a message context menu interaction.
-       */
-      isMessageContextMenu() {
-        return this.executionMode === CommandExecutionMode.MessageContextMenu;
-      }
-      /**
-       * Whether the command was triggered by a user context menu interaction.
-       */
-      isUserContextMenu() {
-        return this.executionMode === CommandExecutionMode.UserContextMenu;
-      }
-      /**
-       * Whether the command was triggered by a message.
-       */
-      isMessage() {
-        return this.executionMode === CommandExecutionMode.Message;
-      }
-      /**
-       * Returns the command identifier.
-       */
-      getCommandIdentifier() {
-        if (this.isInteraction()) {
-          return this.interaction.commandName;
-        } else {
-          return this.message.content.split(" ")[0].slice(1);
-        }
-      }
-      /**
-       * Returns the locale of the guild where this command was triggered.
-       */
-      getGuildLocale() {
-        var _a;
-        if (this.isInteraction()) {
-          return this.interaction.guildLocale;
-        } else {
-          return ((_a = this.message.guild) == null ? void 0 : _a.preferredLocale) ?? null;
-        }
-      }
-      /**
-       * Returns the locale of the user who triggered this command.
-       */
-      getUserLocale() {
-        if (this.isInteraction()) {
-          return this.interaction.locale;
-        } else {
-          return null;
-        }
-      }
-      /**
-       * Returns the locale for this command.
-       * @param preferUser Whether to prefer the user's locale over the guild's locale.
-       * @returns The locale for this command. If no locale is found, the default locale is returned.
-       */
-      getLocale(preferUser = false) {
-        if (this._locale) return this._locale;
-        const locale = preferUser ? this.getUserLocale() : this.getGuildLocale();
-        if (!locale) {
-          return this.commandkit.config.defaultLocale;
-        }
-        return locale;
-      }
-      /**
-       * Sets the locale for this command.
-       * @param locale The locale to set.
-       */
-      setLocale(locale) {
-        this._locale = locale;
-      }
-      /**
-       * Returns the i18n api for this command.
-       * @param locale The locale to use for the i18n api.
-       */
-      locale(locale) {
-        const selectedLocale = locale ?? this.getLocale();
-        return new Localization(this.commandkit, {
-          locale: selectedLocale,
-          target: this.getCommandIdentifier()
-        });
-      }
-      /**
-       * Creates a clone of this context
-       */
-      clone(config) {
-        if (!config) return new _Context(this.commandkit, this.config);
-        const ctx = new _Context(this.commandkit, {
-          ...this.config,
-          ...config,
-          store: __privateGet(this, _store)
-        });
-        return ctx;
-      }
-      isMiddleware() {
-        return this instanceof MiddlewareContext;
-      }
-      args() {
-        if (this.isMessage()) {
-          return this.config.messageCommandParser.getArgs();
-        }
-        return [];
-      }
-      /**
-       * Stops upcoming middleware or current command execution.
-       * If this is called inside pre-stage middleware, the next run will be the actual command, skipping all other pre-stage middlewares.
-       * If this is called inside a command itself, it will skip all post-stage middlewares.
-       * If this is called inside post-stage middleware, it will skip all other post-stage middlewares.
-       */
-      exit() {
-        exitMiddleware();
-      }
-      /**
-       * Defers the given function to be executed after this command's execution.
-       * @param fn The function to defer.
-       * @returns A unique identifier for the deferred function.
-       */
-      defer(fn) {
-        return afterCommand(fn);
-      }
-      /**
-       * Cancels the deferred function with the given identifier.
-       * @param id The identifier of the deferred function.
-       */
-      cancelDeferred(id) {
-        cancelAfterCommand(id);
-      }
-      /**
-       * Validates if the given function is a cached function.
-       * @param fn The function to validate.
-       */
-      isCached(fn) {
-        return isCachedFunction(fn);
-      }
-    };
-    _store = new WeakMap();
-    __name(_Context, "Context");
-    Context = _Context;
-    _MiddlewareContext = class _MiddlewareContext extends Context {
-      constructor() {
-        super(...arguments);
-        __privateAdd(this, _cancel, false);
+       */
+      isAutocomplete() {
+        return this.executionMode === CommandExecutionMode.Autocomplete;
       }
       /**
-       * Whether the command execution was cancelled.
+       * Whether the command was triggered by a message context menu interaction.
        */
-      get cancelled() {
-        return __privateGet(this, _cancel);
+      isMessageContextMenu() {
+        return this.executionMode === CommandExecutionMode.MessageContextMenu;
       }
       /**
-       * Cancels the command execution.
+       * Whether the command was triggered by a user context menu interaction.
        */
-      cancel() {
-        __privateSet(this, _cancel, true);
+      isUserContextMenu() {
+        return this.executionMode === CommandExecutionMode.UserContextMenu;
       }
       /**
-       * Sets command runner function to wrap the command execution.
-       * @param fn The function to set.
-       * @example ctx.setCommandRunner(async (execute) => {
-       *  // do something before command execution
-       *  await execute();
-       *  // do something after command execution
-       * })
+       * Whether the command was triggered by a message.
        */
-      setCommandRunner(fn) {
-        var _a, _b;
-        (_b = (_a = this.config.customArgs) == null ? void 0 : _a.setCommandRunner) == null ? void 0 : _b.call(_a, fn);
-      }
-    };
-    _cancel = new WeakMap();
-    __name(_MiddlewareContext, "MiddlewareContext");
-    MiddlewareContext = _MiddlewareContext;
-  }
-});
-
-// src/utils/resolve-file-url.ts
-function toFileURL(filePath, withTs = false) {
-  const resolvedPath = import_path.default.resolve(filePath);
-  return `${"file://" + resolvedPath.replace(/\\\\|\\/g, "/")}${withTs ? `?ts=${Date.now()}` : ""}`;
-}
-var import_path;
-var init_resolve_file_url = __esm({
-  "src/utils/resolve-file-url.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_path = __toESM(require("path"));
-    __name(toFileURL, "toFileURL");
-  }
-});
-
-// src/app/commands/MessageCommandParser.ts
-var import_discord8, _parsed, _options, _args, _MessageCommandParser, MessageCommandParser, _MessageCommandOptions, MessageCommandOptions;
-var init_MessageCommandParser = __esm({
-  "src/app/commands/MessageCommandParser.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_discord8 = require("discord.js");
-    init_error_codes();
-    _MessageCommandParser = class _MessageCommandParser {
-      constructor(message, prefix, schema) {
-        this.message = message;
-        this.prefix = prefix;
-        this.schema = schema;
-        __privateAdd(this, _parsed, null);
-        __privateAdd(this, _options, null);
-        __privateAdd(this, _args, []);
-      }
-      getArgs() {
-        void this.parse();
-        return __privateGet(this, _args);
+      isMessage() {
+        return this.executionMode === CommandExecutionMode.Message;
       }
-      get options() {
-        if (!__privateGet(this, _options)) {
-          __privateSet(this, _options, new MessageCommandOptions(this));
+      /**
+       * Returns the command identifier.
+       */
+      getCommandIdentifier() {
+        if (this.isInteraction()) {
+          return this.interaction.commandName;
+        } else {
+          return this.message.content.split(" ")[0].slice(1);
         }
-        return __privateGet(this, _options);
       }
-      getOption(name) {
+      /**
+       * Returns the locale of the guild where this command was triggered.
+       */
+      getGuildLocale() {
         var _a;
-        return (_a = this.parse().options.find((o) => o.name === name)) == null ? void 0 : _a.value;
-      }
-      getCommand() {
-        return this.parse().command;
-      }
-      getSubcommand() {
-        return this.parse().subcommand;
-      }
-      getSubcommandGroup() {
-        return this.parse().subcommandGroup;
-      }
-      getPrefix() {
-        for (const p of this.prefix) {
-          if (this.message.content.startsWith(p)) {
-            return p;
-          }
+        if (this.isInteraction()) {
+          return this.interaction.guildLocale;
+        } else {
+          return ((_a = this.message.guild) == null ? void 0 : _a.preferredLocale) ?? null;
         }
       }
-      getFullCommand() {
-        return [this.getCommand(), this.getSubcommandGroup(), this.getSubcommand()].filter((v) => v).join(" ");
-      }
-      parse() {
-        if (__privateGet(this, _parsed)) {
-          return __privateGet(this, _parsed);
-        }
-        const content = this.message.content;
-        const prefix = this.getPrefix();
-        if (!prefix) {
-          throw createCommandKitError(CommandKitErrorCodes.InvalidCommandPrefix);
-        }
-        const parts = content.slice(prefix.length).trim().split(" ");
-        const command = parts.shift();
-        __privateSet(this, _args, parts);
-        let subcommandGroup;
-        let subcommand;
-        if (command == null ? void 0 : command.includes(":")) {
-          const [, group, cmd] = command.split(":");
-          if (!cmd && group) {
-            subcommand = group;
-          } else if (cmd && group) {
-            subcommandGroup = group;
-            subcommand = cmd;
-          }
+      /**
+       * Returns the locale of the user who triggered this command.
+       */
+      getUserLocale() {
+        if (this.isInteraction()) {
+          return this.interaction.locale;
+        } else {
+          return null;
         }
-        const schema = this.schema(
-          [command, subcommandGroup, subcommand].filter(Boolean).join(" ").trim()
-        );
-        const options = parts.map((part) => {
-          try {
-            const [name, value] = part.split(":");
-            if (!(name in schema)) return null;
-            switch (schema[name]) {
-              case import_discord8.ApplicationCommandOptionType.Boolean:
-                return { name, value: value === "true" };
-              case import_discord8.ApplicationCommandOptionType.Integer:
-                return { name, value: parseInt(value, 10) };
-              case import_discord8.ApplicationCommandOptionType.Number:
-                return { name, value: parseFloat(value) };
-              case import_discord8.ApplicationCommandOptionType.String:
-                return { name, value };
-              case import_discord8.ApplicationCommandOptionType.User:
-                return {
-                  name,
-                  value: this.message.mentions.users.find((u) => {
-                    return u.id === value.replace(/[<@!>]/g, "");
-                  })
-                };
-              case import_discord8.ApplicationCommandOptionType.Channel:
-                return {
-                  name,
-                  value: this.message.mentions.channels.find((c) => {
-                    return c.id === value.replace(/[<#>]/g, "");
-                  })
-                };
-              case import_discord8.ApplicationCommandOptionType.Role:
-                return {
-                  name,
-                  value: this.message.mentions.roles.find((r) => {
-                    return r.id === value.replace(/[<@&>]/g, "");
-                  })
-                };
-              case import_discord8.ApplicationCommandOptionType.Attachment:
-                return {
-                  name,
-                  value: this.message.attachments.find((a) => {
-                    return a.name === value;
-                  })
-                };
-              default:
-                return null;
-            }
-          } catch {
-            return null;
-          }
-        }).filter((v) => v !== null);
-        __privateSet(this, _parsed, {
-          command,
-          options,
-          subcommand,
-          subcommandGroup
-        });
-        return __privateGet(this, _parsed);
-      }
-    };
-    _parsed = new WeakMap();
-    _options = new WeakMap();
-    _args = new WeakMap();
-    __name(_MessageCommandParser, "MessageCommandParser");
-    MessageCommandParser = _MessageCommandParser;
-    _MessageCommandOptions = class _MessageCommandOptions {
-      constructor(parser2) {
-        this.parser = parser2;
       }
-      assertOption(name, required = false) {
-        const option = this.parser.getOption(name);
-        if (required && option === void 0) {
-          throw new Error(`Option "${name}" is required.`);
+      /**
+       * Returns the locale for this command.
+       * @param preferUser Whether to prefer the user's locale over the guild's locale.
+       * @returns The locale for this command. If no locale is found, the default locale is returned.
+       */
+      getLocale(preferUser = false) {
+        if (this._locale) return this._locale;
+        const locale = preferUser ? this.getUserLocale() : this.getGuildLocale();
+        if (!locale) {
+          return this.commandkit.config.defaultLocale;
         }
-        return option ?? null;
+        return locale;
       }
-      getMember(name, required = false) {
-        var _a;
-        const user = this.assertOption(name, required);
-        const member = (_a = this.parser.message.guild) == null ? void 0 : _a.members.cache.get(user == null ? void 0 : user.id);
-        if (required && !member) {
-          throw new Error(`Member "${name}" is required.`);
-        }
-        return member ?? null;
+      /**
+       * Sets the locale for this command.
+       * @param locale The locale to set.
+       */
+      setLocale(locale) {
+        this._locale = locale;
       }
-      getAttachment(name, required = false) {
-        return this.assertOption(name, required);
+      /**
+       * Returns the i18n api for this command.
+       * @param locale The locale to use for the i18n api.
+       */
+      locale(locale) {
+        const selectedLocale = locale ?? this.getLocale();
+        return new Localization(this.commandkit, {
+          locale: selectedLocale,
+          target: this.getCommandIdentifier()
+        });
+      }
+      /**
+       * Creates a clone of this context
+       */
+      clone(config) {
+        if (!config) return new _Context(this.commandkit, this.config);
+        const ctx = new _Context(this.commandkit, {
+          ...this.config,
+          ...config,
+          store: __privateGet(this, _store)
+        });
+        return ctx;
       }
-      getBoolean(name, required = false) {
-        return this.assertOption(name, required);
+      isMiddleware() {
+        return this instanceof MiddlewareContext;
       }
-      getNumber(name, required = false) {
-        return this.assertOption(name, required);
+      args() {
+        if (this.isMessage()) {
+          return this.config.messageCommandParser.getArgs();
+        }
+        return [];
       }
-      getString(name, required = false) {
-        return this.assertOption(name, required);
+      /**
+       * Stops upcoming middleware or current command execution.
+       * If this is called inside pre-stage middleware, the next run will be the actual command, skipping all other pre-stage middlewares.
+       * If this is called inside a command itself, it will skip all post-stage middlewares.
+       * If this is called inside post-stage middleware, it will skip all other post-stage middlewares.
+       */
+      exit() {
+        exitMiddleware();
       }
-      getInteger(name, required = false) {
-        return this.assertOption(name, required);
+      /**
+       * Defers the given function to be executed after this command's execution.
+       * @param fn The function to defer.
+       * @returns A unique identifier for the deferred function.
+       */
+      defer(fn) {
+        return afterCommand(fn);
       }
-      getUser(name, required = false) {
-        return this.assertOption(name, required);
+      /**
+       * Cancels the deferred function with the given identifier.
+       * @param id The identifier of the deferred function.
+       */
+      cancelDeferred(id) {
+        cancelAfterCommand(id);
       }
-      getChannel(name, required = false) {
-        return this.assertOption(name, required);
+      /**
+       * Validates if the given function is a cached function.
+       * @param fn The function to validate.
+       */
+      isCached(fn) {
+        return isCachedFunction(fn);
       }
-      getRole(name, required = false) {
-        return this.assertOption(name, required);
+    };
+    _store = new WeakMap();
+    __name(_Context, "Context");
+    Context = _Context;
+    _MiddlewareContext = class _MiddlewareContext extends Context {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _cancel, false);
       }
-      getMentionable(name, required = false) {
-        const target = this.assertOption(name, required);
-        if (target instanceof import_discord8.GuildMember || target instanceof import_discord8.User || target instanceof import_discord8.Role) {
-          return target;
-        }
-        if (required) {
-          throw new Error(`Mentionable "${name}" is required.`);
-        }
-        return null;
+      /**
+       * Whether the command execution was cancelled.
+       */
+      get cancelled() {
+        return __privateGet(this, _cancel);
       }
-      getSubcommand(required = false) {
-        const sub = this.parser.getSubcommand();
-        if (required && sub === void 0) {
-          throw new Error("Subcommand is required.");
-        }
-        return sub ?? null;
+      /**
+       * Cancels the command execution.
+       */
+      cancel() {
+        __privateSet(this, _cancel, true);
       }
-      getSubcommandGroup(required = false) {
-        const sub = this.parser.getSubcommandGroup();
-        if (required && sub === void 0) {
-          throw new Error("Subcommand group is required.");
-        }
-        return sub ?? null;
+      /**
+       * Sets command runner function to wrap the command execution.
+       * @param fn The function to set.
+       * @example ctx.setCommandRunner(async (execute) => {
+       *  // do something before command execution
+       *  await execute();
+       *  // do something after command execution
+       * })
+       */
+      setCommandRunner(fn) {
+        var _a, _b;
+        (_b = (_a = this.config.customArgs) == null ? void 0 : _a.setCommandRunner) == null ? void 0 : _b.call(_a, fn);
       }
     };
-    __name(_MessageCommandOptions, "MessageCommandOptions");
-    MessageCommandOptions = _MessageCommandOptions;
+    _cancel = new WeakMap();
+    __name(_MiddlewareContext, "MiddlewareContext");
+    MiddlewareContext = _MiddlewareContext;
   }
 });
 
-// src/app/register/CommandRegistrar.ts
-var import_discord9, _CommandRegistrar, CommandRegistrar;
-var init_CommandRegistrar = __esm({
-  "src/app/register/CommandRegistrar.ts"() {
+// src/app/commands/AppCommandRunner.ts
+var import_discord10, _AppCommandRunner_instances, finalizer_fn, _AppCommandRunner, AppCommandRunner;
+var init_AppCommandRunner = __esm({
+  "src/app/commands/AppCommandRunner.ts"() {
     "use strict";
     init_cjs_shims();
-    import_discord9 = require("discord.js");
+    import_discord10 = require("discord.js");
+    init_environment();
     init_Logger();
-    _CommandRegistrar = class _CommandRegistrar {
-      /**
-       * Creates an instance of CommandRegistrar.
-       * @param commandkit The commandkit instance.
-       */
-      constructor(commandkit) {
-        this.commandkit = commandkit;
-        this.api.setToken(
-          this.commandkit.client.token ?? process.env.DISCORD_TOKEN ?? process.env.TOKEN ?? ""
-        );
-      }
-      api = new import_discord9.REST();
-      /**
-       * Gets the commands data.
-       */
-      getCommandsData() {
-        const handler = this.commandkit.commandHandler;
-        const commands = handler.getCommandsArray();
-        return commands.flatMap((cmd) => {
-          var _a;
-          const json = "toJSON" in cmd.data.command ? cmd.data.command.toJSON() : cmd.data.command;
-          if (((_a = cmd.command.subcommands) == null ? void 0 : _a.length) > 0 && (!json.type || json.type === import_discord9.ApplicationCommandType.ChatInput)) {
-            this.processSubcommands(json, cmd.command.subcommands);
-          }
-          const collections = [json];
-          if (cmd.data.userContextMenu && json.type !== import_discord9.ApplicationCommandType.User) {
-            collections.push({
-              ...json,
-              type: import_discord9.ApplicationCommandType.User,
-              options: void 0,
-              description_localizations: void 0,
-              // @ts-ignore
-              description: void 0
-            });
-          }
-          if (cmd.data.messageContextMenu && json.type !== import_discord9.ApplicationCommandType.Message) {
-            collections.push({
-              ...json,
-              type: import_discord9.ApplicationCommandType.Message,
-              description_localizations: void 0,
-              // @ts-ignore
-              description: void 0,
-              options: void 0
-            });
-          }
-          return collections;
-        });
+    init_Context();
+    init_async_context();
+    _AppCommandRunner = class _AppCommandRunner {
+      constructor(handler) {
+        this.handler = handler;
+        __privateAdd(this, _AppCommandRunner_instances);
       }
-      /**
-       * Process and merge subcommands into the parent command's options
-       */
-      processSubcommands(commandData, subcommands) {
-        var _a, _b, _c;
-        if (!commandData.options) {
-          commandData.options = [];
+      async runCommand(prepared, source) {
+        if (source instanceof import_discord10.Message && (source.editedTimestamp || source.partial)) {
+          return;
         }
-        const groupedSubcommands = /* @__PURE__ */ new Map();
-        for (const subcommand of subcommands) {
-          const group = subcommand.group || null;
-          if (!groupedSubcommands.has(group)) {
-            groupedSubcommands.set(group, []);
+        const { commandkit: commandkit2 } = this.handler;
+        const executionMode = this.getExecutionMode(source);
+        let runCommand = null;
+        const env = new CommandKitEnvironment(commandkit2);
+        env.setType("COMMAND_HANDLER" /* CommandHandler */);
+        env.variables.set("commandHandlerType", "app");
+        env.variables.set("currentCommandName", prepared.command.command.name);
+        env.variables.set("execHandlerKind", executionMode);
+        const ctx = new MiddlewareContext(commandkit2, {
+          environment: env,
+          executionMode,
+          interaction: !(source instanceof import_discord10.Message) ? source : null,
+          message: source instanceof import_discord10.Message ? source : null,
+          forwarded: false,
+          customArgs: {
+            setCommandRunner: /* @__PURE__ */ __name((fn2) => {
+              runCommand = fn2;
+            }, "setCommandRunner")
           }
-          (_a = groupedSubcommands.get(group)) == null ? void 0 : _a.push(subcommand);
+        });
+        for (const middleware of prepared.middlewares) {
+          await middleware.data.beforeExecute(ctx);
         }
-        const directSubcommands = groupedSubcommands.get(null) || [];
-        for (const subcommand of directSubcommands) {
-          const subcommandData = this.commandkit.commandHandler.getSubcommandData(
-            subcommand.command,
-            subcommand.name
+        const targetData = prepared.command.data;
+        const fn = targetData[executionMode];
+        if (!fn) {
+          Logger.warn(
+            `Command ${prepared.command.command.name} has no handler for ${executionMode}`
           );
-          if (subcommandData) {
-            const subcommandOption = {
-              type: import_discord9.ApplicationCommandOptionType.Subcommand,
-              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,
-            name: groupName,
-            description: `${groupName} commands`,
-            options: []
-          };
-          for (const subcommand of groupSubcommands) {
-            const subcommandData = this.commandkit.commandHandler.getSubcommandData(
-              subcommand.command,
-              subcommand.name
+        if (fn) {
+          try {
+            const _executeCommand = makeContextAwareFunction(
+              env,
+              async () => {
+                afterCommand((env2) => {
+                  const error = env2.getExecutionError();
+                  const marker = env2.getMarker();
+                  const time = `${env2.getExecutionTime().toFixed(2)}ms`;
+                  if (error) {
+                    Logger.error(
+                      `[${marker} - ${time}] Error executing command: ${error.stack || error}`
+                    );
+                    return;
+                  }
+                  Logger.info(
+                    `[${marker} - ${time}] Command executed successfully`
+                  );
+                });
+                return fn(ctx.clone());
+              },
+              __privateMethod(this, _AppCommandRunner_instances, finalizer_fn).bind(this)
             );
-            if (subcommandData) {
-              (_b = subcommandGroupOption.options) == null ? void 0 : _b.push({
-                type: import_discord9.ApplicationCommandOptionType.Subcommand,
-                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.
-       */
-      async register() {
-        if (!this.commandkit.client.isReady()) {
-          throw new Error("Cannot register commands before the client is ready");
-        }
-        const commands = this.getCommandsData();
-        const guildCommands = commands.filter((command) => {
-          var _a;
-          return (_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length;
-        }).map((c) => {
-          var _a;
-          return {
-            ...c,
-            guilds: Array.from(new Set((_a = c.guilds) == null ? void 0 : _a.filter(Boolean)))
-          };
-        });
-        const globalCommands = commands.filter(
-          (command) => {
-            var _a;
-            return !((_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length);
-          }
-        );
-        await this.updateGlobalCommands(globalCommands);
-        await this.updateGuildCommands(guildCommands);
-      }
-      /**
-       * Updates the global commands.
-       */
-      async updateGlobalCommands(commands) {
-        if (!commands.length) return;
-        try {
-          const data = await this.api.put(
-            import_discord9.Routes.applicationCommands(this.commandkit.client.user.id),
-            {
-              body: commands.map((c) => ({
-                ...c,
-                guilds: void 0
-              }))
+            const executeCommand = runCommand != null ? runCommand(_executeCommand) : _executeCommand;
+            env.markStart(prepared.command.command.name);
+            const res = await commandkit2.plugins.execute(async (ctx2, plugin) => {
+              return plugin.executeCommand(ctx2, source, prepared, executeCommand);
+            });
+            if (!res) {
+              await executeCommand();
             }
-          );
-          Logger.info(
-            `\u2728 Refreshed ${data.length} global application (/) commands`
-          );
-        } catch (e) {
-          Logger.error("Failed to update global application (/) commands", e);
+          } catch (e) {
+            Logger.error(e);
+          }
         }
-      }
-      /**
-       * Updates the guild commands.
-       */
-      async updateGuildCommands(commands) {
         try {
-          const guildCommandsMap = /* @__PURE__ */ new Map();
-          commands.forEach((command) => {
-            var _a;
-            if (!((_a = command.guilds) == null ? void 0 : _a.length)) return;
-            command.guilds.forEach((guild) => {
-              if (!guildCommandsMap.has(guild)) {
-                guildCommandsMap.set(guild, []);
-              }
-              guildCommandsMap.get(guild).push(command);
-            });
-          });
-          if (!guildCommandsMap.size) return;
-          let count = 0;
-          for (const [guild, guildCommands] of guildCommandsMap) {
-            const data = await this.api.put(
-              import_discord9.Routes.applicationGuildCommands(
-                this.commandkit.client.user.id,
-                guild
-              ),
-              {
-                body: guildCommands.map((b) => ({
-                  ...b,
-                  guilds: void 0
-                }))
-              }
-            );
-            count += data.length;
+          for (const middleware of prepared.middlewares) {
+            await middleware.data.afterExecute(ctx);
           }
-          Logger.info(`\u2728 Refreshed ${count} guild application (/) commands`);
-        } catch (e) {
-          Logger.error("Failed to update guild application (/) commands", e);
+        } finally {
+          env.markEnd();
+        }
+      }
+      getExecutionMode(source) {
+        if (source instanceof import_discord10.Message) return CommandExecutionMode.Message;
+        if (source.isChatInputCommand()) return CommandExecutionMode.SlashCommand;
+        if (source.isAutocomplete()) {
+          return CommandExecutionMode.Autocomplete;
         }
+        if (source.isMessageContextMenuCommand()) {
+          return CommandExecutionMode.MessageContextMenu;
+        }
+        if (source.isUserContextMenuCommand()) {
+          return CommandExecutionMode.UserContextMenu;
+        }
+        return null;
       }
     };
-    __name(_CommandRegistrar, "CommandRegistrar");
-    CommandRegistrar = _CommandRegistrar;
+    _AppCommandRunner_instances = new WeakSet();
+    finalizer_fn = /* @__PURE__ */ __name(async function() {
+      const env = useEnvironment();
+      await env.runDeferredFunctions();
+      env.clearAllDeferredFunctions();
+    }, "#finalizer");
+    __name(_AppCommandRunner, "AppCommandRunner");
+    AppCommandRunner = _AppCommandRunner;
   }
 });
 
 // src/app/handlers/AppCommandHandler.ts
-var import_discord10, commandDataSchema, middlewareDataSchema, _AppCommandHandler_instances, finalizer_fn, _AppCommandHandler, AppCommandHandler;
+var import_discord11, commandDataSchema, middlewareDataSchema, _AppCommandHandler, AppCommandHandler;
 var init_AppCommandHandler = __esm({
   "src/app/handlers/AppCommandHandler.ts"() {
     "use strict";
     init_cjs_shims();
-    import_discord10 = require("discord.js");
-    init_Context();
+    import_discord11 = require("discord.js");
     init_resolve_file_url();
     init_MessageCommandParser();
     init_error_codes();
     init_CommandRegistrar();
-    init_async_context();
     init_Logger();
-    init_environment();
+    init_AppCommandRunner();
     commandDataSchema = {
-      command: /* @__PURE__ */ __name((c) => c instanceof import_discord10.SlashCommandBuilder || c instanceof import_discord10.ContextMenuCommandBuilder || c && typeof c === "object", "command"),
+      command: /* @__PURE__ */ __name((c) => c instanceof import_discord11.SlashCommandBuilder || c instanceof import_discord11.ContextMenuCommandBuilder || c && typeof c === "object", "command"),
       chatInput: /* @__PURE__ */ __name((c) => typeof c === "function", "chatInput"),
       autocomplete: /* @__PURE__ */ __name((c) => typeof c === "function", "autocomplete"),
       message: /* @__PURE__ */ __name((c) => typeof c === "function", "message"),
@@ -3318,35 +3374,23 @@ var init_AppCommandHandler = __esm({
       afterExecute: /* @__PURE__ */ __name((c) => typeof c === "function", "afterExecute")
     };
     _AppCommandHandler = class _AppCommandHandler {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
-        __privateAdd(this, _AppCommandHandler_instances);
-        __publicField(this, "loadedCommands", new import_discord10.Collection());
-        __publicField(this, "loadedSubCommands", new import_discord10.Collection());
-        __publicField(this, "loadedMiddlewares", new import_discord10.Collection());
-        // Name-to-ID mapping for easier lookup
-        __publicField(this, "commandNameToId", /* @__PURE__ */ new Map());
-        __publicField(this, "subcommandPathToId", /* @__PURE__ */ new Map());
-        __publicField(this, "registrar");
-        __publicField(this, "onInteraction", null);
-        __publicField(this, "onMessageCreate", null);
-        __publicField(this, "onMessageUpdate", null);
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
         this.registrar = new CommandRegistrar(this.commandkit);
       }
+      loadedCommands = new import_discord11.Collection();
+      loadedMiddlewares = new import_discord11.Collection();
+      // Name-to-ID mapping for easier lookup
+      commandNameToId = /* @__PURE__ */ new Map();
+      subcommandPathToId = /* @__PURE__ */ new Map();
+      registrar;
+      onInteraction = null;
+      onMessageCreate = null;
+      onMessageUpdate = null;
+      commandRunner = new AppCommandRunner(this);
       getCommandsArray() {
         return Array.from(this.loadedCommands.values());
       }
-      /**
-       * Get subcommand data by command ID and subcommand name
-       */
-      getSubcommandData(commandId, subcommandName) {
-        const subcommand = Array.from(this.loadedSubCommands.values()).find(
-          (sub) => sub.subcommand.command === commandId && sub.subcommand.name === subcommandName
-        );
-        if (!subcommand) return null;
-        const commandData = subcommand.data.command;
-        return "toJSON" in commandData ? commandData.toJSON() : commandData;
-      }
       registerCommandHandler() {
         this.onInteraction ??= async (interaction) => {
           const success = await this.commandkit.plugins.execute(
@@ -3359,7 +3403,7 @@ var init_AppCommandHandler = __esm({
           if (!isCommandLike) return;
           const prepared = await this.prepareCommandRun(interaction);
           if (!prepared) return;
-          return this.runCommand(prepared, interaction);
+          return this.commandRunner.runCommand(prepared, interaction);
         };
         this.onMessageCreate ??= async (message) => {
           const success = await this.commandkit.plugins.execute(
@@ -3371,7 +3415,7 @@ var init_AppCommandHandler = __esm({
           if (message.author.bot) return;
           const prepared = await this.prepareCommandRun(message);
           if (!prepared) return;
-          return this.runCommand(prepared, message);
+          return this.commandRunner.runCommand(prepared, message);
         };
         this.onMessageUpdate ??= async (oldMessage, newMessage) => {
           const success = await this.commandkit.plugins.execute(
@@ -3388,107 +3432,17 @@ var init_AppCommandHandler = __esm({
           if (oldMessage.author.bot) return;
           const prepared = await this.prepareCommandRun(newMessage);
           if (!prepared) return;
-          return this.runCommand(prepared, newMessage);
+          return this.commandRunner.runCommand(prepared, newMessage);
         };
-        this.commandkit.client.on(import_discord10.Events.InteractionCreate, this.onInteraction);
-        this.commandkit.client.on(import_discord10.Events.MessageCreate, this.onMessageCreate);
-        this.commandkit.client.on(import_discord10.Events.MessageUpdate, this.onMessageUpdate);
-      }
-      getExecutionMode(source) {
-        if (source instanceof import_discord10.Message) return CommandExecutionMode.Message;
-        if (source.isChatInputCommand()) return CommandExecutionMode.SlashCommand;
-        if (source.isAutocomplete()) {
-          return CommandExecutionMode.Autocomplete;
-        }
-        if (source.isMessageContextMenuCommand()) {
-          return CommandExecutionMode.MessageContextMenu;
-        }
-        if (source.isUserContextMenuCommand()) {
-          return CommandExecutionMode.UserContextMenu;
-        }
-        return null;
-      }
-      async runCommand(prepared, source) {
-        if (source instanceof import_discord10.Message && (source.editedTimestamp || source.partial)) {
-          return;
-        }
-        const executionMode = this.getExecutionMode(source);
-        let runCommand = null;
-        const env = new CommandKitEnvironment(this.commandkit);
-        env.setType("COMMAND_HANDLER" /* CommandHandler */);
-        env.variables.set("commandHandlerType", "app");
-        env.variables.set("currentCommandName", prepared.command.command.name);
-        env.variables.set("execHandlerKind", executionMode);
-        const ctx = new MiddlewareContext(this.commandkit, {
-          environment: env,
-          executionMode,
-          interaction: !(source instanceof import_discord10.Message) ? source : null,
-          message: source instanceof import_discord10.Message ? source : null,
-          forwarded: false,
-          customArgs: {
-            setCommandRunner: /* @__PURE__ */ __name((fn2) => {
-              runCommand = fn2;
-            }, "setCommandRunner")
-          }
-        });
-        for (const middleware of prepared.middlewares) {
-          await middleware.data.beforeExecute(ctx);
-        }
-        const targetData = prepared.subcommand ? prepared.subcommand.data : prepared.command.data;
-        const fn = targetData[executionMode];
-        if (!fn) {
-          Logger.warn(
-            `Command ${prepared.command.command.name}${prepared.subcommand ? "/" + prepared.subcommand.subcommand.name : ""} has no handler for ${executionMode}`
-          );
-        }
-        if (fn) {
-          try {
-            const _executeCommand = makeContextAwareFunction(
-              env,
-              async () => fn(ctx.clone()),
-              __privateMethod(this, _AppCommandHandler_instances, finalizer_fn).bind(this)
-            );
-            const executeCommand = runCommand != null ? runCommand(_executeCommand) : _executeCommand;
-            afterCommand((env2) => {
-              const error = env2.getExecutionError();
-              const marker = env2.getMarker();
-              const time = `${env2.getExecutionTime().toFixed(2)}ms`;
-              if (error) {
-                Logger.error(
-                  `[${marker} - ${time}] Error executing command: ${error.stack || error}`
-                );
-                return;
-              }
-              Logger.info(`[${marker} - ${time}] Command executed successfully`);
-            });
-            env.markStart(prepared.command.command.name);
-            const res = await this.commandkit.plugins.execute(
-              async (ctx2, plugin) => {
-                return plugin.executeCommand(ctx2, source, prepared, executeCommand);
-              }
-            );
-            if (!res) {
-              await executeCommand();
-            }
-          } catch (e) {
-            Logger.error(e);
-          }
-        }
-        try {
-          for (const middleware of prepared.middlewares) {
-            await middleware.data.afterExecute(ctx);
-          }
-        } finally {
-          env.markEnd();
-        }
+        this.commandkit.client.on(import_discord11.Events.InteractionCreate, this.onInteraction);
+        this.commandkit.client.on(import_discord11.Events.MessageCreate, this.onMessageCreate);
+        this.commandkit.client.on(import_discord11.Events.MessageUpdate, this.onMessageUpdate);
       }
       async prepareCommandRun(source) {
         var _a;
         let cmdName;
-        let subcommandGroupName = null;
-        let subcommandName = null;
         let parser2;
-        if (source instanceof import_discord10.Message) {
+        if (source instanceof import_discord11.Message) {
           if (source.author.bot) return null;
           const prefix = await this.commandkit.config.getMessageCommandPrefix(source);
           parser2 = new MessageCommandParser(
@@ -3517,14 +3471,6 @@ var init_AppCommandHandler = __esm({
             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;
@@ -3535,31 +3481,16 @@ var init_AppCommandHandler = __esm({
         } else {
           if (!source.isCommand()) return null;
           cmdName = source.commandName;
-          if (source.isChatInputCommand()) {
-            subcommandGroupName = source.options.getSubcommandGroup(false);
-            subcommandName = source.options.getSubcommand(false);
-          }
         }
         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)) {
+        if (source instanceof import_discord11.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.middlewareIds) {
+        for (const middlewareId of loadedCommand.command.middlewares) {
           const middleware = this.loadedMiddlewares.get(middlewareId);
           if (middleware) {
             middlewares.push(middleware);
@@ -3567,14 +3498,12 @@ var init_AppCommandHandler = __esm({
         }
         return {
           command: loadedCommand,
-          subcommand: loadedSubCommand,
           middlewares,
           messageCommandParser: parser2
         };
       }
       async reloadCommands() {
         this.loadedCommands.clear();
-        this.loadedSubCommands.clear();
         this.loadedMiddlewares.clear();
         this.commandNameToId.clear();
         this.subcommandPathToId.clear();
@@ -3592,13 +3521,6 @@ var init_AppCommandHandler = __esm({
         for (const [id, command] of commands) {
           await this.loadCommand(id, command);
         }
-        for (const loadedCommand of this.loadedCommands.values()) {
-          if (loadedCommand.command.subcommands) {
-            for (const subcommand of loadedCommand.command.subcommands) {
-              await this.loadSubcommand(subcommand);
-            }
-          }
-        }
       }
       async loadMiddleware(id, middleware) {
         try {
@@ -3673,59 +3595,20 @@ var init_AppCommandHandler = __esm({
           Logger.error(`Failed to load command ${command.name} (${id})`, error);
         }
       }
-      async loadSubcommand(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 },
-            subcommand
-          );
-          const subcommandId = subcommand.command + "/" + subcommand.name;
-          this.loadedSubCommands.set(subcommandId, {
-            subcommand,
-            data: {
-              ...data,
-              command: localizedCommand
-            }
-          });
-          this.subcommandPathToId.set(subcommandId, subcommandId);
-        } catch (error) {
-          Logger.error(`Failed to load subcommand ${subcommand.name}`, error);
-        }
-      }
-      async applyLocalizations(command, subcommand) {
+      async applyLocalizations(command) {
         var _a, _b, _c, _d, _e;
         const localization = this.commandkit.config.localizationStrategy;
-        const validLocales = Object.values(import_discord10.Locale).filter(
+        const validLocales = Object.values(import_discord11.Locale).filter(
           (v) => typeof v === "string"
         );
-        const localizationKey = subcommand ? command.name.split("/")[0] : command.name;
+        const localizationKey = command.name;
         for (const locale of validLocales) {
           const translation = await localization.locateTranslation(
             localizationKey,
             locale
           );
           if (!(translation == null ? void 0 : translation.command)) continue;
-          if (command instanceof import_discord10.SlashCommandBuilder) {
+          if (command instanceof import_discord11.SlashCommandBuilder) {
             if (translation.command.name) {
               command.setNameLocalization(locale, translation.command.name);
             }
@@ -3742,7 +3625,6 @@ var init_AppCommandHandler = __esm({
               while (o = opt.shift()) {
                 (_c = raw.options) == null ? void 0 : _c.forEach((option) => {
                   var _a2;
-                  if (subcommand && option.name !== subcommand.name) return;
                   if (option.name === o.ref) {
                     if (option.name) {
                       option.name_localizations ??= {};
@@ -3772,14 +3654,14 @@ var init_AppCommandHandler = __esm({
                 });
               }
             }
-          } else if (command instanceof import_discord10.ContextMenuCommandBuilder) {
+          } else if (command instanceof import_discord11.ContextMenuCommandBuilder) {
             if (translation.command.name) {
               command.setNameLocalization(locale, translation.command.name);
             }
           } else {
             command.name_localizations ??= {};
             command.name_localizations[locale] = translation.command.name;
-            if (!subcommand && command.description) {
+            if (command.description) {
               command.description_localizations ??= {};
               command.description_localizations[locale] = translation.command.description;
             }
@@ -3789,7 +3671,6 @@ var init_AppCommandHandler = __esm({
               while (o = opt.shift()) {
                 command.options.forEach((option) => {
                   var _a2;
-                  if (subcommand && option.name !== subcommand.name) return;
                   if (option.name === o.ref) {
                     option.name_localizations ??= {};
                     option.name_localizations[locale] = o.name;
@@ -3822,50 +3703,70 @@ var init_AppCommandHandler = __esm({
         return command;
       }
     };
-    _AppCommandHandler_instances = new WeakSet();
-    finalizer_fn = /* @__PURE__ */ __name(async function() {
-      const env = useEnvironment();
-      await env.runDeferredFunctions();
-      env.clearAllDeferredFunctions();
-    }, "#finalizer");
     __name(_AppCommandHandler, "AppCommandHandler");
     AppCommandHandler = _AppCommandHandler;
   }
 });
 
 // src/app/router/CommandsRouter.ts
-var import_discord11, import_node_fs3, import_node_crypto3, import_walk, import_node_path3, _CommandsRouter, CommandsRouter;
+var import_node_fs3, import_promises3, import_node_path3, MIDDLEWARE_PATTERN, COMMAND_PATTERN, CATEGORY_PATTERN, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_discord11 = require("discord.js");
     import_node_fs3 = require("fs");
-    import_node_crypto3 = __toESM(require("crypto"));
-    import_walk = __toESM(require("@root/walk"));
-    import_node_path3 = __toESM(require("path"));
+    import_promises3 = require("fs/promises");
+    import_node_path3 = require("path");
+    MIDDLEWARE_PATTERN = /^\+middleware\.(m|c)?(j|t)sx?$/;
+    COMMAND_PATTERN = /^(\w+)\.(m|c)?(j|t)sx?$/;
+    CATEGORY_PATTERN = /^\(\w+\)$/;
     _CommandsRouter = class _CommandsRouter {
       constructor(options) {
         this.options = options;
       }
-      commands = new import_discord11.Collection();
-      middlewares = new import_discord11.Collection();
-      fromData(data) {
-        this.commands = new import_discord11.Collection(
-          Object.entries(data.commands).map(([id, command]) => [id, command])
-        );
-        this.middlewares = new import_discord11.Collection(
-          Object.entries(data.middlewares).map(
-            ([id, middleware]) => [
-              id,
-              middleware
-            ]
-          )
-        );
+      commands = /* @__PURE__ */ new Map();
+      middlewares = /* @__PURE__ */ new Map();
+      populate(data) {
+        for (const [id, command] of Object.entries(data.commands)) {
+          this.commands.set(id, command);
+        }
+        for (const [id, middleware] of Object.entries(data.middlewares)) {
+          this.middlewares.set(id, middleware);
+        }
       }
       isValidPath() {
         return (0, import_node_fs3.existsSync)(this.options.entrypoint);
       }
+      isCommand(name) {
+        return COMMAND_PATTERN.test(name);
+      }
+      isMiddleware(name) {
+        return MIDDLEWARE_PATTERN.test(name);
+      }
+      isCategory(name) {
+        return CATEGORY_PATTERN.test(name);
+      }
+      clear() {
+        this.commands.clear();
+        this.middlewares.clear();
+      }
+      async scan() {
+        const entries = await (0, import_promises3.readdir)(this.options.entrypoint, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          if (entry.name.startsWith("_")) continue;
+          const fullPath = (0, import_node_path3.join)(this.options.entrypoint, entry.name);
+          if (entry.isDirectory()) {
+            const category = this.isCategory(entry.name) ? entry.name.slice(1, -1) : null;
+            await this.traverse(fullPath, category);
+          } else {
+            await this.handle(entry);
+          }
+        }
+        await this.applyMiddlewares();
+        return this.toJSON();
+      }
       getData() {
         return {
           commands: this.commands,
@@ -3878,164 +3779,58 @@ var init_CommandsRouter = __esm({
           middlewares: Object.fromEntries(this.middlewares.entries())
         };
       }
-      clear() {
-        this.commands.clear();
-        this.middlewares.clear();
-      }
-      reload() {
-        this.clear();
-        return this.scan();
-      }
-      async scan() {
-        if (!this.isValidPath()) {
-          throw new Error("Invalid path");
-        }
-        await this.traverse();
-        this.applyBindings();
-        return this.toJSON();
-      }
-      async traverse() {
-        const validFile = /\.(c|m)?(j|t)sx?$/;
-        const middleware = /^(\w+\.)?middleware\.(c|m)?(j|t)sx?$/;
-        const categoryDir = /^\((\w+)\)$/;
-        const isCategory = /* @__PURE__ */ __name((name) => categoryDir.test(name), "isCategory");
-        const isMiddleware = /* @__PURE__ */ __name((name) => middleware.test(name), "isMiddleware");
-        const isCommand = /* @__PURE__ */ __name((name) => validFile.test(name) && !isMiddleware(name), "isCommand");
-        await import_walk.default.walk(
-          this.options.entrypoint,
-          async (error, pathname, dirent) => {
-            if (error) throw error;
-            const name = dirent.name;
-            if (dirent.isDirectory()) {
-              if (isCategory(name) && this.distanceFromRoot(pathname) > 1) {
-                throw new Error(
-                  `Category directories must be at the root. Found "${name}" at "${pathname}"`
-                );
-              }
-              return;
-            }
-            if (this.distanceFromRoot(pathname, true) > 1) return;
-            if (isMiddleware(name)) {
-              const middleware2 = {
-                id: import_node_crypto3.default.randomUUID(),
-                path: pathname,
-                relativePath: this.toRelativePath(pathname)
-              };
-              this.middlewares.set(middleware2.id, middleware2);
-              return;
-            }
-            if (!isCommand(name)) return;
-            const command = {
-              id: import_node_crypto3.default.randomUUID(),
-              name: this.parseFileName(name),
-              category: this.parseCategory(pathname),
-              middlewareIds: [],
-              path: pathname,
-              relativePath: this.toRelativePath(pathname),
-              subcommands: []
-            };
-            this.commands.set(command.id, command);
-          }
-        );
-        await import_walk.default.walk(
-          this.options.entrypoint,
-          async (error, pathname, dirent) => {
-            if (error) throw error;
-            const name = dirent.name;
-            if (dirent.isDirectory()) return;
-            if (this.distanceFromRoot(pathname, true) <= 1) return;
-            if (isMiddleware(name)) {
-              const middleware2 = {
-                id: import_node_crypto3.default.randomUUID(),
-                path: pathname,
-                relativePath: this.toRelativePath(pathname)
-              };
-              this.middlewares.set(middleware2.id, middleware2);
-              return;
-            }
-            if (!isCommand(name)) return;
-            let currentDir = import_node_path3.default.dirname(pathname);
-            let parentCommand;
-            while (currentDir !== this.options.entrypoint) {
-              const dirName = import_node_path3.default.basename(currentDir);
-              parentCommand = Array.from(this.commands.values()).find(
-                (cmd) => import_node_path3.default.basename(import_node_path3.default.dirname(cmd.path)) === import_node_path3.default.basename(import_node_path3.default.dirname(currentDir)) && this.parseFileName(cmd.path) === dirName
-              );
-              if (parentCommand) break;
-              currentDir = import_node_path3.default.dirname(currentDir);
-            }
-            if (parentCommand) {
-              const subcommand = {
-                name: this.parseFileName(name),
-                group: this.parseGroup(pathname),
-                path: pathname,
-                relativePath: this.toRelativePath(pathname),
-                command: parentCommand.id
-              };
-              parentCommand.subcommands.push(subcommand);
-            }
-          }
-        );
-      }
-      applyBindings() {
-        for (const command of this.commands.values()) {
-          const commandName = command.name;
-          const commandDir = import_node_path3.default.dirname(command.path);
-          for (const middleware of this.middlewares.values()) {
-            const middlewareDir = import_node_path3.default.dirname(middleware.path);
-            const middlewareFileName = import_node_path3.default.basename(middleware.path);
-            const isCommandSpecificMiddleware = middlewareFileName.startsWith(
-              commandName + "."
-            );
-            const isSharedMiddleware = middlewareFileName === "middleware.ts" || middlewareFileName === "middleware.js";
-            if (isCommandSpecificMiddleware && middlewareFileName.startsWith(commandName + ".")) {
-              command.middlewareIds.push(middleware.id);
-              continue;
-            }
-            if (isSharedMiddleware) {
-              const relPath = import_node_path3.default.relative(middlewareDir, commandDir);
-              if (!relPath.startsWith("..") && !import_node_path3.default.isAbsolute(relPath)) {
-                command.middlewareIds.push(middleware.id);
-              }
+      async traverse(path2, category) {
+        const entries = await (0, import_promises3.readdir)(path2, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          if (entry.name.startsWith("_")) continue;
+          if (entry.isFile()) {
+            if (this.isCommand(entry.name) || this.isMiddleware(entry.name)) {
+              await this.handle(entry, category);
             }
           }
         }
       }
-      distanceFromRoot(pathname, isFile = false) {
-        const entrypointParts = this.options.entrypoint.split(import_node_path3.default.sep);
-        const pathParts = (!isFile ? pathname : import_node_path3.default.dirname(pathname)).split(
-          import_node_path3.default.sep
-        );
-        const relativeParts = pathParts.slice(entrypointParts.length);
-        return relativeParts.filter((part) => !part.match(/^\(.*\)$/)).length;
-      }
-      parseGroup(pathname) {
-        const parts = pathname.split(import_node_path3.default.sep);
-        const parentDirIndex = parts.findIndex(
-          (part) => this.commands.some((cmd) => cmd.name === part)
-        );
-        if (parentDirIndex === -1) return null;
-        const groupName = parts[parts.length - 2];
-        if (!groupName || groupName === parts[parentDirIndex] || groupName.match(/^\(.*\)$/)) {
-          return null;
-        }
-        return groupName;
-      }
-      parseCategory(pathname) {
-        const parts = pathname.split(import_node_path3.default.sep);
-        const entrypointParts = this.options.entrypoint.split(import_node_path3.default.sep);
-        const relativeIndex = entrypointParts.length;
-        const categoryDir = parts[relativeIndex];
-        if (!categoryDir || !/^\((\w+)\)$/.test(categoryDir)) {
-          return null;
+      async handle(entry, category = null) {
+        const name = entry.name;
+        const path2 = (0, import_node_path3.join)(entry.parentPath, entry.name);
+        if (this.isCommand(name)) {
+          const command = {
+            id: crypto.randomUUID(),
+            name: (0, import_node_path3.basename)(path2, (0, import_node_path3.extname)(path2)),
+            path: path2,
+            category,
+            parentPath: entry.parentPath,
+            relativePath: this.replaceEntrypoint(path2),
+            middlewares: []
+          };
+          this.commands.set(command.id, command);
+        } else if (this.isMiddleware(name)) {
+          const middleware = {
+            id: crypto.randomUUID(),
+            name: (0, import_node_path3.basename)(path2, (0, import_node_path3.extname)(path2)),
+            path: path2,
+            relativePath: this.replaceEntrypoint(path2),
+            parentPath: entry.parentPath
+          };
+          this.middlewares.set(middleware.id, middleware);
         }
-        return categoryDir.slice(1, -1);
       }
-      parseFileName(filename) {
-        return import_node_path3.default.basename(filename, import_node_path3.default.extname(filename));
+      applyMiddlewares() {
+        this.commands.forEach((command) => {
+          const commandPath = command.parentPath;
+          const samePathMiddlewares = Array.from(this.middlewares.values()).filter((middleware) => {
+            return middleware.parentPath === commandPath;
+          }).map((middleware) => middleware.id);
+          command.middlewares = Array.from(
+            /* @__PURE__ */ new Set([...command.middlewares, ...samePathMiddlewares])
+          );
+        });
       }
-      toRelativePath(pathname) {
-        return import_node_path3.default.relative(this.options.entrypoint, pathname);
+      replaceEntrypoint(path2) {
+        const normalized = (0, import_node_path3.normalize)(path2);
+        return normalized.replace(this.options.entrypoint, "");
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -4044,13 +3839,13 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_node_fs4, import_promises3, import_node_path4, _EventsRouter, EventsRouter;
+var import_node_fs4, import_promises4, import_node_path4, _EventsRouter, EventsRouter;
 var init_EventsRouter = __esm({
   "src/app/router/EventsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs4 = require("fs");
-    import_promises3 = require("fs/promises");
+    import_promises4 = require("fs/promises");
     import_node_path4 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
@@ -4106,12 +3901,11 @@ var init_EventsRouter = __esm({
        * @returns Promise resolving to the events tree
        */
       async scan() {
-        const dirs = await (0, import_promises3.readdir)(this.entrypoint, { withFileTypes: true });
+        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 event = await this.scanEvent(dir.name, path3);
-            this.events.set(event.event, event);
+            const path2 = (0, import_node_path4.join)(this.entrypoint, dir.name);
+            await this.scanEvent(dir.name, path2, null, [], true);
           }
         }
         return Object.fromEntries(this.events);
@@ -4130,23 +3924,24 @@ var init_EventsRouter = __esm({
        * @param listeners - Array to collect listener file paths
        * @returns Promise resolving to the parsed event metadata
        */
-      async scanEvent(event, path3, listeners = []) {
-        var _a;
-        const files = await (0, import_promises3.readdir)(path3, { withFileTypes: true });
+      async scanEvent(event, path2, _namespace = null, listeners = [], isRoot = false) {
+        const files = await (0, import_promises4.readdir)(path2, { withFileTypes: true });
+        const isNamespace = isRoot && /^\(.+\)$/.test(event);
+        const namespace = isNamespace ? event.slice(1, -1) : _namespace ?? null;
         for (const file of files) {
-          if (/node_modules/.test(file.name)) continue;
+          if (file.name.includes("_")) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path4.join)(path3, file.name);
-            await this.scanEvent(event, nextPath, listeners);
+            const nextPath = (0, import_node_path4.join)(path2, file.name);
+            await this.scanEvent(file.name, nextPath, namespace, listeners);
             continue;
           }
           if (file.isFile() && /\.(m|c)?(j|t)sx?$/.test(file.name)) {
             listeners.push((0, import_node_path4.join)(file.parentPath, file.name));
           }
         }
-        const maybeNamespace = path3.replace(this.entrypoint, "").replaceAll("\\", "/").split("/").shift();
-        const namespace = maybeNamespace && ((_a = /\(([^)]+)\)/.exec(maybeNamespace)) == null ? void 0 : _a[1]) || null;
-        return { event, path: path3, listeners, namespace };
+        if (!isNamespace) {
+          this.events.set(event, { event, path: path2, listeners, namespace });
+        }
       }
     };
     __name(_EventsRouter, "EventsRouter");
@@ -4173,8 +3968,8 @@ var init_AppEventsHandler = __esm({
     init_Logger();
     init_resolve_file_url();
     _AppEventsHandler = class _AppEventsHandler {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
       }
       loadedEvents = /* @__PURE__ */ new Map();
       async reloadEvents() {
@@ -4344,21 +4139,21 @@ async function generateTypesPackage() {
       command: CommandTypeData;
     }
   }`;
-  await (0, import_promises4.mkdir)(location, { recursive: true });
-  await (0, import_promises4.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
-  await (0, import_promises4.writeFile)(index, indexContent);
-  await (0, import_promises4.writeFile)(types, typesContent);
-  await (0, import_promises4.writeFile)(locale, "");
-  await (0, import_promises4.writeFile)(command, "");
+  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_promises4, import_node_path5;
+var import_node_fs5, import_promises5, import_node_path5;
 var init_types_package = __esm({
   "src/utils/types-package.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs5 = require("fs");
-    import_promises4 = require("fs/promises");
+    import_promises5 = require("fs/promises");
     import_node_path5 = require("path");
     __name(generateTypesPackage, "generateTypesPackage");
   }
@@ -4477,24 +4272,24 @@ var init_loader = __esm({
 });
 
 // src/utils/dev-hooks.ts
-function registerDevHooks(commandkit) {
+function registerDevHooks(commandkit2) {
   if (!COMMANDKIT_IS_DEV) return;
   process.on("message", (message) => {
     if (typeof message !== "object" || message === null) return;
-    const { event, path: path3 } = message;
+    const { event, path: path2 } = message;
     if (!event) return;
     if (process.env.COMMANDKIT_DEBUG_HMR === "true") {
-      Logger.info(`Received HMR event: ${event}${path3 ? ` for ${path3}` : ""}`);
+      Logger.info(`Received HMR event: ${event}${path2 ? ` for ${path2}` : ""}`);
     }
     switch (event) {
       case "reload-commands":
-        commandkit.commandHandler.reloadCommands();
+        commandkit2.commandHandler.reloadCommands();
         break;
       case "reload-events":
-        commandkit.eventHandler.reloadEvents();
+        commandkit2.eventHandler.reloadEvents();
         break;
       case "reload-locales":
-        commandkit.commandHandler.reloadCommands();
+        commandkit2.commandHandler.reloadCommands();
         break;
     }
   });
@@ -4517,8 +4312,8 @@ var init_CommandKitEventsChannel = __esm({
     init_cjs_shims();
     import_node_events = __toESM(require("events"));
     _CommandKitEventsChannel = class _CommandKitEventsChannel {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
+      constructor(commandkit2) {
+        this.commandkit = commandkit2;
       }
       emitter = new import_node_events.default();
       to(namespace) {
@@ -4556,7 +4351,7 @@ var init_CommandKitEventsChannel = __esm({
 });
 
 // src/CommandKit.ts
-var import_node_events2, import_discord12, import_node_path8, import_node_fs8, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
+var import_node_events2, import_discord12, import_node_path8, import_node_fs8, commandkit, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
@@ -4634,6 +4429,7 @@ var init_CommandKit = __esm({
         if (!_CommandKit.instance) {
           _CommandKit.instance = this;
         }
+        commandkit = _CommandKit.instance;
       }
       /**
        * Starts the commandkit application.
@@ -4868,7 +4664,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250309035914";
+    "0.1.11-dev.20250327153237";
   }
 });
 
@@ -5027,9 +4823,9 @@ async function main() {
 await main();
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
-  await (0, import_promises5.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
+  await (0, import_promises6.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
 }
-var import_tsup, import_promises5, import_node_path10, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
+var import_tsup, import_promises6, import_node_path10, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -5037,7 +4833,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_path10 = require("path");
     init_env();
     __name(buildApplication, "buildApplication");
@@ -5117,40 +4913,40 @@ async function bootstrapDevelopmentServer(configPath) {
     ignoreInitial: true
   });
   let ps = null;
-  const performHMR = debounce(async (path3) => {
-    if (!path3 || !ps) return false;
+  const performHMR = debounce(async (path2) => {
+    if (!path2 || !ps) return false;
     if (!ps.send) return false;
-    if (isCommandSource(path3)) {
+    if (isCommandSource(path2)) {
       console.log(
-        `${colors_default.cyanBright("Reloading command(s) at ")} ${colors_default.yellowBright(path3)}`
+        `${colors_default.cyanBright("Reloading command(s) at ")} ${colors_default.yellowBright(path2)}`
       );
       await buildAndStart(cwd, true);
-      ps.send({ event: "reload-commands", path: path3 });
+      ps.send({ event: "reload-commands", path: path2 });
       return true;
     }
-    if (isEventSource(path3)) {
+    if (isEventSource(path2)) {
       console.log(
-        `${colors_default.cyanBright("Reloading event(s) at ")} ${colors_default.yellowBright(path3)}`
+        `${colors_default.cyanBright("Reloading event(s) at ")} ${colors_default.yellowBright(path2)}`
       );
       await buildAndStart(cwd, true);
-      ps.send({ event: "reload-events", path: path3 });
+      ps.send({ event: "reload-events", path: path2 });
       return true;
     }
-    if (isLocaleSource(path3)) {
+    if (isLocaleSource(path2)) {
       console.log(
-        `${colors_default.cyanBright("Reloading locale(s) at ")} ${colors_default.yellowBright(path3)}`
+        `${colors_default.cyanBright("Reloading locale(s) at ")} ${colors_default.yellowBright(path2)}`
       );
       await buildAndStart(cwd, true);
-      ps.send({ event: "reload-locales", path: path3 });
+      ps.send({ event: "reload-locales", path: path2 });
       return true;
     }
     return false;
   }, 300);
-  const hmrHandler = /* @__PURE__ */ __name(async (path3) => {
-    const hmr = await performHMR(path3);
+  const hmrHandler = /* @__PURE__ */ __name(async (path2) => {
+    const hmr = await performHMR(path2);
     if (hmr) return;
     console.log(
-      `${colors_default.yellowBright("\u26A1\uFE0F Performing full restart due to the changes in")} ${colors_default.cyanBright(path3)}`
+      `${colors_default.yellowBright("\u26A1\uFE0F Performing full restart due to the changes in")} ${colors_default.cyanBright(path2)}`
     );
     ps == null ? void 0 : ps.kill();
     ps = await buildAndStart(cwd);
@@ -5230,7 +5026,7 @@ async function createSpinner(text) {
   });
 }
 var ora;
-var init_utils2 = __esm({
+var init_utils = __esm({
   "src/cli/utils.ts"() {
     "use strict";
     init_cjs_shims();
@@ -5280,7 +5076,7 @@ var init_production = __esm({
     init_common();
     init_build();
     init_plugins();
-    init_utils2();
+    init_utils();
     __name(bootstrapProductionServer, "bootstrapProductionServer");
     __name(createProductionBuild, "createProductionBuild");
   }
@@ -5295,7 +5091,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.`);
   }
@@ -5315,7 +5111,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`
@@ -5324,10 +5120,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 = `
@@ -5335,7 +5131,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)}`
@@ -5353,7 +5149,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.`);
   }
@@ -5364,7 +5160,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)
   );
@@ -5376,12 +5172,12 @@ async function generateLocale(locale, commandName, customPath) {
     )
   );
 }
-var import_promises6, import_path4, import_discord13, 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_discord13 = require("discord.js");
     init_common();
@@ -5391,7 +5187,7 @@ var init_generators = __esm({
     COMMANDS_DIR = (0, import_path4.join)(BASE_PATH, "src/app/commands");
     EVENTS_DIR = (0, import_path4.join)(BASE_PATH, "src/app/events");
     LOCALES_DIR = (0, import_path4.join)(BASE_PATH, "src/app/locales");
-    formatPath = /* @__PURE__ */ __name((path3) => path3.replace(process.cwd(), ".").replace(/\\/g, "/"), "formatPath");
+    formatPath = /* @__PURE__ */ __name((path2) => path2.replace(process.cwd(), ".").replace(/\\/g, "/"), "formatPath");
     __name(generateCommand, "generateCommand");
     __name(generateEvent, "generateEvent");
     __name(generateLocale, "generateLocale");
@@ -5410,7 +5206,10 @@ __export(index_exports, {
   CommandKit: () => CommandKit,
   CommandKitEnvironment: () => CommandKitEnvironment,
   CommandKitEnvironmentType: () => CommandKitEnvironmentType,
+  CommandKitPluginRuntime: () => CommandKitPluginRuntime,
   CommandsRouter: () => CommandsRouter,
+  CompilerPlugin: () => CompilerPlugin,
+  CompilerPluginRuntime: () => CompilerPluginRuntime,
   Context: () => Context,
   DefaultLocalizationStrategy: () => DefaultLocalizationStrategy,
   DefaultLogger: () => DefaultLogger,
@@ -5427,6 +5226,7 @@ __export(index_exports, {
   Modal: () => Modal,
   ModalKit: () => ModalKit,
   ParagraphInput: () => ParagraphInput,
+  RuntimePlugin: () => RuntimePlugin,
   ShortInput: () => ShortInput,
   TextInput: () => TextInput,
   afterCommand: () => afterCommand,
@@ -5435,6 +5235,7 @@ __export(index_exports, {
   cacheLife: () => cacheLife,
   cacheTag: () => cacheTag,
   cancelAfterCommand: () => cancelAfterCommand,
+  commandkit: () => commandkit,
   createElement: () => createElement,
   createLogger: () => createLogger,
   default: () => index_default,
@@ -5442,6 +5243,7 @@ __export(index_exports, {
   dmOnly: () => dmOnly,
   exitContext: () => exitContext,
   exitMiddleware: () => exitMiddleware,
+  fromEsbuildPlugin: () => fromEsbuildPlugin,
   getCommandKit: () => getCommandKit,
   getConfig: () => getConfig,
   getContext: () => getContext,
@@ -5450,6 +5252,8 @@ __export(index_exports, {
   invalidate: () => invalidate,
   isCachedFunction: () => isCachedFunction,
   isCommandKitElement: () => isCommandKitElement,
+  isCompilerPlugin: () => isCompilerPlugin,
+  isRuntimePlugin: () => isRuntimePlugin,
   makeContextAwareFunction: () => makeContextAwareFunction,
   redirect: () => redirect,
   rethrow: () => rethrow,
@@ -5495,6 +5299,7 @@ init_cjs_shims();
 init_Logger();
 init_router();
 init_version();
+init_plugins();
 
 // src/cli/init.ts
 init_cjs_shims();
@@ -5561,7 +5366,10 @@ var index_default = CommandKit;
   CommandKit,
   CommandKitEnvironment,
   CommandKitEnvironmentType,
+  CommandKitPluginRuntime,
   CommandsRouter,
+  CompilerPlugin,
+  CompilerPluginRuntime,
   Context,
   DefaultLocalizationStrategy,
   DefaultLogger,
@@ -5578,6 +5386,7 @@ var index_default = CommandKit;
   Modal,
   ModalKit,
   ParagraphInput,
+  RuntimePlugin,
   ShortInput,
   TextInput,
   afterCommand,
@@ -5586,12 +5395,14 @@ var index_default = CommandKit;
   cacheLife,
   cacheTag,
   cancelAfterCommand,
+  commandkit,
   createElement,
   createLogger,
   defineConfig,
   dmOnly,
   exitContext,
   exitMiddleware,
+  fromEsbuildPlugin,
   getCommandKit,
   getConfig,
   getContext,
@@ -5600,6 +5411,8 @@ var index_default = CommandKit;
   invalidate,
   isCachedFunction,
   isCommandKitElement,
+  isCompilerPlugin,
+  isRuntimePlugin,
   makeContextAwareFunction,
   redirect,
   rethrow,