commandkit 0.1.11-dev.20250314022547 → 0.1.11-dev.20250328083250

package/dist/index.js

@@ -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,13 +1965,24 @@ var init_config = __esm({
     "use strict";
     init_cjs_shims();
     init_default();
-    init_utils();
     defined = defaultConfig;
     __name(getConfig, "getConfig");
     __name(defineConfig, "defineConfig");
   }
 });
 
+// src/utils/constants.ts
+var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    init_cjs_shims();
+    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
+    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
+    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
+  }
+});
+
 // src/app/i18n/DefaultLocalizationStrategy.ts
 var import_promises2, import_node_path, import_node_fs, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
 var init_DefaultLocalizationStrategy = __esm({
@@ -1975,6 +1993,7 @@ var init_DefaultLocalizationStrategy = __esm({
     import_node_path = require("path");
     init_config();
     import_node_fs = require("fs");
+    init_constants();
     _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
       constructor(commandkit2) {
         this.commandkit = commandkit2;
@@ -1983,17 +2002,38 @@ var init_DefaultLocalizationStrategy = __esm({
       async locateTranslation(scope, locale) {
         const localesPath = this.commandkit.getPath("locales");
         if (!localesPath) return null;
-        const path3 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
-        try {
-          const data = await (0, import_promises2.readFile)(path3, "utf-8");
-          const localeData = JSON.parse(data);
-          await this.generateLocaleTypes(localeData);
-          return localeData;
-        } catch {
-          return null;
+        const paths = [".js", ".json", ".mjs", ".cjs"].map(
+          (e) => (0, import_node_path.join)(localesPath, locale, scope) + e
+        );
+        for (const path2 of paths) {
+          if (!(0, import_node_fs.existsSync)(path2)) {
+            continue;
+          }
+          try {
+            let localeData;
+            try {
+              if (path2.endsWith(".json")) {
+                const data = await (0, import_promises2.readFile)(path2, "utf-8");
+                localeData = JSON.parse(data);
+              } else {
+                const { default: data } = await import(`file://${path2}`);
+                localeData = data;
+              }
+            } catch {
+              continue;
+            }
+            if (!localeData) continue;
+            await this.generateLocaleTypes(localeData).catch(() => {
+            });
+            return localeData;
+          } catch {
+            return null;
+          }
         }
+        return null;
       }
       async generateLocaleTypes(localeData) {
+        if (!COMMANDKIT_IS_DEV) return;
         const { typedLocales } = getConfig();
         if (!typedLocales) return;
         const file = (0, import_node_path.join)(
@@ -2003,43 +2043,58 @@ var init_DefaultLocalizationStrategy = __esm({
           "locale_types.d.ts"
         );
         const header = `// auto generated file do not edit
+export {};
 declare module 'commandkit' {
   export interface CommandLocalizationTypeData {
 `;
-        const footer = `  }
+        const footer = `  type TranslatableCommandName = keyof CommandLocalizationTypeData
+}
 }`;
         const generateType = /* @__PURE__ */ __name((locale) => {
-          return `"${locale.command}": ${JSON.stringify(
-            Object.entries(locale.translations).map(([key, value]) => {
-              const args = value.match(/{([^}]+)}/g);
-              if (!args) return `${JSON.stringify(key)}: null`;
-              return `${JSON.stringify(key)}: ${args.map((arg) => arg.slice(1, -1)).join(" | ")}`;
-            }),
-            null,
-            2
-          )}`;
+          const commandName = locale.command.name;
+          const translationTypes = Object.entries(locale.translations).map(([key, value]) => {
+            const args = value.match(/{([^}]+)}/g);
+            if (!args) {
+              return `    "${key}": null`;
+            }
+            const argUnion = args.map((arg) => `"${arg.slice(1, -1)}"`).join(" | ");
+            return `    "${key}": ${argUnion}`;
+          }).join(",\n");
+          return `  "${commandName}": {
+${translationTypes}
+  }`;
         }, "generateType");
-        if (!(0, import_node_fs.existsSync)(file)) {
-          const generated = generateType(localeData);
-          await (0, import_promises2.writeFile)(file, `${header}${generated}${footer}`);
-        } else {
-          const data = await (0, import_promises2.readFile)(file, "utf-8");
-          const lines = data.split("\n");
-          const index = lines.findIndex(
-            (line) => line.includes("CommandLocalizationTypeData")
-          );
-          if (index === -1) {
-            for (const locale of this.translations.values()) {
-              const generated2 = generateType(locale);
-              await (0, import_promises2.writeFile)(file, `${header}${generated2}${footer}`);
+        try {
+          let commandDefinitions = /* @__PURE__ */ new Map();
+          if ((0, import_node_fs.existsSync)(file)) {
+            try {
+              const data = await (0, import_promises2.readFile)(file, "utf-8");
+              const content = data.toString();
+              const regex = /"([^"]+)":\s*\{([^}]*)\}/gs;
+              let match;
+              while ((match = regex.exec(content)) !== null) {
+                const [fullMatch, commandName] = match;
+                if (commandName !== localeData.command.name) {
+                  commandDefinitions.set(commandName, fullMatch);
+                }
+              }
+            } catch (err) {
+              console.warn("Could not parse existing type file, creating new one");
             }
-            return;
           }
-          const start = index + 2;
-          const end = lines.findIndex((line) => line.includes("}"));
-          const generated = generateType(localeData);
-          lines.splice(start, end - start, generated);
-          await (0, import_promises2.writeFile)(file, lines.join("\n"));
+          const newCommandType = generateType(localeData);
+          commandDefinitions.set(localeData.command.name, newCommandType);
+          let fileContent = header;
+          const entries = Array.from(commandDefinitions.values());
+          fileContent += entries.join(",\n");
+          fileContent += "\n" + footer;
+          const dir = (0, import_node_path.join)(process.cwd(), "node_modules", "commandkit-types");
+          if (!(0, import_node_fs.existsSync)(dir)) {
+            await (0, import_promises2.mkdir)(dir, { recursive: true });
+          }
+          await (0, import_promises2.writeFile)(file, fileContent);
+        } catch (error) {
+          console.error("Failed to generate locale types:", error);
         }
       }
       async getTranslationStrict(scope, locale) {
@@ -2081,18 +2136,6 @@ declare module 'commandkit' {
   }
 });
 
-// src/utils/constants.ts
-var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    init_cjs_shims();
-    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
-    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
-    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
-  }
-});
-
 // src/utils/utilities.ts
 function findAppDirectory() {
   if (appDir) return appDir;
@@ -2146,160 +2189,471 @@ 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(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;
+    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(commandkit2) {
-        this.commandkit = commandkit2;
-        __privateAdd(this, _data, {
-          executionError: null,
-          type: null,
-          variables: /* @__PURE__ */ new Map(),
-          deferredFunctions: /* @__PURE__ */ new Map(),
-          marker: "",
-          markStart: 0,
-          markEnd: 0
-        });
+    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, []);
       }
-      /**
-       * Get the execution error.
-       * @internal
-       */
-      getExecutionError() {
-        return __privateGet(this, _data).executionError;
+      getArgs() {
+        void this.parse();
+        return __privateGet(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.");
+      get options() {
+        if (!__privateGet(this, _options)) {
+          __privateSet(this, _options, new MessageCommandOptions(this));
         }
-        __privateGet(this, _data).executionError = error;
+        return __privateGet(this, _options);
       }
-      /**
-       * Get the environment type.
-       */
-      getType() {
-        const type = __privateGet(this, _data).type;
-        if (!type) {
-          throw new Error("Environment type not set.");
-        }
-        return type;
+      getOption(name) {
+        var _a;
+        return (_a = this.parse().options.find((o) => o.name === name)) == null ? void 0 : _a.value;
       }
-      /**
-       * Set the environment type.
-       * @param type - The environment type to set.
-       * @internal
-       */
-      setType(type) {
-        __privateGet(this, _data).type = type;
+      getCommand() {
+        return this.parse().command;
       }
-      /**
-       * The variables store for this environment.
-       */
-      get variables() {
-        return __privateGet(this, _data).variables;
+      getSubcommand() {
+        return this.parse().subcommand;
       }
-      /**
-       * 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;
+      getSubcommandGroup() {
+        return this.parse().subcommandGroup;
       }
-      /**
+      getPrefix() {
+        for (const p of this.prefix) {
+          if (this.message.content.startsWith(p)) {
+            return p;
+          }
+        }
+      }
+      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
@@ -2360,15 +2714,76 @@ var init_environment = __esm({
         return Math.abs(__privateGet(this, _data).markEnd - __privateGet(this, _data).markStart);
       }
     };
-    _data = new WeakMap();
-    __name(_CommandKitEnvironment, "CommandKitEnvironment");
-    CommandKitEnvironment = _CommandKitEnvironment;
-    CommandKitEnvironmentType = /* @__PURE__ */ ((CommandKitEnvironmentType2) => {
-      CommandKitEnvironmentType2["CommandHandler"] = "COMMAND_HANDLER";
-      return CommandKitEnvironmentType2;
-    })(CommandKitEnvironmentType || {});
-    __name(afterCommand, "afterCommand");
-    __name(cancelAfterCommand, "cancelAfterCommand");
+    _data = new WeakMap();
+    __name(_CommandKitEnvironment, "CommandKitEnvironment");
+    CommandKitEnvironment = _CommandKitEnvironment;
+    CommandKitEnvironmentType = /* @__PURE__ */ ((CommandKitEnvironmentType2) => {
+      CommandKitEnvironmentType2["CommandHandler"] = "COMMAND_HANDLER";
+      return CommandKitEnvironmentType2;
+    })(CommandKitEnvironmentType || {});
+    __name(afterCommand, "afterCommand");
+    __name(cancelAfterCommand, "cancelAfterCommand");
+  }
+});
+
+// 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;
   }
 });
 
@@ -2750,13 +3165,17 @@ var init_Context = __esm({
       /**
        * Returns the i18n api for this command.
        * @param locale The locale to use for the i18n api.
+       * @template T The command name for type-safe translations. Will provide autocomplete from available translations.
        */
       locale(locale) {
         const selectedLocale = locale ?? this.getLocale();
-        return new Localization(this.commandkit, {
-          locale: selectedLocale,
-          target: this.getCommandIdentifier()
-        });
+        return new Localization(
+          this.commandkit,
+          {
+            locale: selectedLocale,
+            target: this.getCommandIdentifier()
+          }
+        );
       }
       /**
        * Creates a clone of this context
@@ -2817,496 +3236,248 @@ var init_Context = __esm({
     _MiddlewareContext = class _MiddlewareContext extends Context {
       constructor() {
         super(...arguments);
-        __privateAdd(this, _cancel, false);
-      }
-      /**
-       * Whether the command execution was cancelled.
-       */
-      get cancelled() {
-        return __privateGet(this, _cancel);
-      }
-      /**
-       * Cancels the command execution.
-       */
-      cancel() {
-        __privateSet(this, _cancel, true);
-      }
-      /**
-       * 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);
-      }
-    };
-    _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);
-      }
-      get options() {
-        if (!__privateGet(this, _options)) {
-          __privateSet(this, _options, new MessageCommandOptions(this));
-        }
-        return __privateGet(this, _options);
-      }
-      getOption(name) {
-        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;
-          }
-        }
-      }
-      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;
+        __privateAdd(this, _cancel, false);
       }
-      getSubcommand(required = false) {
-        const sub = this.parser.getSubcommand();
-        if (required && sub === void 0) {
-          throw new Error("Subcommand is required.");
-        }
-        return sub ?? null;
+      /**
+       * Whether the command execution was cancelled.
+       */
+      get cancelled() {
+        return __privateGet(this, _cancel);
       }
-      getSubcommandGroup(required = false) {
-        const sub = this.parser.getSubcommandGroup();
-        if (required && sub === void 0) {
-          throw new Error("Subcommand group is required.");
-        }
-        return sub ?? null;
+      /**
+       * Cancels the command execution.
+       */
+      cancel() {
+        __privateSet(this, _cancel, true);
+      }
+      /**
+       * 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(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) => {
-          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
-              });
+            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();
             }
+          } catch (e) {
+            Logger.error(e);
           }
-          if ((((_c = subcommandGroupOption.options) == null ? void 0 : _c.length) || 0) > 0) {
-            commandData.options.push(subcommandGroupOption);
+        }
+        try {
+          for (const middleware of prepared.middlewares) {
+            await middleware.data.afterExecute(ctx);
           }
+        } finally {
+          env.markEnd();
         }
       }
-      /**
-       * Registers loaded commands.
-       */
-      async register() {
-        if (!this.commandkit.client.isReady()) {
-          throw new Error("Cannot register commands before the client is ready");
+      getExecutionMode(source) {
+        if (source instanceof import_discord10.Message) return CommandExecutionMode.Message;
+        if (source.isChatInputCommand()) return CommandExecutionMode.SlashCommand;
+        if (source.isAutocomplete()) {
+          return CommandExecutionMode.Autocomplete;
         }
-        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);
+        if (source.isMessageContextMenuCommand()) {
+          return CommandExecutionMode.MessageContextMenu;
         }
-      }
-      /**
-       * 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);
+        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/utils/types-package.ts
+async function generateTypesPackage() {
+  const location = (0, import_node_path3.join)(process.cwd(), "node_modules", "commandkit-types");
+  if (!COMMANDKIT_IS_DEV) return location;
+  const packageJSON = (0, import_node_path3.join)(location, "package.json");
+  const index = (0, import_node_path3.join)(location, "index.js");
+  const types = (0, import_node_path3.join)(location, "index.d.ts");
+  const locale = (0, import_node_path3.join)(location, "locale_types.d.ts");
+  const command = (0, import_node_path3.join)(location, "command.d.ts");
+  const packageJSONContent = {
+    name: "commandkit-types",
+    version: "1.0.0",
+    description: "CommandKit types package",
+    type: "commonjs",
+    main: "index.js",
+    types: "index.d.ts"
+  };
+  const indexContent = `module.exports = {};`;
+  const typesContent = `// Main types index file - imports all type declarations
+import './locale_types';
+import './command';
+export {};
+`;
+  const localeTypesContent = `// Auto-generated localization types
+  export {};
+declare module 'commandkit' {
+   interface CommandLocalizationTypeData {
+    // This interface will be populated with localizations
+  }
+
+  type TranslatableCommandName = keyof CommandLocalizationTypeData
+}`;
+  const commandTypesContent = `// Auto-generated command types
+  export {};
+declare module 'commandkit' {
+   type CommandTypeData = string
+}`;
+  await (0, import_promises3.mkdir)(location, { recursive: true }).catch(() => {
+  });
+  await (0, import_promises3.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+  await (0, import_promises3.writeFile)(index, indexContent);
+  await (0, import_promises3.writeFile)(types, typesContent);
+  await (0, import_promises3.writeFile)(locale, localeTypesContent);
+  await (0, import_promises3.writeFile)(command, commandTypesContent);
+  return location;
+}
+async function rewriteCommandDeclaration(data) {
+  const commandTypesContent = `// Auto-generated command types
+  declare module 'commandkit' {
+    ${data}
+}
+    export {};
+`;
+  const location = (0, import_node_path3.join)(process.cwd(), "node_modules", "commandkit-types");
+  if (!(0, import_node_fs3.existsSync)(location)) return;
+  const type = (0, import_node_path3.join)(location, "command.d.ts");
+  await (0, import_promises3.writeFile)(type, commandTypesContent, { encoding: "utf-8" });
+}
+var import_promises3, import_node_path3, import_node_fs3;
+var init_types_package = __esm({
+  "src/utils/types-package.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises3 = require("fs/promises");
+    import_node_path3 = require("path");
+    init_constants();
+    import_node_fs3 = require("fs");
+    __name(generateTypesPackage, "generateTypesPackage");
+    __name(rewriteCommandDeclaration, "rewriteCommandDeclaration");
   }
 });
 
 // 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();
+    init_constants();
+    init_types_package();
     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"),
@@ -3320,33 +3491,21 @@ var init_AppCommandHandler = __esm({
     _AppCommandHandler = class _AppCommandHandler {
       constructor(commandkit2) {
         this.commandkit = commandkit2;
-        __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);
         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 +3518,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 +3530,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 +3547,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 +3586,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 +3596,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 +3613,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,12 +3636,12 @@ 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);
-            }
-          }
+        if (COMMANDKIT_IS_DEV) {
+          await rewriteCommandDeclaration(
+            `type CommandTypeData = ${Array.from(
+              this.loadedCommands.mapValues((v) => JSON.stringify(v.command.name)).values()
+            ).join(" | ")}`
+          );
         }
       }
       async loadMiddleware(id, middleware) {
@@ -3673,59 +3717,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 +3747,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 +3776,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 +3793,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,49 +3825,69 @@ 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_fs4, import_promises4, import_node_path4, 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_node_fs4 = require("fs");
+    import_promises4 = require("fs/promises");
+    import_node_path4 = 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);
+        return (0, import_node_fs4.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_promises4.readdir)(this.options.entrypoint, {
+          withFileTypes: true
+        });
+        for (const entry of entries) {
+          if (entry.name.startsWith("_")) continue;
+          const fullPath = (0, import_node_path4.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 {
@@ -3878,164 +3901,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_promises4.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_path4.join)(entry.parentPath, entry.name);
+        if (this.isCommand(name)) {
+          const command = {
+            id: crypto.randomUUID(),
+            name: (0, import_node_path4.basename)(path2, (0, import_node_path4.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_path4.basename)(path2, (0, import_node_path4.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_path4.normalize)(path2);
+        return normalized.replace(this.options.entrypoint, "");
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -4044,14 +3961,14 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_node_fs4, import_promises3, import_node_path4, _EventsRouter, EventsRouter;
+var import_node_fs5, import_promises5, import_node_path5, _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_node_path4 = require("path");
+    import_node_fs5 = require("fs");
+    import_promises5 = require("fs/promises");
+    import_node_path5 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
        * Creates a new EventsRouter instance
@@ -4085,7 +4002,7 @@ var init_EventsRouter = __esm({
        * Checks if the entrypoint path is valid
        */
       isValidPath() {
-        return (0, import_node_fs4.existsSync)(this.entrypoint);
+        return (0, import_node_fs5.existsSync)(this.entrypoint);
       }
       /**
        * Clear all parsed events
@@ -4106,12 +4023,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_promises5.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_path5.join)(this.entrypoint, dir.name);
+            await this.scanEvent(dir.name, path2, null, [], true);
           }
         }
         return Object.fromEntries(this.events);
@@ -4130,23 +4046,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_promises5.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_path5.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));
+            listeners.push((0, import_node_path5.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");
@@ -4316,54 +4233,6 @@ var init_AppEventsHandler = __esm({
   }
 });
 
-// src/utils/types-package.ts
-async function generateTypesPackage() {
-  const location = (0, import_node_path5.join)(process.cwd(), "node_modules", "commandkit-types");
-  const packageJSON = (0, import_node_path5.join)(location, "package.json");
-  const index = (0, import_node_path5.join)(location, "index.js");
-  const types = (0, import_node_path5.join)(location, "index.d.ts");
-  const locale = (0, import_node_path5.join)(location, "locale.d.ts");
-  const command = (0, import_node_path5.join)(location, "command.d.ts");
-  const exists = (0, import_node_fs5.existsSync)(packageJSON);
-  if (exists) return location;
-  const packageJSONContent = {
-    name: "commandkit-types",
-    version: "1.0.0",
-    description: "CommandKit types package",
-    type: "commonjs",
-    main: "index.js",
-    types: "index.d.ts"
-  };
-  const indexContent = `module.exports = {};`;
-  const typesContent = `import { CommandLocalizationTypeData } from './locale.d.ts';
-  import { CommandTypeData } from './command.d.ts';
-  
-  declare module 'commandkit' {
-    export interface CommandKitTypeReferences {
-      locale: CommandLocalizationTypeData;
-      command: CommandTypeData;
-    }
-  }`;
-  await (0, import_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, "");
-  return location;
-}
-var import_node_fs5, import_promises4, 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_node_path5 = require("path");
-    __name(generateTypesPackage, "generateTypesPackage");
-  }
-});
-
 // src/cli/common.ts
 function write(message) {
   process.stdout.write(message);
@@ -4481,10 +4350,10 @@ 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":
@@ -4869,7 +4738,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250314022547";
+    "0.1.11-dev.20250328083250";
   }
 });
 
@@ -4962,6 +4831,8 @@ async function buildApplication({
     esbuildPluginList.push(...esbuildPlugins.map(fromEsbuildPlugin));
   }
   try {
+    const dest = isDev ? ".commandkit" : config.distDir;
+    await (0, import_rimraf2.rimraf)(dest);
     await (0, import_tsup.build)({
       esbuildPlugins: esbuildPluginList,
       watch: false,
@@ -4985,7 +4856,7 @@ async function buildApplication({
       name: "CommandKit",
       sourcemap: true,
       target: "node16",
-      outDir: isDev ? ".commandkit" : config.distDir,
+      outDir: dest,
       entry: [
         "src",
         `!${config.distDir}`,
@@ -5028,9 +4899,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, import_rimraf2, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -5038,9 +4909,10 @@ 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();
+    import_rimraf2 = require("rimraf");
     __name(buildApplication, "buildApplication");
     envScript = /* @__PURE__ */ __name((dev) => `// --- Environment Variables Loader ---
 const $env = [${(dev ? devEnvFileArgs : prodEnvFileArgs).map((p) => `"${p}"`).join(", ")}];
@@ -5118,40 +4990,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);
@@ -5231,7 +5103,7 @@ async function createSpinner(text) {
   });
 }
 var ora;
-var init_utils2 = __esm({
+var init_utils = __esm({
   "src/cli/utils.ts"() {
     "use strict";
     init_cjs_shims();
@@ -5281,7 +5153,7 @@ var init_production = __esm({
     init_common();
     init_build();
     init_plugins();
-    init_utils2();
+    init_utils();
     __name(bootstrapProductionServer, "bootstrapProductionServer");
     __name(createProductionBuild, "createProductionBuild");
   }
@@ -5296,7 +5168,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.`);
   }
@@ -5316,7 +5188,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`
@@ -5325,10 +5197,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 = `
@@ -5336,7 +5208,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)}`
@@ -5354,7 +5226,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.`);
   }
@@ -5365,7 +5237,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)
   );
@@ -5377,12 +5249,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();
@@ -5392,7 +5264,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");
@@ -5411,7 +5283,10 @@ __export(index_exports, {
   CommandKit: () => CommandKit,
   CommandKitEnvironment: () => CommandKitEnvironment,
   CommandKitEnvironmentType: () => CommandKitEnvironmentType,
+  CommandKitPluginRuntime: () => CommandKitPluginRuntime,
   CommandsRouter: () => CommandsRouter,
+  CompilerPlugin: () => CompilerPlugin,
+  CompilerPluginRuntime: () => CompilerPluginRuntime,
   Context: () => Context,
   DefaultLocalizationStrategy: () => DefaultLocalizationStrategy,
   DefaultLogger: () => DefaultLogger,
@@ -5428,6 +5303,7 @@ __export(index_exports, {
   Modal: () => Modal,
   ModalKit: () => ModalKit,
   ParagraphInput: () => ParagraphInput,
+  RuntimePlugin: () => RuntimePlugin,
   ShortInput: () => ShortInput,
   TextInput: () => TextInput,
   afterCommand: () => afterCommand,
@@ -5444,6 +5320,7 @@ __export(index_exports, {
   dmOnly: () => dmOnly,
   exitContext: () => exitContext,
   exitMiddleware: () => exitMiddleware,
+  fromEsbuildPlugin: () => fromEsbuildPlugin,
   getCommandKit: () => getCommandKit,
   getConfig: () => getConfig,
   getContext: () => getContext,
@@ -5452,6 +5329,8 @@ __export(index_exports, {
   invalidate: () => invalidate,
   isCachedFunction: () => isCachedFunction,
   isCommandKitElement: () => isCommandKitElement,
+  isCompilerPlugin: () => isCompilerPlugin,
+  isRuntimePlugin: () => isRuntimePlugin,
   makeContextAwareFunction: () => makeContextAwareFunction,
   redirect: () => redirect,
   rethrow: () => rethrow,
@@ -5497,9 +5376,13 @@ init_cjs_shims();
 init_Logger();
 init_router();
 init_version();
+init_plugins();
 
 // src/cli/init.ts
 init_cjs_shims();
+var import_node_fs10 = require("fs");
+var import_promises8 = require("fs/promises");
+var import_node_path11 = require("path");
 async function bootstrapCommandkitCLI(argv, options) {
   process.title = "CommandKit CLI";
   const { Command } = await import("commander");
@@ -5547,6 +5430,11 @@ async function bootstrapCommandkitCLI(argv, options) {
     }
   });
   await program.parseAsync(argv, options);
+  const types = (0, import_node_path11.join)(process.cwd(), "node_modules", "commandkit-types");
+  if (!(0, import_node_fs10.existsSync)(types)) {
+    await (0, import_promises8.mkdir)(types, { recursive: true }).catch(() => {
+    });
+  }
 }
 __name(bootstrapCommandkitCLI, "bootstrapCommandkitCLI");
 
@@ -5563,7 +5451,10 @@ var index_default = CommandKit;
   CommandKit,
   CommandKitEnvironment,
   CommandKitEnvironmentType,
+  CommandKitPluginRuntime,
   CommandsRouter,
+  CompilerPlugin,
+  CompilerPluginRuntime,
   Context,
   DefaultLocalizationStrategy,
   DefaultLogger,
@@ -5580,6 +5471,7 @@ var index_default = CommandKit;
   Modal,
   ModalKit,
   ParagraphInput,
+  RuntimePlugin,
   ShortInput,
   TextInput,
   afterCommand,
@@ -5595,6 +5487,7 @@ var index_default = CommandKit;
   dmOnly,
   exitContext,
   exitMiddleware,
+  fromEsbuildPlugin,
   getCommandKit,
   getConfig,
   getContext,
@@ -5603,6 +5496,8 @@ var index_default = CommandKit;
   invalidate,
   isCachedFunction,
   isCommandKitElement,
+  isCompilerPlugin,
+  isRuntimePlugin,
   makeContextAwareFunction,
   redirect,
   rethrow,