commandkit 0.1.11-dev.20250402134128 → 0.1.11-dev.20250403165006

package/dist/index.js

@@ -1871,6 +1871,23 @@ var init_components = __esm({
   }
 });
 
+// src/utils/constants.ts
+var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST, HMREventType;
+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";
+    HMREventType = {
+      ReloadCommands: "reload-commands",
+      ReloadEvents: "reload-events",
+      Unknown: "unknown"
+    };
+  }
+});
+
 // src/plugins/PluginCommon.ts
 var _PluginCommon, PluginCommon;
 var init_PluginCommon = __esm({
@@ -2028,6 +2045,14 @@ var init_RuntimePlugin = __esm({
        */
       async performHMR(ctx, event) {
       }
+      /**
+       * Called before command is loaded for registration. This method can be used to modify the command data before it is loaded.
+       * @param ctx The context
+       * @param commands The command that is being loaded. This is a CommandBuilderLike object which represents Discord's command
+       */
+      async prepareCommand(ctx, commands) {
+        return null;
+      }
     };
     __name(_RuntimePlugin, "RuntimePlugin");
     RuntimePlugin = _RuntimePlugin;
@@ -2754,8 +2779,7 @@ var init_default = __esm({
         development: true,
         production: true
       },
-      typedCommands: true,
-      typedLocales: true
+      typedCommands: true
     };
   }
 });
@@ -2793,7 +2817,6 @@ function defineConfig(config = {}) {
     },
     static: config.static ?? defaultConfig.static,
     typedCommands: config.typedCommands ?? defaultConfig.typedCommands,
-    typedLocales: config.typedLocales ?? defaultConfig.typedLocales,
     typescript: {
       ...defaultConfig.typescript,
       ...config.typescript
@@ -2813,205 +2836,34 @@ var init_config = __esm({
   }
 });
 
-// src/utils/constants.ts
-var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST, HMREventType;
-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";
-    HMREventType = {
-      ReloadCommands: "reload-commands",
-      ReloadEvents: "reload-events",
-      ReloadLocales: "reload-locales",
-      Unknown: "unknown"
-    };
-  }
-});
-
-// src/app/i18n/DefaultLocalizationStrategy.ts
-var import_promises2, import_node_path, import_node_fs, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
-var init_DefaultLocalizationStrategy = __esm({
-  "src/app/i18n/DefaultLocalizationStrategy.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_promises2 = require("fs/promises");
-    import_node_path = require("path");
-    init_config();
-    import_node_fs = require("fs");
-    init_constants();
-    _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
-      constructor(commandkit2) {
-        this.commandkit = commandkit2;
-      }
-      translations = /* @__PURE__ */ new Map();
-      async locateTranslation(scope, locale) {
-        const localesPath = this.commandkit.getPath("locales");
-        if (!localesPath) return null;
-        const paths = [".js", ".json", ".mjs", ".cjs"].map(
-          (e) => (0, import_node_path.join)(localesPath, locale, scope) + e
-        );
-        for (const path3 of paths) {
-          if (!(0, import_node_fs.existsSync)(path3)) {
-            continue;
-          }
-          try {
-            let localeData;
-            try {
-              if (path3.endsWith(".json")) {
-                const data = await (0, import_promises2.readFile)(path3, "utf-8");
-                localeData = JSON.parse(data);
-              } else {
-                const { default: data } = await import(`file://${path3}`);
-                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)(
-          process.cwd(),
-          "node_modules",
-          "commandkit-types",
-          "locale_types.d.ts"
-        );
-        const header = `// auto generated file do not edit
-export {};
-declare module 'commandkit' {
-  export interface CommandLocalizationTypeData {
-`;
-        const footer = `  }
-type TranslatableCommandName = keyof CommandLocalizationTypeData
-}`;
-        const generateType = /* @__PURE__ */ __name((locale) => {
-          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");
-        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");
-            }
-          }
-          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) {
-        const key = `${scope}:${locale}`;
-        if (!this.translations.has(key)) {
-          const translation = await this.locateTranslation(scope, locale);
-          if (!translation) {
-            throw new Error(`Translation not found for ${key}`);
-          }
-          this.translations.set(key, translation);
-          return translation;
-        }
-        return this.translations.get(key);
-      }
-      async getTranslation(scope, locale) {
-        try {
-          return this.getTranslationStrict(scope, locale);
-        } catch (e) {
-          return null;
-        }
-      }
-      async translate(request) {
-        const { scope, key, args, locale } = request;
-        const translation = await this.getTranslation(scope, locale);
-        if (!translation) return `${scope}.${key}`;
-        const value = translation.translations[key];
-        const translated = this.applyTranslation(value, args);
-        return translated || `${scope}.${key}`;
-      }
-      applyTranslation(translation, args) {
-        if (!translation || !args) return translation;
-        return translation.replace(/{([^}]+)}/g, (_, key) => {
-          return String(args[key] ?? `{${key}}`);
-        });
-      }
-    };
-    __name(_DefaultLocalizationStrategy, "DefaultLocalizationStrategy");
-    DefaultLocalizationStrategy = _DefaultLocalizationStrategy;
-  }
-});
-
 // src/utils/utilities.ts
 function getCurrentDirectory() {
   if (currentDir) return currentDir;
-  let root = (0, import_node_path2.join)(
+  let root = (0, import_node_path.join)(
     process.cwd(),
     COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir
   );
-  if (!(0, import_node_fs2.existsSync)(root)) root = process.cwd();
+  if (!(0, import_node_fs.existsSync)(root)) root = process.cwd();
   currentDir = root;
   return root;
 }
 function getSourceDirectories() {
   const dist = getConfig().distDir;
   const locations = ["src", ".commandkit", dist].map(
-    (dir) => (0, import_node_path2.join)(process.cwd(), dir)
+    (dir) => (0, import_node_path.join)(process.cwd(), dir)
   );
   return locations;
 }
 function findAppDirectory() {
   if (appDir) return appDir;
-  let root = (0, import_node_path2.join)(
+  let root = (0, import_node_path.join)(
     process.cwd(),
     COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir
   );
-  if (!(0, import_node_fs2.existsSync)(root)) root = process.cwd();
-  const dirs = ["app"].map((dir) => (0, import_node_path2.join)(root, dir));
+  if (!(0, import_node_fs.existsSync)(root)) root = process.cwd();
+  const dirs = ["app"].map((dir) => (0, import_node_path.join)(root, dir));
   for (const dir of dirs) {
-    if ((0, import_node_fs2.existsSync)(dir)) {
+    if ((0, import_node_fs.existsSync)(dir)) {
       appDir = dir;
       return dir;
     }
@@ -3039,13 +2891,13 @@ function debounce(fn, ms2) {
     });
   };
 }
-var import_node_fs2, import_node_path2, appDir, currentDir;
+var import_node_fs, import_node_path, appDir, currentDir;
 var init_utilities = __esm({
   "src/utils/utilities.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs2 = require("fs");
-    import_node_path2 = require("path");
+    import_node_fs = require("fs");
+    import_node_path = require("path");
     init_constants();
     init_config();
     appDir = null;
@@ -3611,67 +3463,6 @@ var init_environment = __esm({
   }
 });
 
-// src/app/i18n/Localization.ts
-var _Localization, Localization;
-var init_Localization = __esm({
-  "src/app/i18n/Localization.ts"() {
-    "use strict";
-    init_cjs_shims();
-    _Localization = class _Localization {
-      /**
-       * Creates a new localization instance.
-       * @param commandkit The command kit instance.
-       * @param config The localization configuration.
-       */
-      constructor(commandkit2, config) {
-        this.commandkit = commandkit2;
-        this.config = config;
-        const strategy = this.commandkit.config.localizationStrategy;
-        const { locale, target } = this.config;
-        this.t = (translatable, args) => {
-          return strategy.translate({
-            args,
-            key: translatable,
-            locale,
-            scope: target
-          });
-        };
-      }
-      /**
-       * Translates the given translatable object.
-       * @param translatable The translatable object to translate.
-       */
-      t;
-      /**
-       * Get the localization strategy.
-       */
-      getStrategy() {
-        return this.commandkit.config.localizationStrategy;
-      }
-      /**
-       * Get the default locale
-       */
-      getDefaultLocale() {
-        return this.commandkit.config.defaultLocale;
-      }
-      /**
-       * Get the current locale
-       */
-      getLocale() {
-        return this.config.locale;
-      }
-      /**
-       * Get the localization target
-       */
-      getTarget() {
-        return this.config.target;
-      }
-    };
-    __name(_Localization, "Localization");
-    Localization = _Localization;
-  }
-});
-
 // src/app/middleware/signals.ts
 function exitMiddleware() {
   throw createCommandKitError(CommandKitErrorCodes.ExitMiddleware);
@@ -3693,10 +3484,59 @@ var init_signals = __esm({
   }
 });
 
-// src/cache/cache.ts
-function md5(data) {
-  return (0, import_node_crypto2.createHash)("md5").update(data).digest("hex");
+// src/cache/utils.ts
+function isSerializablePrimitive(value) {
+  return value === null || PRIMITIVE_TYPES.has(typeof value);
+}
+function createKey(val) {
+  return `commandkit:cache:object:${val}`;
 }
+function getObjectId(obj) {
+  const primitive = isSerializablePrimitive(obj);
+  if (primitive) return createKey(obj);
+  if (obj instanceof Date) return createKey(obj.getTime());
+  if (obj instanceof RegExp) return createKey(obj);
+  const ref = references.get(obj);
+  if (ref) return createKey(ref);
+  const id = tracker++;
+  references.set(obj, id);
+  return createKey(id);
+}
+async function createObjectHash(...args) {
+  const serializedKey = args.map(getObjectId).join(":");
+  try {
+    const hash = (0, import_node_crypto2.createHash)("sha256");
+    hash.update(serializedKey);
+    return hash.digest("hex");
+  } catch {
+    return serializedKey;
+  }
+}
+var import_node_crypto2, tracker, references, PRIMITIVE_TYPES;
+var init_utils = __esm({
+  "src/cache/utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto2 = require("crypto");
+    tracker = 0n;
+    references = /* @__PURE__ */ new WeakMap();
+    PRIMITIVE_TYPES = /* @__PURE__ */ new Set(
+      [
+        "string",
+        "number",
+        "boolean",
+        "bigint",
+        "undefined"
+      ]
+    );
+    __name(isSerializablePrimitive, "isSerializablePrimitive");
+    __name(createKey, "createKey");
+    __name(getObjectId, "getObjectId");
+    __name(createObjectHash, "createObjectHash");
+  }
+});
+
+// src/cache/use-cache.ts
 function getCacheProvider() {
   const commandkit2 = getCommandKit(true);
   const provider = commandkit2.getCacheProvider();
@@ -3712,10 +3552,10 @@ function useCache(fn, id, params) {
   if (id && !isLocal) {
     throw new Error("Illegal use of cache function.");
   }
-  const fnId = (0, import_node_crypto2.randomUUID)();
-  const memo = /* @__PURE__ */ __name((...args) => {
+  const fnId = (0, import_node_crypto3.randomUUID)();
+  const memo = /* @__PURE__ */ __name(async (...args) => {
     const forcedName = isLocal ? params == null ? void 0 : params.name : null;
-    const keyHash = forcedName ?? md5(!args.length ? fnId : `${fnId}:${args.join(":")}`);
+    const keyHash = forcedName ?? await createObjectHash(fnId, ...args);
     const resolvedTTL = isLocal && (params == null ? void 0 : params.ttl) != null ? typeof params.ttl === "string" ? (0, import_ms.default)(params.ttl) : params.ttl : null;
     return cacheContext.run(
       {
@@ -3805,21 +3645,21 @@ async function revalidate(tag, ...args) {
 function isCachedFunction(fn) {
   return Object.prototype.hasOwnProperty.call(fn, CACHED_FN_SYMBOL);
 }
-var import_node_async_hooks2, import_node_crypto2, import_ms, cacheContext, fnStore, DEFAULT_TTL, CACHE_FN_ID, CACHED_FN_SYMBOL, zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired;
-var init_cache = __esm({
-  "src/cache/cache.ts"() {
+var import_node_async_hooks2, import_node_crypto3, import_ms, cacheContext, fnStore, DEFAULT_TTL, CACHE_FN_ID, CACHED_FN_SYMBOL, zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired;
+var init_use_cache = __esm({
+  "src/cache/use-cache.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_async_hooks2 = require("async_hooks");
     init_async_context();
-    import_node_crypto2 = require("crypto");
+    import_node_crypto3 = require("crypto");
     import_ms = __toESM(require("ms"));
+    init_utils();
     cacheContext = new import_node_async_hooks2.AsyncLocalStorage();
     fnStore = /* @__PURE__ */ new Map();
     DEFAULT_TTL = (0, import_ms.default)("15m");
     CACHE_FN_ID = `__cache_fn_id_${Date.now()}__${Math.random()}__`;
     CACHED_FN_SYMBOL = Symbol("commandkit.cache.sentinel");
-    __name(md5, "md5");
     __name(getCacheProvider, "getCacheProvider");
     __name(useCache, "useCache");
     __name(cache, "cache");
@@ -3833,13 +3673,13 @@ var init_cache = __esm({
 });
 
 // src/cache/index.ts
-var init_cache2 = __esm({
+var init_cache = __esm({
   "src/cache/index.ts"() {
     "use strict";
     init_cjs_shims();
     init_CacheProvider();
     init_MemoryCache();
-    init_cache();
+    init_use_cache();
   }
 });
 
@@ -3849,11 +3689,10 @@ var init_Context = __esm({
   "src/app/commands/Context.ts"() {
     "use strict";
     init_cjs_shims();
-    init_Localization();
     init_environment();
     init_async_context();
     init_signals();
-    init_cache2();
+    init_cache();
     CommandExecutionMode = {
       SlashCommand: "chatInput",
       MessageContextMenu: "messageContextMenu",
@@ -4057,21 +3896,6 @@ var init_Context = __esm({
       setLocale(locale) {
         this._locale = locale;
       }
-      /**
-       * 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()
-          }
-        );
-      }
       /**
        * Creates a clone of this context
        */
@@ -4331,13 +4155,12 @@ var init_AppCommandRunner = __esm({
 
 // src/utils/types-package.ts
 async function generateTypesPackage() {
-  const location = (0, import_node_path3.join)(process.cwd(), "node_modules", "commandkit-types");
+  const location = (0, import_node_path2.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 packageJSON = (0, import_node_path2.join)(location, "package.json");
+  const index = (0, import_node_path2.join)(location, "index.js");
+  const types = (0, import_node_path2.join)(location, "index.d.ts");
+  const command = (0, import_node_path2.join)(location, "command.d.ts");
   const packageJSONContent = {
     name: "commandkit-types",
     version: "1.0.0",
@@ -4348,31 +4171,20 @@ async function generateTypesPackage() {
   };
   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_promises2.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);
+  await (0, import_promises2.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+  await (0, import_promises2.writeFile)(index, indexContent);
+  await (0, import_promises2.writeFile)(types, typesContent);
+  await (0, import_promises2.writeFile)(command, commandTypesContent);
   return location;
 }
 async function rewriteCommandDeclaration(data) {
@@ -4382,20 +4194,20 @@ async function rewriteCommandDeclaration(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" });
+  const location = (0, import_node_path2.join)(process.cwd(), "node_modules", "commandkit-types");
+  if (!(0, import_node_fs2.existsSync)(location)) return;
+  const type = (0, import_node_path2.join)(location, "command.d.ts");
+  await (0, import_promises2.writeFile)(type, commandTypesContent, { encoding: "utf-8" });
 }
-var import_promises3, import_node_path3, import_node_fs3;
+var import_promises2, import_node_path2, import_node_fs2;
 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");
+    import_promises2 = require("fs/promises");
+    import_node_path2 = require("path");
     init_constants();
-    import_node_fs3 = require("fs");
+    import_node_fs2 = require("fs");
     __name(generateTypesPackage, "generateTypesPackage");
     __name(rewriteCommandDeclaration, "rewriteCommandDeclaration");
   }
@@ -4714,15 +4526,19 @@ var init_AppCommandHandler = __esm({
               `Invalid export for command ${command.name}: at least one handler function must be provided`
             );
           }
-          const localizedCommand = await this.applyLocalizations({
-            ...data.command
+          let lastUpdated = data.command;
+          await this.commandkit.plugins.execute(async (ctx, plugin) => {
+            const res = await plugin.prepareCommand(ctx, lastUpdated);
+            if (res) {
+              lastUpdated = res;
+            }
           });
           this.loadedCommands.set(id, {
             command,
             guilds: data.guilds,
             data: {
               ...data,
-              command: localizedCommand
+              command: "toJSON" in lastUpdated ? lastUpdated.toJSON() : lastUpdated
             }
           });
           this.commandNameToId.set(command.name, id);
@@ -4730,113 +4546,6 @@ var init_AppCommandHandler = __esm({
           Logger.error(`Failed to load command ${command.name} (${id})`, error);
         }
       }
-      async applyLocalizations(command) {
-        var _a, _b, _c, _d, _e;
-        const localization = this.commandkit.config.localizationStrategy;
-        const validLocales = Object.values(import_discord16.Locale).filter(
-          (v) => typeof v === "string"
-        );
-        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_discord16.SlashCommandBuilder) {
-            if (translation.command.name) {
-              command.setNameLocalization(locale, translation.command.name);
-            }
-            if (translation.command.description) {
-              command.setDescriptionLocalization(
-                locale,
-                translation.command.description
-              );
-            }
-            const raw = command.toJSON();
-            if (((_a = raw.options) == null ? void 0 : _a.length) && ((_b = translation.command.options) == null ? void 0 : _b.length)) {
-              const opt = translation.command.options.slice();
-              let o;
-              while (o = opt.shift()) {
-                (_c = raw.options) == null ? void 0 : _c.forEach((option) => {
-                  var _a2;
-                  if (option.name === o.ref) {
-                    if (option.name) {
-                      option.name_localizations ??= {};
-                      option.name_localizations[locale] = o.name;
-                    }
-                    if (option.description) {
-                      option.description_localizations ??= {};
-                      option.description_localizations[locale] = o.description;
-                    }
-                    const opts = option.options;
-                    if ((opts == null ? void 0 : opts.length) && ((_a2 = o.options) == null ? void 0 : _a2.length)) {
-                      o.options.forEach((subOpt) => {
-                        const targetOption = opts == null ? void 0 : opts.find(
-                          (opt2) => opt2.name === subOpt.name
-                        );
-                        if (targetOption) {
-                          targetOption.name_localizations ??= {};
-                          targetOption.name_localizations[locale] = subOpt.name;
-                          if ("description" in targetOption) {
-                            targetOption.description_localizations ??= {};
-                            targetOption.description_localizations[locale] = subOpt.description;
-                          }
-                        }
-                      });
-                    }
-                  }
-                });
-              }
-            }
-          } else if (command instanceof import_discord16.ContextMenuCommandBuilder) {
-            if (translation.command.name) {
-              command.setNameLocalization(locale, translation.command.name);
-            }
-          } else {
-            command.name_localizations ??= {};
-            command.name_localizations[locale] = translation.command.name;
-            if (command.description) {
-              command.description_localizations ??= {};
-              command.description_localizations[locale] = translation.command.description;
-            }
-            if (((_d = command.options) == null ? void 0 : _d.length) && ((_e = translation.command.options) == null ? void 0 : _e.length)) {
-              const opt = translation.command.options.slice();
-              let o;
-              while (o = opt.shift()) {
-                command.options.forEach((option) => {
-                  var _a2;
-                  if (option.name === o.ref) {
-                    option.name_localizations ??= {};
-                    option.name_localizations[locale] = o.name;
-                    if ("description" in option) {
-                      option.description_localizations ??= {};
-                      option.description_localizations[locale] = o.description;
-                    }
-                    const opts = option.options;
-                    if ((opts == null ? void 0 : opts.length) && ((_a2 = o.options) == null ? void 0 : _a2.length)) {
-                      o.options.forEach((subOpt) => {
-                        const targetOption = opts == null ? void 0 : opts.find(
-                          (opt2) => opt2.name === subOpt.name
-                        );
-                        if (targetOption) {
-                          targetOption.name_localizations ??= {};
-                          targetOption.name_localizations[locale] = subOpt.name;
-                          if ("description" in targetOption) {
-                            targetOption.description_localizations ??= {};
-                            targetOption.description_localizations[locale] = subOpt.description;
-                          }
-                        }
-                      });
-                    }
-                  }
-                });
-              }
-            }
-          }
-        }
-        return command;
-      }
     };
     __name(_AppCommandHandler, "AppCommandHandler");
     AppCommandHandler = _AppCommandHandler;
@@ -4844,15 +4553,15 @@ var init_AppCommandHandler = __esm({
 });
 
 // src/app/router/CommandsRouter.ts
-var import_discord17, import_node_fs4, import_promises4, import_node_path4, MIDDLEWARE_PATTERN, GLOBAL_MIDDLEWARE_PATTERN, COMMAND_PATTERN, CATEGORY_PATTERN, _CommandsRouter, CommandsRouter;
+var import_discord17, import_node_fs3, import_promises3, import_node_path3, MIDDLEWARE_PATTERN, GLOBAL_MIDDLEWARE_PATTERN, COMMAND_PATTERN, CATEGORY_PATTERN, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_discord17 = require("discord.js");
-    import_node_fs4 = require("fs");
-    import_promises4 = require("fs/promises");
-    import_node_path4 = require("path");
+    import_node_fs3 = require("fs");
+    import_promises3 = require("fs/promises");
+    import_node_path3 = require("path");
     MIDDLEWARE_PATTERN = /^\+middleware\.(m|c)?(j|t)sx?$/;
     GLOBAL_MIDDLEWARE_PATTERN = /^\+global-middleware\.(m|c)?(j|t)sx?$/;
     COMMAND_PATTERN = /^([^+().][^().]*)\.(m|c)?(j|t)sx?$/;
@@ -4872,7 +4581,7 @@ var init_CommandsRouter = __esm({
         }
       }
       isValidPath() {
-        return (0, import_node_fs4.existsSync)(this.options.entrypoint);
+        return (0, import_node_fs3.existsSync)(this.options.entrypoint);
       }
       isCommand(name) {
         return COMMAND_PATTERN.test(name);
@@ -4888,12 +4597,12 @@ var init_CommandsRouter = __esm({
         this.middlewares.clear();
       }
       async scan() {
-        const entries = await (0, import_promises4.readdir)(this.options.entrypoint, {
+        const entries = await (0, import_promises3.readdir)(this.options.entrypoint, {
           withFileTypes: true
         });
         for (const entry of entries) {
           if (entry.name.startsWith("_")) continue;
-          const fullPath = (0, import_node_path4.join)(this.options.entrypoint, entry.name);
+          const fullPath = (0, import_node_path3.join)(this.options.entrypoint, entry.name);
           if (entry.isDirectory()) {
             const category = this.isCategory(entry.name) ? entry.name.slice(1, -1) : null;
             await this.traverse(fullPath, category);
@@ -4917,7 +4626,7 @@ var init_CommandsRouter = __esm({
         };
       }
       async traverse(path3, category) {
-        const entries = await (0, import_promises4.readdir)(path3, {
+        const entries = await (0, import_promises3.readdir)(path3, {
           withFileTypes: true
         });
         for (const entry of entries) {
@@ -4931,11 +4640,11 @@ var init_CommandsRouter = __esm({
       }
       async handle(entry, category = null) {
         const name = entry.name;
-        const path3 = (0, import_node_path4.join)(entry.parentPath, entry.name);
+        const path3 = (0, import_node_path3.join)(entry.parentPath, entry.name);
         if (this.isCommand(name)) {
           const command = {
             id: crypto.randomUUID(),
-            name: (0, import_node_path4.basename)(path3, (0, import_node_path4.extname)(path3)),
+            name: (0, import_node_path3.basename)(path3, (0, import_node_path3.extname)(path3)),
             path: path3,
             category,
             parentPath: entry.parentPath,
@@ -4946,7 +4655,7 @@ var init_CommandsRouter = __esm({
         } else if (this.isMiddleware(name)) {
           const middleware = {
             id: crypto.randomUUID(),
-            name: (0, import_node_path4.basename)(path3, (0, import_node_path4.extname)(path3)),
+            name: (0, import_node_path3.basename)(path3, (0, import_node_path3.extname)(path3)),
             path: path3,
             relativePath: this.replaceEntrypoint(path3),
             parentPath: entry.parentPath,
@@ -4967,7 +4676,7 @@ var init_CommandsRouter = __esm({
         });
       }
       replaceEntrypoint(path3) {
-        const normalized = (0, import_node_path4.normalize)(path3);
+        const normalized = (0, import_node_path3.normalize)(path3);
         return normalized.replace(this.options.entrypoint, "");
       }
     };
@@ -4977,15 +4686,15 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_discord18, import_node_fs5, import_promises5, import_node_path5, _EventsRouter, EventsRouter;
+var import_discord18, import_node_fs4, import_promises4, import_node_path4, _EventsRouter, EventsRouter;
 var init_EventsRouter = __esm({
   "src/app/router/EventsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_discord18 = require("discord.js");
-    import_node_fs5 = require("fs");
-    import_promises5 = require("fs/promises");
-    import_node_path5 = require("path");
+    import_node_fs4 = require("fs");
+    import_promises4 = require("fs/promises");
+    import_node_path4 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
        * Creates a new EventsRouter instance
@@ -5032,7 +4741,7 @@ var init_EventsRouter = __esm({
        * Checks if the entrypoint path is valid
        */
       isValidPath() {
-        return this.entrypoints.every((entrypoint) => (0, import_node_fs5.existsSync)(entrypoint));
+        return this.entrypoints.every((entrypoint) => (0, import_node_fs4.existsSync)(entrypoint));
       }
       /**
        * Clear all parsed events
@@ -5054,10 +4763,10 @@ var init_EventsRouter = __esm({
        */
       async scan() {
         for (const entrypoint of this.entrypoints) {
-          const dirs = await (0, import_promises5.readdir)(entrypoint, { withFileTypes: true });
+          const dirs = await (0, import_promises4.readdir)(entrypoint, { withFileTypes: true });
           for (const dir of dirs) {
             if (dir.isDirectory()) {
-              const path3 = (0, import_node_path5.join)(entrypoint, dir.name);
+              const path3 = (0, import_node_path4.join)(entrypoint, dir.name);
               await this.scanEvent(dir.name, path3, null, [], true);
             }
           }
@@ -5079,18 +4788,18 @@ var init_EventsRouter = __esm({
        * @returns Promise resolving to the parsed event metadata
        */
       async scanEvent(event, path3, _namespace = null, listeners = [], isRoot = false) {
-        const files = await (0, import_promises5.readdir)(path3, { withFileTypes: true });
+        const files = await (0, import_promises4.readdir)(path3, { withFileTypes: true });
         const isNamespace = isRoot && /^\(.+\)$/.test(event);
         const namespace = isNamespace ? event.slice(1, -1) : _namespace ?? null;
         for (const file of files) {
           if (file.name.includes("_")) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path5.join)(path3, file.name);
+            const nextPath = (0, import_node_path4.join)(path3, 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_path5.join)(file.parentPath, file.name));
+            listeners.push((0, import_node_path4.join)(file.parentPath, file.name));
           }
         }
         if (!isNamespace) {
@@ -5284,21 +4993,24 @@ async function ensureTypeScript(target) {
   const isTypeScript = /\.(c|m)?tsx?$/.test(target);
   if (!isTypeScript) return false;
   if (process.features.typescript) return true;
-  if (!ts) {
-    try {
-      ts = await import("typescript");
-    } catch {
-      panic("TypeScript must be installed to use TypeScript config files.");
-    }
-  }
+  await loadTypeScript();
   return true;
 }
+async function loadTypeScript(e) {
+  if (ts) return ts;
+  try {
+    ts = await import("typescript");
+  } catch {
+    panic(e || "TypeScript must be installed to use TypeScript config files.");
+  }
+  return ts;
+}
 async function loadConfigFileFromPath(target) {
   await ensureExists(target);
   const isTs = await ensureTypeScript(target);
   if (isTs && ts) {
     const { transpileModule } = ts;
-    const src = import_node_fs6.default.readFileSync(target, "utf8");
+    const src = import_node_fs5.default.readFileSync(target, "utf8");
     const { outputText } = transpileModule(src, {
       compilerOptions: {
         module: ts.ModuleKind.ESNext,
@@ -5308,8 +5020,8 @@ async function loadConfigFileFromPath(target) {
       fileName: target
     });
     const nodeModulesPath = await generateTypesPackage();
-    const tmpFile = (0, import_node_path6.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
-    import_node_fs6.default.writeFileSync(tmpFile, outputText);
+    const tmpFile = (0, import_node_path5.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
+    import_node_fs5.default.writeFileSync(tmpFile, outputText);
     target = tmpFile;
   }
   const config = await import(`file://${target}`).then(
@@ -5318,24 +5030,25 @@ async function loadConfigFileFromPath(target) {
   return config;
 }
 async function ensureExists(loc) {
-  const exists = import_node_fs6.default.existsSync(loc);
+  const exists = import_node_fs5.default.existsSync(loc);
   if (!exists) {
     throw new Error(`File not found: ${loc}`);
   }
 }
-var import_rimraf, import_node_path6, import_node_fs6, ts;
+var import_rimraf, import_node_path5, import_node_fs5, ts;
 var init_common2 = __esm({
   "src/cli/common.ts"() {
     "use strict";
     init_cjs_shims();
     import_rimraf = require("rimraf");
-    import_node_path6 = require("path");
-    import_node_fs6 = __toESM(require("fs"));
+    import_node_path5 = require("path");
+    import_node_fs5 = __toESM(require("fs"));
     init_colors();
     init_types_package();
     __name(write, "write");
     __name(panic, "panic");
     __name(ensureTypeScript, "ensureTypeScript");
+    __name(loadTypeScript, "loadTypeScript");
     __name(loadConfigFileFromPath, "loadConfigFileFromPath");
     __name(ensureExists, "ensureExists");
   }
@@ -5343,12 +5056,12 @@ var init_common2 = __esm({
 
 // src/config/loader.ts
 function getPossibleConfigPaths(root) {
-  return CONFIG_FILE_NAMES.map((name) => (0, import_node_path7.join)(root, name));
+  return CONFIG_FILE_NAMES.map((name) => (0, import_node_path6.join)(root, name));
 }
 function findConfigFile(cwd) {
   const locations = getPossibleConfigPaths(cwd);
   for (const location of locations) {
-    if ((0, import_node_fs7.existsSync)(location)) {
+    if ((0, import_node_fs6.existsSync)(location)) {
       return {
         path: location,
         isTypeScript: /\.ts$/.test(location)
@@ -5365,13 +5078,13 @@ async function loadConfigFile(entrypoint = process.cwd()) {
   loadedConfig = config;
   return config;
 }
-var import_node_fs7, import_node_path7, CONFIG_FILE_NAMES, loadedConfig;
+var import_node_fs6, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs7 = require("fs");
-    import_node_path7 = require("path");
+    import_node_fs6 = require("fs");
+    import_node_path6 = require("path");
     init_common2();
     init_config();
     CONFIG_FILE_NAMES = [
@@ -5421,7 +5134,6 @@ function registerDevHooks(commandkit2) {
           handled = true;
           break;
         case HMREventType.ReloadEvents:
-        case HMREventType.ReloadLocales:
           commandkit2.eventHandler.reloadEvents();
           handled = true;
           break;
@@ -5499,7 +5211,7 @@ var init_CommandKitEventsChannel = __esm({
 });
 
 // src/CommandKit.ts
-var import_node_events2, import_discord19, import_node_path8, import_node_fs8, commandkit, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
+var import_node_events2, import_discord19, import_node_path7, import_node_fs7, commandkit, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
@@ -5511,9 +5223,8 @@ var init_CommandKit = __esm({
     init_components();
     init_EventInterceptor();
     import_discord19 = require("discord.js");
-    init_DefaultLocalizationStrategy();
     init_utilities();
-    import_node_path8 = require("path");
+    import_node_path7 = require("path");
     init_AppCommandHandler();
     init_router();
     init_AppEventsHandler();
@@ -5521,7 +5232,7 @@ var init_CommandKit = __esm({
     init_loader();
     init_constants();
     init_dev_hooks();
-    import_node_fs8 = require("fs");
+    import_node_fs7 = require("fs");
     init_CommandKitEventsChannel();
     init_plugins();
     init_types_package();
@@ -5554,7 +5265,6 @@ var init_CommandKit = __esm({
         __publicField(this, "eventInterceptor");
         __publicField(this, "config", {
           defaultLocale: import_discord19.Locale.EnglishUS,
-          localizationStrategy: new DefaultLocalizationStrategy(this),
           getMessageCommandPrefix: /* @__PURE__ */ __name(() => "!", "getMessageCommandPrefix")
         });
         __publicField(this, "commandsRouter");
@@ -5664,14 +5374,6 @@ var init_CommandKit = __esm({
         this.options.cacheProvider = provider;
         return this;
       }
-      /**
-       * Sets the localization strategy for the command handler.
-       * @param strategy The localization strategy.
-       */
-      setLocalizationStrategy(strategy) {
-        this.config.localizationStrategy = strategy;
-        return this;
-      }
       /**
        * Resolves the current cache provider.
        */
@@ -5726,12 +5428,10 @@ var init_CommandKit = __esm({
         const appDir2 = this.getAppDirectory();
         if (!appDir2) return null;
         switch (to) {
-          case "locales":
-            return (0, import_node_path8.join)(appDir2, "locales");
           case "commands":
-            return (0, import_node_path8.join)(appDir2, "commands");
+            return (0, import_node_path7.join)(appDir2, "commands");
           case "events":
-            return (0, import_node_path8.join)(appDir2, "events");
+            return (0, import_node_path7.join)(appDir2, "events");
           default:
             return to;
         }
@@ -5763,7 +5463,7 @@ var init_CommandKit = __esm({
       if (this.commandsRouter.isValidPath()) {
         const result = await this.commandsRouter.scan();
         if (COMMANDKIT_IS_DEV) {
-          (0, import_node_fs8.writeFileSync)(
+          (0, import_node_fs7.writeFileSync)(
             "./.commandkit/commands.json",
             JSON.stringify(result, null, 2)
           );
@@ -5797,7 +5497,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250402134128";
+    "0.1.11-dev.20250403165006";
   }
 });
 
@@ -5839,7 +5539,7 @@ function getStdio(supportsCommands) {
 }
 function createAppProcess(fileName, cwd, isDev) {
   var _a, _b;
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path9.join)(cwd, fileName))) {
+  if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
     panic(`Could not locate the entrypoint file: ${fileName}`);
   }
   const stdio = getStdio(isDev);
@@ -5861,21 +5561,130 @@ function createAppProcess(fileName, cwd, isDev) {
   (_b = ps.stderr) == null ? void 0 : _b.pipe(process.stderr);
   return ps;
 }
-var import_node_child_process, import_node_path9, import_node_fs9;
+var import_node_child_process, import_node_path8, import_node_fs8;
 var init_app_process = __esm({
   "src/cli/app-process.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_child_process = require("child_process");
     init_env();
-    import_node_path9 = require("path");
-    import_node_fs9 = require("fs");
+    import_node_path8 = require("path");
+    import_node_fs8 = require("fs");
     init_common2();
     __name(getStdio, "getStdio");
     __name(createAppProcess, "createAppProcess");
   }
 });
 
+// src/cli/type-checker.ts
+function formatDiagnostic(ts2, diagnostic, cwd) {
+  const messageText = ts2.flattenDiagnosticMessageText(
+    diagnostic.messageText,
+    "\n"
+  );
+  if (!diagnostic.file) {
+    return `${colors_default.red("error")}: ${messageText}`;
+  }
+  const { line, character } = ts2.getLineAndCharacterOfPosition(
+    diagnostic.file,
+    diagnostic.start
+  );
+  const fileName = (0, import_node_path9.relative)(cwd, diagnostic.file.fileName);
+  const position = `${line + 1}:${character + 1}`;
+  const errorCode = diagnostic.code ? `TS${diagnostic.code}` : "";
+  return [
+    `${colors_default.bold(colors_default.cyan(fileName))}:${colors_default.bold(colors_default.yellow(position))} - ${colors_default.red("error")} ${colors_default.gray(errorCode)}`,
+    `${messageText}`
+  ].join("\n");
+}
+async function performTypeCheck(path3) {
+  const tsconfigPath = (0, import_node_path9.join)(path3, "tsconfig.json");
+  if (!(0, import_node_fs9.existsSync)(tsconfigPath)) return;
+  const ts2 = await loadTypeScript(TS_NOT_FOUND_ERR);
+  const formatHost = {
+    getCanonicalFileName: /* @__PURE__ */ __name((path4) => path4, "getCanonicalFileName"),
+    getCurrentDirectory: ts2.sys.getCurrentDirectory,
+    getNewLine: /* @__PURE__ */ __name(() => ts2.sys.newLine, "getNewLine")
+  };
+  const configFile = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
+  if (configFile.error) {
+    console.error(
+      colors_default.red(
+        `Error reading tsconfig.json: ${ts2.formatDiagnostic(configFile.error, formatHost)}`
+      )
+    );
+    process.exit(1);
+  }
+  const parsedConfig = ts2.parseJsonConfigFileContent(
+    configFile.config,
+    ts2.sys,
+    path3
+  );
+  parsedConfig.options.noEmit = true;
+  const program = ts2.createProgram({
+    rootNames: parsedConfig.fileNames,
+    options: parsedConfig.options,
+    projectReferences: parsedConfig.projectReferences
+  });
+  const diagnostics = [
+    ...program.getOptionsDiagnostics(),
+    ...program.getGlobalDiagnostics(),
+    ...program.getSyntacticDiagnostics(),
+    ...program.getSemanticDiagnostics()
+  ];
+  if (diagnostics.length > 0) {
+    console.log("");
+    console.error(
+      colors_default.bold(
+        colors_default.red("Type checking failed with the following errors:")
+      )
+    );
+    console.log("");
+    const byFile = /* @__PURE__ */ new Map();
+    for (const diagnostic of diagnostics) {
+      const fileName = diagnostic.file ? diagnostic.file.fileName : "Global";
+      if (!byFile.has(fileName)) {
+        byFile.set(fileName, []);
+      }
+      byFile.get(fileName).push(diagnostic);
+    }
+    const totalErrors = diagnostics.length;
+    let counter = 0;
+    for (const [_, fileDiags] of byFile) {
+      for (const diagnostic of fileDiags) {
+        counter++;
+        console.log(formatDiagnostic(ts2, diagnostic, path3));
+        if (counter < totalErrors) {
+          console.log("");
+        }
+      }
+    }
+    console.log("");
+    console.error(
+      colors_default.bold(
+        colors_default.red(`Found ${totalErrors} error${totalErrors > 1 ? "s" : ""}`)
+      )
+    );
+    console.log("");
+    process.exit(1);
+  }
+  console.log(colors_default.green("\u2713 Type checking completed successfully."));
+}
+var import_node_fs9, import_node_path9, TS_NOT_FOUND_ERR;
+var init_type_checker = __esm({
+  "src/cli/type-checker.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs9 = require("fs");
+    init_common2();
+    import_node_path9 = require("path");
+    init_colors();
+    TS_NOT_FOUND_ERR = `TypeScript must be installed in order to use the type checker. Please install it using \`npm install typescript\` or \`yarn add typescript\``;
+    __name(formatDiagnostic, "formatDiagnostic");
+    __name(performTypeCheck, "performTypeCheck");
+  }
+});
+
 // src/cli/build.ts
 async function buildApplication({
   plugins,
@@ -5883,7 +5692,11 @@ async function buildApplication({
   isDev,
   configPath
 }) {
+  var _a;
   const config = await loadConfigFile(configPath);
+  if (!isDev && !((_a = config == null ? void 0 : config.typescript) == null ? void 0 : _a.ignoreDuringBuilds)) {
+    await performTypeCheck(configPath || process.cwd());
+  }
   const pluginRuntime = new CompilerPluginRuntime(plugins || []);
   const esbuildPluginList = pluginRuntime.isEmpty() ? [] : [pluginRuntime.toEsbuildPlugin()];
   if (esbuildPlugins == null ? void 0 : esbuildPlugins.length) {
@@ -5960,9 +5773,9 @@ await bootstrap().catch((e) => {
 })
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
-  await (0, import_promises6.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
+  await (0, import_promises5.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
 }
-var import_tsup, import_promises6, import_node_path10, import_rimraf2, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
+var import_tsup, import_promises5, import_node_path10, import_rimraf2, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -5970,10 +5783,11 @@ var init_build = __esm({
     import_tsup = require("tsup");
     init_plugins();
     init_loader();
-    import_promises6 = require("fs/promises");
+    import_promises5 = require("fs/promises");
     import_node_path10 = require("path");
     init_env();
     import_rimraf2 = require("rimraf");
+    init_type_checker();
     __name(buildApplication, "buildApplication");
     envScript = /* @__PURE__ */ __name((dev) => `// --- Environment Variables Loader ---
 const $env = [${(dev ? devEnvFileArgs : prodEnvFileArgs).map((p) => `"${p}"`).join(", ")}];
@@ -6064,7 +5878,7 @@ async function bootstrapDevelopmentServer(configPath) {
       }, "onMessage");
       ps.once("message", onMessage);
       if (!_handled) {
-        (0, import_promises7.setTimeout)(3e3).then(() => {
+        (0, import_promises6.setTimeout)(3e3).then(() => {
           ps == null ? void 0 : ps.off("message", onMessage);
           resolve(false);
         });
@@ -6073,7 +5887,7 @@ async function bootstrapDevelopmentServer(configPath) {
   }, "waitForAcknowledgment");
   const sendHmrEvent = /* @__PURE__ */ __name(async (event, path3) => {
     if (!ps || !ps.send) return false;
-    const messageId = (0, import_node_crypto3.randomUUID)();
+    const messageId = (0, import_node_crypto4.randomUUID)();
     const messagePromise = waitForAcknowledgment(messageId);
     ps.send({ event, path: path3, id: messageId });
     try {
@@ -6081,7 +5895,7 @@ async function bootstrapDevelopmentServer(configPath) {
       const res = !!await Promise.race(
         [
           messagePromise,
-          (0, import_promises7.setTimeout)(3e3).then(() => {
+          (0, import_promises6.setTimeout)(3e3).then(() => {
             if (!triggered) {
               console.warn(
                 colors_default.yellow(
@@ -6112,9 +5926,6 @@ async function bootstrapDevelopmentServer(configPath) {
     } else if (isEventSource(path3)) {
       eventType = HMREventType.ReloadEvents;
       eventDescription = "event(s)";
-    } else if (isLocaleSource(path3)) {
-      eventType = HMREventType.ReloadLocales;
-      eventDescription = "locale(s)";
     } else {
       eventType = HMREventType.Unknown;
       eventDescription = "unknown source";
@@ -6170,9 +5981,6 @@ async function bootstrapDevelopmentServer(configPath) {
         console.log(`Received reload events command, reloading...`);
         await sendHmrEvent(HMREventType.ReloadEvents);
         break;
-      case "rl":
-        console.log(`Received reload locales command, reloading...`);
-        await sendHmrEvent(HMREventType.ReloadLocales);
         break;
     }
   });
@@ -6192,11 +6000,10 @@ ${colors_default.greenBright("Watching for changes in")} ${colors_default.yellow
 ${colors_default.greenBright("Commands:")}
 ${colors_default.yellowBright("r")} - Restart the server
 ${colors_default.yellowBright("rc")} - Reload all commands
-${colors_default.yellowBright("re")} - Reload all events
-${colors_default.yellowBright("rl")} - Reload all locales`
+${colors_default.yellowBright("re")} - Reload all events`
   );
 }
-var import_path2, import_chokidar, import_promises7, import_node_crypto3, isCommandSource, isEventSource, isLocaleSource;
+var import_path2, import_chokidar, import_promises6, import_node_crypto4, isCommandSource, isEventSource;
 var init_development = __esm({
   "src/cli/development.ts"() {
     "use strict";
@@ -6209,13 +6016,12 @@ var init_development = __esm({
     import_chokidar = require("chokidar");
     init_utilities();
     init_colors();
-    import_promises7 = require("timers/promises");
-    import_node_crypto3 = require("crypto");
+    import_promises6 = require("timers/promises");
+    import_node_crypto4 = require("crypto");
     init_constants();
     __name(buildAndStart, "buildAndStart");
     isCommandSource = /* @__PURE__ */ __name((p) => p.replaceAll("\\", "/").includes("src/app/commands"), "isCommandSource");
     isEventSource = /* @__PURE__ */ __name((p) => p.replaceAll("\\", "/").includes("src/app/events"), "isEventSource");
-    isLocaleSource = /* @__PURE__ */ __name((p) => p.replaceAll("\\", "/").includes("src/app/locales"), "isLocaleSource");
     __name(bootstrapDevelopmentServer, "bootstrapDevelopmentServer");
   }
 });
@@ -6231,7 +6037,7 @@ async function createSpinner(text) {
   });
 }
 var ora;
-var init_utils = __esm({
+var init_utils2 = __esm({
   "src/cli/utils.ts"() {
     "use strict";
     init_cjs_shims();
@@ -6259,7 +6065,9 @@ async function bootstrapProductionServer(configPath) {
 async function createProductionBuild(configPath) {
   const cwd = configPath || process.cwd();
   const config = await loadConfigFile(cwd);
-  const spinner = await createSpinner("Creating an optimized production build");
+  const spinner = await createSpinner(
+    "Creating an optimized production build\n"
+  );
   spinner.start();
   await buildApplication({
     configPath: cwd,
@@ -6281,7 +6089,7 @@ var init_production = __esm({
     init_common2();
     init_build();
     init_plugins();
-    init_utils();
+    init_utils2();
     __name(bootstrapProductionServer, "bootstrapProductionServer");
     __name(createProductionBuild, "createProductionBuild");
   }
@@ -6291,8 +6099,7 @@ var init_production = __esm({
 var generators_exports = {};
 __export(generators_exports, {
   generateCommand: () => generateCommand,
-  generateEvent: () => generateEvent,
-  generateLocale: () => generateLocale
+  generateEvent: () => generateEvent
 });
 function determineExtension() {
   return (0, import_fs2.existsSync)((0, import_path4.join)(BASE_PATH, "tsconfig.json")) ? "ts" : "js";
@@ -6340,7 +6147,7 @@ export const message = async (ctx) => {
 }
 async function generateCommand(name, customPath) {
   const cmdPath = (0, import_path4.join)(customPath || COMMANDS_DIR);
-  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises8.mkdir)(cmdPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises7.mkdir)(cmdPath, { recursive: true });
   const ext = determineExtension();
   const isTypeScript = ext === "ts";
   const fileName = `${name}.${ext}`;
@@ -6348,7 +6155,7 @@ async function generateCommand(name, customPath) {
     panic(`Command ${name} already exists.`);
   }
   const commandFile = isTypeScript ? TS_COMMAND_SOURCE(name) : JS_COMMAND_SOURCE(name);
-  await (0, import_promises8.writeFile)((0, import_path4.join)(cmdPath, fileName), commandFile);
+  await (0, import_promises7.writeFile)((0, import_path4.join)(cmdPath, fileName), commandFile);
   console.log(
     colors_default.green(
       `Command ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(`${cmdPath}/${fileName}`))}`
@@ -6357,11 +6164,11 @@ async function generateCommand(name, customPath) {
 }
 async function generateEvent(name, customPath) {
   const eventPath = (0, import_path4.join)(customPath || EVENTS_DIR, name);
-  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises8.mkdir)(eventPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises7.mkdir)(eventPath, { recursive: true });
   const ext = determineExtension();
   let filename = `event.${ext}`;
   if ((0, import_fs2.existsSync)((0, import_path4.join)(eventPath, filename))) {
-    const count = (await (0, import_promises8.readdir)(eventPath)).length;
+    const count = (await (0, import_promises7.readdir)(eventPath)).length;
     filename = `${String(count).padStart(2, "0")}_${filename}`;
   }
   const eventFile = `
@@ -6369,69 +6176,32 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
   console.log('${name} event fired!');
 };
 `.trim();
-  await (0, import_promises8.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)}`
     )
   );
 }
-async function generateLocale(locale, commandName, customPath) {
-  const localeNames = Object.fromEntries(
-    Object.entries(import_discord21.Locale).map(([k, v]) => [v, k])
-  );
-  if (!localeNames[locale]) {
-    panic(`Invalid locale: ${locale}`);
-  }
-  if (!commandName) {
-    panic("Command name is required.");
-  }
-  const localePath = (0, import_path4.join)(customPath || LOCALES_DIR, locale);
-  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises8.mkdir)(localePath, { recursive: true });
-  if ((0, import_fs2.existsSync)((0, import_path4.join)(localePath, `${commandName}.json`))) {
-    panic(`Locale file for ${commandName} already exists.`);
-  }
-  const localeFile = {
-    command: {
-      name: `${commandName}`,
-      description: `${commandName} command`
-    },
-    translations: {}
-  };
-  await (0, import_promises8.writeFile)(
-    (0, import_path4.join)(localePath, `${commandName}.json`),
-    JSON.stringify(localeFile, null, 2)
-  );
-  console.log(
-    colors_default.green(
-      `Locale file for ${colors_default.magenta(commandName)} created at ${colors_default.blue(
-        formatPath(localePath)
-      )}/${colors_default.magenta(`${commandName}.json`)}`
-    )
-  );
-}
-var import_promises8, import_path4, import_discord21, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
+var import_promises7, import_path4, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, formatPath;
 var init_generators = __esm({
   "src/cli/generators.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises8 = require("fs/promises");
+    import_promises7 = require("fs/promises");
     import_path4 = require("path");
-    import_discord21 = require("discord.js");
     init_common2();
     import_fs2 = require("fs");
     init_colors();
     BASE_PATH = process.cwd();
     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");
     __name(determineExtension, "determineExtension");
     __name(TS_COMMAND_SOURCE, "TS_COMMAND_SOURCE");
     __name(JS_COMMAND_SOURCE, "JS_COMMAND_SOURCE");
     __name(generateCommand, "generateCommand");
     __name(generateEvent, "generateEvent");
-    __name(generateLocale, "generateLocale");
   }
 });
 
@@ -6537,7 +6307,7 @@ async function showInformation() {
       Yarn: getBinaryVersion("yarn") || "N/A",
       pnpm: getBinaryVersion("pnpm") || "N/A",
       Bun: getBinaryVersion("bun") || "N/A",
-      Deno: getBinaryVersion("deno") || "N/A"
+      Deno: (getBinaryVersion("deno") || "N/A").replace(/\n|\r/g, " ")
     },
     "Relevant Packages": {
       commandkit: version,
@@ -6610,14 +6380,12 @@ __export(index_exports, {
   CompilerPlugin: () => CompilerPlugin,
   CompilerPluginRuntime: () => CompilerPluginRuntime,
   Context: () => Context,
-  DefaultLocalizationStrategy: () => DefaultLocalizationStrategy,
   DefaultLogger: () => DefaultLogger,
   ElementType: () => ElementType,
   EventInterceptor: () => EventInterceptor,
   EventsRouter: () => EventsRouter,
   Fragment: () => Fragment,
   HMREventType: () => HMREventType,
-  Localization: () => Localization,
   Logger: () => Logger,
   MemoryCache: () => MemoryCache,
   MentionableSelectMenu: () => MentionableSelectMenu,
@@ -6682,23 +6450,13 @@ init_components();
 init_config();
 init_async_context();
 init_environment();
-init_cache2();
+init_cache();
 
 // src/app/index.ts
 init_cjs_shims();
 init_AppCommandHandler();
 init_Context();
 init_MessageCommandParser();
-init_DefaultLocalizationStrategy();
-init_Localization();
-
-// src/app/i18n/LocalizationStrategy.ts
-init_cjs_shims();
-
-// src/app/i18n/Translation.ts
-init_cjs_shims();
-
-// src/app/index.ts
 init_signals();
 
 // src/app/commands/helpers.ts
@@ -6730,14 +6488,14 @@ init_constants();
 // src/cli/init.ts
 init_cjs_shims();
 var import_node_fs11 = require("fs");
-var import_promises9 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_node_path12 = require("path");
 async function bootstrapCommandkitCLI(argv, options) {
   process.title = "CommandKit CLI";
   const { Command } = await import("commander");
   const { bootstrapDevelopmentServer: bootstrapDevelopmentServer2 } = await Promise.resolve().then(() => (init_development(), development_exports));
   const { bootstrapProductionServer: bootstrapProductionServer2, createProductionBuild: createProductionBuild2 } = await Promise.resolve().then(() => (init_production(), production_exports));
-  const { generateCommand: generateCommand2, generateEvent: generateEvent2, generateLocale: generateLocale2 } = await Promise.resolve().then(() => (init_generators(), generators_exports));
+  const { generateCommand: generateCommand2, generateEvent: generateEvent2 } = await Promise.resolve().then(() => (init_generators(), generators_exports));
   const { version: version2 } = await Promise.resolve().then(() => (init_version(), version_exports));
   const { showInformation: showInformation2 } = await Promise.resolve().then(() => (init_information(), information_exports));
   const program = new Command("commandkit");
@@ -6756,38 +6514,27 @@ async function bootstrapCommandkitCLI(argv, options) {
   });
   program.command("start").description(
     "Start your bot in production mode after running the build command."
-  ).option("-c, --config [path]", "Path to your commandkit.json file.").action(() => {
+  ).option("-c, --config [path]", "Path to your commandkit config file.").action(() => {
     const options2 = program.opts();
     bootstrapProductionServer2(options2.config);
   });
-  program.command("build").description("Build your project for production usage.").option("-c, --config [path]", "Path to your commandkit.json file.").action(() => {
+  program.command("build").description("Build your project for production usage.").option("-c, --config [path]", "Path to your commandkit config file.").action(() => {
     const options2 = program.opts();
     return createProductionBuild2(options2.config);
   });
-  program.command("create").description("Create new commands, events, or locale files").option("-c, --command", "Create a new command").option("-e, --event", "Create a new event").option(
-    "-l, --locale <locale>",
-    "Specify the locale code (e.g. nl, es, fr)"
-  ).argument("<name>", "The name of the command or event").action(async (name, options2) => {
+  program.command("create").description("Create new commands or events files").option("-c, --command", "Create a new command").option("-e, --event", "Create a new event").argument("<name>", "The name of the command or event").action(async (name, options2) => {
     if (options2.command) {
       await generateCommand2(name);
     } else if (options2.event) {
       await generateEvent2(name);
-    } else if (options2.locale) {
-      if (!name) {
-        console.error("Please specify a command name for the locale file");
-        return;
-      }
-      await generateLocale2(options2.locale, name);
     } else {
-      console.error(
-        "Please specify what to create: --command, --event, or --locale"
-      );
+      console.error("Please specify what to create: --command or --event");
     }
   });
   await program.parseAsync(argv, options);
   const types = (0, import_node_path12.join)(process.cwd(), "node_modules", "commandkit-types");
   if (!(0, import_node_fs11.existsSync)(types)) {
-    await (0, import_promises9.mkdir)(types, { recursive: true }).catch(() => {
+    await (0, import_promises8.mkdir)(types, { recursive: true }).catch(() => {
     });
   }
 }
@@ -6816,14 +6563,12 @@ var index_default = CommandKit;
   CompilerPlugin,
   CompilerPluginRuntime,
   Context,
-  DefaultLocalizationStrategy,
   DefaultLogger,
   ElementType,
   EventInterceptor,
   EventsRouter,
   Fragment,
   HMREventType,
-  Localization,
   Logger,
   MemoryCache,
   MentionableSelectMenu,