seedcord 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import 'reflect-metadata';
-import { Logger, ShutdownPhase, CoordinatedShutdown, CoordinatedStartup, HealthCheck, StartupPhase } from '@seedcord/services';
+import { Logger, StrictEventEmitter, SeedcordError, SeedcordErrorCode, ShutdownPhase, CoordinatedShutdown, CoordinatedStartup, HealthCheck, StartupPhase, SeedcordTypeError } from '@seedcord/services';
 export * from '@seedcord/services';
 import chalk3 from 'chalk';
-import { SeparatorBuilder, SectionBuilder, MediaGalleryBuilder, FileBuilder, TextDisplayBuilder, ContainerBuilder, RoleSelectMenuBuilder, MentionableSelectMenuBuilder, ChannelSelectMenuBuilder, UserSelectMenuBuilder, StringSelectMenuOptionBuilder, StringSelectMenuBuilder, ButtonBuilder, FileUploadBuilder, TextInputBuilder, LabelBuilder, ModalBuilder, EmbedBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, ContextMenuCommandBuilder, SlashCommandBuilder, InteractionContextType, ActionRowBuilder, Collection, MessageFlags, Events, Client, WebhookClient, AttachmentBuilder, SeparatorSpacingSize, DiscordAPIError, SnowflakeUtil, Role, PermissionFlagsBits, ChatInputCommandInteraction, AutocompleteInteraction, Message, TextChannel, Guild, RESTJSONErrorCodes, Colors } from 'discord.js';
+import { SeparatorBuilder, SectionBuilder, MediaGalleryBuilder, FileBuilder, TextDisplayBuilder, ContainerBuilder, RoleSelectMenuBuilder, MentionableSelectMenuBuilder, ChannelSelectMenuBuilder, UserSelectMenuBuilder, StringSelectMenuOptionBuilder, StringSelectMenuBuilder, ButtonBuilder, FileUploadBuilder, TextInputBuilder, LabelBuilder, ModalBuilder, EmbedBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, ContextMenuCommandBuilder, SlashCommandBuilder, InteractionContextType, ActionRowBuilder, Collection, MessageFlags, Events, Client, WebhookClient, AttachmentBuilder, SeparatorSpacingSize, DiscordAPIError, SnowflakeUtil, Role, PermissionFlagsBits, ChatInputCommandInteraction, AutocompleteInteraction, Message, TextChannel, Guild, RESTJSONErrorCodes, Colors, ComponentType } from 'discord.js';
 import { Envapt } from 'envapt';
 import { hexToNumber, traverseDirectory, filterCirculars, prettify } from '@seedcord/utils';
 export * from '@seedcord/utils';
@@ -11,8 +11,6 @@ import { EventEmitter } from 'events';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/bot/decorators/Command.ts
 var CommandMetadataKey = Symbol("command:metadata");
 function RegisterCommand(scope, guilds = []) {
   return (ctor) => {
@@ -22,6 +20,20 @@ function RegisterCommand(scope, guilds = []) {
       scope,
       guilds
     };
+    const existingMeta = Reflect.getOwnMetadata(CommandMetadataKey, ctor);
+    if (existingMeta) {
+      throw new SeedcordError(SeedcordErrorCode.DecoratorCommandAlreadyRegistered, [
+        ctor.name,
+        existingMeta.scope,
+        scope
+      ]);
+    }
+    if (scope === "global" && guilds.length > 0) {
+      throw new SeedcordError(SeedcordErrorCode.DecoratorCommandGlobalWithGuilds);
+    }
+    if (scope === "guild" && (!Array.isArray(guilds) || guilds.length === 0)) {
+      throw new SeedcordError(SeedcordErrorCode.DecoratorCommandGuildWithoutGuilds);
+    }
     Reflect.defineMetadata(CommandMetadataKey, meta, ctor);
   };
 }
@@ -268,24 +280,20 @@ var CommandRegistry = class {
       await guild.commands.set(commands);
       const tag = commands.length === 1 ? "command" : "commands";
       this.logger.info(`${chalk3.bold.green("Configured")} ${chalk3.magenta.bold(commands.length)} ${tag} for guild ${chalk3.bold.yellow(guild.name)}`);
-      this.logger.info(` \u2192 ${commands.map((command) => chalk3.bold.cyan(command.name)).join(", ")}`);
+      this.logger.info(`\u2192 ${commands.map((command) => chalk3.bold.cyan(command.name)).join(", ")}`);
     }
   }
 };
 
 // src/bot/decorators/Events.ts
 var EventMetadataKey = Symbol("event:metadata");
-function RegisterEvent(events, options) {
+function RegisterEvent(...defs) {
   return function(constructor) {
     const saved = Reflect.getMetadata(EventMetadataKey, constructor);
     const existing = saved ?? [];
-    const toStore = Array.isArray(events) ? events : [
-      events
-    ];
-    const frequency = options?.frequency ?? "on";
-    const entries = toStore.map((event) => ({
+    const entries = defs.map(([event, options]) => ({
       event,
-      frequency
+      frequency: options?.frequency ?? "on"
     }));
     Reflect.defineMetadata(EventMetadataKey, [
       ...existing,
@@ -294,8 +302,6 @@ function RegisterEvent(events, options) {
   };
 }
 __name(RegisterEvent, "RegisterEvent");
-
-// src/bot/decorators/Middlewares.ts
 var MiddlewareType = /* @__PURE__ */ (function(MiddlewareType2) {
   MiddlewareType2["Interaction"] = "middleware:interaction";
   MiddlewareType2["Event"] = "middleware:event";
@@ -306,10 +312,10 @@ function Middleware(type, priority = 0, options = {}) {
   return (ctor) => {
     const normalizedPriority = Number(priority);
     if (!Number.isFinite(normalizedPriority)) {
-      throw new TypeError("Middleware priority must be a finite number");
+      throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInvalidMiddlewarePriority);
     }
-    if (type === "middleware:interaction" && options.events?.length) {
-      throw new Error("Interaction middleware cannot specify event filters");
+    if (type === "middleware:interaction" && Array.isArray(options.events) && options.events.length > 0) {
+      throw new SeedcordError(SeedcordErrorCode.DecoratorInteractionEventFilter);
     }
     const metadata = {
       priority: normalizedPriority,
@@ -322,8 +328,6 @@ function Middleware(type, priority = 0, options = {}) {
   };
 }
 __name(Middleware, "Middleware");
-
-// src/interfaces/Handler.ts
 var BaseHandler = class {
   static {
     __name(this, "BaseHandler");
@@ -334,10 +338,18 @@ var BaseHandler = class {
   errored = false;
   event;
   args = [];
+  logger;
   constructor(event, core, args) {
     this.core = core;
     this.event = event;
     this.args = args ?? [];
+    this.logger = new Logger(this.constructor.name);
+    this.populate();
+  }
+  /**
+   * Populates the handler with necessary data before execution. Override this method in your handler classes to customize population logic. This method is called at the end of the constructor before all async operations.
+   */
+  populate() {
   }
   hasChecks() {
     return this.checkable;
@@ -548,12 +560,16 @@ var EventController = class {
   }
   attachToClient() {
     for (const [eventName, handlerEntries] of this.eventMap) {
-      this.logger.debug(`Attaching ${chalk3.bold.green(eventName)} to ${chalk3.bold.yellow(this.core.bot.client.user?.username)}`);
+      this.logger.debug(`Attaching ${chalk3.bold.green(eventName)} to the client with ${chalk3.gray(handlerEntries.length)} handler(s)`);
       for (const entry of handlerEntries) {
         const register = entry.frequency === "once" ? this.core.bot.client.once.bind(this.core.bot.client) : this.core.bot.client.on.bind(this.core.bot.client);
         register(eventName, (...args) => {
+          this.core.bot.emit("any:event", eventName, ...args);
           void (async () => {
-            await this.processEvent(eventName, args, entry.ctor);
+            await this.processEvent(eventName, args, entry.ctor).catch((err) => {
+              this.logger.error(`[${chalk3.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+              this.core.bot.emit("error:unhandled:event", err);
+            });
           })();
         });
       }
@@ -690,7 +706,7 @@ function buildSlashRoute(arg1, arg2, arg3) {
     group = arg1.options.getSubcommandGroup(false) ?? void 0;
     sub = arg1.options.getSubcommand(false) ?? void 0;
   } else {
-    throw new TypeError("Invalid argument passed to buildSlashRoute");
+    throw new SeedcordTypeError(SeedcordErrorCode.UtilInvalidSlashRouteArgument);
   }
   if (sub && group) return `${command}/${group}/${sub}`;
   if (sub) return `${command}/${sub}`;
@@ -793,7 +809,7 @@ function Catchable(options) {
     const originalMethod = descriptor.value;
     descriptor.value = async function(...args) {
       const interaction = this.getEvent();
-      if (!originalMethod) throw new Error("Method not found");
+      if (!originalMethod) throw new SeedcordError(SeedcordErrorCode.DecoratorMethodNotFound);
       try {
         await originalMethod.apply(this, args);
       } catch (error) {
@@ -1010,8 +1026,10 @@ var InteractionController = class {
   }
   attachToClient() {
     this.core.bot.client.on(Events.InteractionCreate, (interaction) => {
+      this.core.bot.emit("any:interaction", interaction);
       this.handleInteraction(interaction).catch((err) => {
         this.logger.error(`[${chalk3.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+        this.core.bot.emit("error:unhandled:interaction", err);
       });
     });
   }
@@ -1032,7 +1050,11 @@ var InteractionController = class {
   }
   async processInteraction(interaction, extractKey, getHandler, args) {
     const key = extractKey(interaction);
-    if (this.keysToIgnore.has(key)) return;
+    if ([
+      ...this.keysToIgnore
+    ].some((pattern) => typeof pattern === "string" ? pattern === key : pattern.test(key))) {
+      return;
+    }
     for (const { ctor } of this.middlewares) {
       const middleware = new ctor(interaction, this.core, args);
       if (middleware.hasChecks()) await middleware.runChecks();
@@ -1129,16 +1151,16 @@ var InteractionController = class {
     await this.processInteraction(interaction, () => autocompleteKey, (key) => this.autocompleteMap.get(key));
   }
 };
-var Plugin = class {
+var Plugin = class extends StrictEventEmitter {
   static {
     __name(this, "Plugin");
   }
   pluggable;
   constructor(pluggable) {
-    this.pluggable = pluggable;
+    super(), this.pluggable = pluggable;
   }
 };
-var Pluggable = class _Pluggable {
+var Pluggable = class _Pluggable extends StrictEventEmitter {
   static {
     __name(this, "Pluggable");
   }
@@ -1147,6 +1169,7 @@ var Pluggable = class _Pluggable {
   startup;
   static PLUGIN_INIT_TIMEOUT_MS = 15e3;
   constructor(shutdown, startup) {
+    super();
     this.shutdown = shutdown;
     this.startup = startup;
   }
@@ -1171,15 +1194,21 @@ var Pluggable = class _Pluggable {
    * @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
    * @param args - Additional arguments to pass to the plugin constructor
    * @returns This instance with the plugin attached as a typed property
-   * @throws An {@link Error} When called after initialization or if key already exists
+   * @throws A {@link SeedcordError} When called after initialization or if key already exists
    * @example
    * ```typescript
    * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
    * ```
    */
   attach(key, Plugin2, startupPhase, ...args) {
-    if (this.isInitialized) throw new Error("Cannot attach a plugin after initialization.");
-    if (this[key]) throw new Error(`Plugin with key "${key}" already exists.`);
+    if (this.isInitialized) {
+      throw new SeedcordError(SeedcordErrorCode.CorePluginAfterInit);
+    }
+    if (this[key]) {
+      throw new SeedcordError(SeedcordErrorCode.CorePluginKeyExists, [
+        key
+      ]);
+    }
     const instance = new Plugin2(this, ...args);
     const entry = {
       [key]: instance
@@ -1192,6 +1221,8 @@ var Pluggable = class _Pluggable {
     return Object.assign(this, entry);
   }
 };
+var emojiStorage = {};
+var Emojis = emojiStorage;
 var EmojiInjector = class {
   static {
     __name(this, "EmojiInjector");
@@ -1202,6 +1233,7 @@ var EmojiInjector = class {
     this.core = core;
   }
   async init() {
+    this.clearEmojis();
     if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
       this.logger.info(`${chalk3.bold.green("Loaded")}: ${chalk3.magenta.bold("0")} emojis`);
       return;
@@ -1210,15 +1242,24 @@ var EmojiInjector = class {
     await this.core.bot.client.application?.emojis.fetch();
     let foundCount = 0;
     Object.entries(configEmojis).forEach(([key, emojiName]) => {
+      if (typeof emojiName !== "string") {
+        this.logger.warn(`${chalk3.bold.yellow("Invalid")}: ${chalk3.magenta.bold(String(key))} (expected string, received ${typeof emojiName})`);
+        return;
+      }
       const emoji = this.core.bot.client.application?.emojis.cache.find((e) => e.name === emojiName);
       if (emoji) {
-        configEmojis[key] = `<${emoji.identifier}>`;
+        emojiStorage[key] = `<${emoji.identifier}>`;
         foundCount++;
-        this.logger.debug(`${chalk3.bold.green("Found")}: ${chalk3.magenta.bold(emojiName)} (${emoji.id})`);
+        return;
       }
+      emojiStorage[key] = emojiName;
+      this.logger.warn(`${chalk3.bold.yellow("Missing")}: ${chalk3.magenta.bold(emojiName)} (using configured value)`);
     });
     this.logger.info(`${chalk3.bold.green("Loaded")}: ${chalk3.magenta.bold(foundCount)} emojis`);
   }
+  clearEmojis() {
+    for (const key of Object.keys(emojiStorage)) Reflect.deleteProperty(emojiStorage, key);
+  }
 };
 
 // src/bot/Bot.ts
@@ -1245,6 +1286,7 @@ var Bot = class extends Plugin {
   events;
   commands;
   emojiInjector;
+  emojis = Emojis;
   constructor(core) {
     super(core), this.core = core;
     this._client = new Client(core.config.bot.clientOptions);
@@ -1296,11 +1338,16 @@ var Bot = class extends Plugin {
   get client() {
     return this._client;
   }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
 };
 _ts_decorate4([
   Envapt("DISCORD_BOT_TOKEN", {
     converter(raw, _fallback) {
-      if (typeof raw !== "string") throw new Error("Missing DISCORD_BOT_TOKEN");
+      if (typeof raw !== "string") {
+        throw new SeedcordError(SeedcordErrorCode.ConfigMissingDiscordToken);
+      }
       return raw;
     }
   }),
@@ -1363,6 +1410,25 @@ function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata5, "_ts_metadata");
+function webhookUrlValidator(raw, _fallback) {
+  if (raw === null) {
+    throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookMissing);
+  }
+  if (typeof raw !== "string") {
+    throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
+  }
+  const value = raw.trim();
+  if (value === "") {
+    throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookMissing);
+  }
+  const pattern = String.raw`^https?:\/\/(?:canary\.|ptb\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w$-]+$`;
+  const discordWebhookRegex = new RegExp(pattern);
+  if (!URL.canParse(value) || !discordWebhookRegex.test(value)) {
+    throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
+  }
+  return value;
+}
+__name(webhookUrlValidator, "webhookUrlValidator");
 var UnknownException = class _UnknownException extends WebhookLog {
   static {
     __name(this, "UnknownException");
@@ -1402,11 +1468,7 @@ var UnknownException = class _UnknownException extends WebhookLog {
 };
 _ts_decorate5([
   Envapt("UNKNOWN_EXCEPTION_WEBHOOK_URL", {
-    converter(raw, _fallback) {
-      if (!raw) throw new Error("Missing UNKNOWN_EXCEPTION_WEBHOOK_URL");
-      if (!URL.canParse(String(raw))) throw new Error("Invalid UNKNOWN_EXCEPTION_WEBHOOK_URL");
-      return raw;
-    }
+    converter: /* @__PURE__ */ __name((raw, fallback) => webhookUrlValidator(raw), "converter")
   }),
   _ts_metadata5("design:type", String)
 ], UnknownException, "unknownExceptionWebhookUrl", void 0);
@@ -1595,7 +1657,7 @@ var Seedcord = class _Seedcord extends Pluggable {
    * Creates a new Seedcord instance
    *
    * @param config - Bot configuration including paths and Discord client options
-   * @throws An {@link Error} When attempting to create multiple instances (singleton)
+   * @throws An {@link SeedcordError} When attempting to create multiple instances (singleton)
    */
   constructor(config) {
     const shutdown = new CoordinatedShutdown();
@@ -1604,7 +1666,7 @@ var Seedcord = class _Seedcord extends Pluggable {
     this.shutdown = shutdown;
     this.startup = startup;
     if (_Seedcord.isInstantiated) {
-      throw new Error("Seedcord can only be instantiated once. Use the existing instance instead.");
+      throw new SeedcordError(SeedcordErrorCode.CoreSingletonViolation);
     }
     _Seedcord.isInstantiated = true;
     this.effects = new EffectsRegistry(this);
@@ -1656,7 +1718,7 @@ function EventCatchable(log) {
   return function(_target, _prop, descriptor) {
     const original = descriptor.value;
     descriptor.value = async function(...args) {
-      if (!original) throw new Error("Method not found");
+      if (!original) throw new SeedcordError(SeedcordErrorCode.DecoratorMethodNotFound);
       try {
         await original.apply(this, args);
       } catch (err) {
@@ -1680,6 +1742,206 @@ function EventCatchable(log) {
   };
 }
 __name(EventCatchable, "EventCatchable");
+var resolveFactory = /* @__PURE__ */ __name(async (input, ctx) => typeof input === "function" ? await input(ctx) : input, "resolveFactory");
+var isV2 = /* @__PURE__ */ __name((opts) => "container" in opts, "isV2");
+var usesResolver = /* @__PURE__ */ __name((opts) => "resolveDecision" in opts, "usesResolver");
+var usesCustomIds = /* @__PURE__ */ __name((opts) => "confirmCustomIds" in opts, "usesCustomIds");
+var isMessageComponentIx = /* @__PURE__ */ __name((ix) => "deferUpdate" in ix && "customId" in ix, "isMessageComponentIx");
+var buildPrompt = /* @__PURE__ */ __name(async (opts, ctx) => {
+  if (isV2(opts)) {
+    const container = await resolveFactory(opts.container, ctx);
+    return {
+      flags: "IsComponentsV2",
+      components: [
+        container.component
+      ]
+    };
+  }
+  const prompt = await resolveFactory(opts.prompt, ctx);
+  const rows = await resolveFactory(opts.rows, ctx);
+  const components = [
+    ...rows
+  ];
+  const payload = {
+    components
+  };
+  if (typeof prompt === "string") payload.content = prompt;
+  else payload.embeds = [
+    prompt.component
+  ];
+  return payload;
+}, "buildPrompt");
+var clearedPayload = /* @__PURE__ */ __name((opts) => isV2(opts) ? {
+  flags: "IsComponentsV2",
+  components: []
+} : {
+  components: []
+}, "clearedPayload");
+var decide = /* @__PURE__ */ __name(async (opts, i) => {
+  if (usesResolver(opts)) return opts.resolveDecision(i);
+  if (usesCustomIds(opts)) {
+    const { confirmCustomIds, cancelCustomIds = [] } = opts;
+    if (confirmCustomIds.includes(i.customId)) return true;
+    if (cancelCustomIds.includes(i.customId)) return false;
+  }
+  return false;
+}, "decide");
+var shouldDefer = /* @__PURE__ */ __name((ix, opts, isSlash, isContext) => {
+  if (ix.deferred) return false;
+  if (opts.defer === false) return false;
+  return isSlash || isContext;
+}, "shouldDefer");
+var maybeDefer = /* @__PURE__ */ __name(async (ix, opts, isSlash, isContext) => {
+  if (!shouldDefer(ix, opts, isSlash, isContext)) return;
+  if (isSlash || isContext) {
+    const { ephemeral = true } = opts;
+    const flags = ephemeral ? {
+      flags: "Ephemeral"
+    } : void 0;
+    if (flags) await ix.deferReply(flags);
+    else await ix.deferReply();
+  } else if (isMessageComponentIx(ix)) {
+    await ix.deferUpdate();
+  } else {
+    await ix.deferReply().catch(() => void 0);
+  }
+}, "maybeDefer");
+var sendPrompt = /* @__PURE__ */ __name(async (ix, payload, ephemeral, isSlash, isContext) => {
+  if (isSlash || isContext) {
+    if (ix.deferred) return ix.editReply(payload);
+    const reply = {
+      ...payload,
+      ...ephemeral ? {
+        flags: "Ephemeral"
+      } : {}
+    };
+    await ix.reply(reply);
+    return ix.fetchReply();
+  }
+  const follow = {
+    ...payload,
+    ...ephemeral ? {
+      flags: "Ephemeral"
+    } : {}
+  };
+  return ix.followUp(follow);
+}, "sendPrompt");
+var awaitComponent = /* @__PURE__ */ __name(async (msg, original, opts) => {
+  const componentType = opts.componentType ?? ComponentType.Button;
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  try {
+    const button = await msg.awaitMessageComponent({
+      componentType,
+      time: timeoutMs,
+      filter: /* @__PURE__ */ __name((c) => {
+        if (c.user.id !== original.user.id) return false;
+        if (usesCustomIds(opts)) {
+          const { confirmCustomIds, cancelCustomIds = [] } = opts;
+          return confirmCustomIds.includes(c.customId) || cancelCustomIds.includes(c.customId);
+        }
+        return true;
+      }, "filter")
+    });
+    return {
+      button,
+      timedOut: false
+    };
+  } catch {
+    return {
+      button: null,
+      timedOut: true
+    };
+  }
+}, "awaitComponent");
+var clearUi = /* @__PURE__ */ __name(async (ix, msg, opts, isSlash) => {
+  if (!isSlash) {
+    try {
+      await msg.edit(clearedPayload(opts));
+    } catch {
+      await ix.deleteReply(msg).catch(() => void 0);
+    }
+    return;
+  }
+  await ix.editReply(clearedPayload(opts)).catch(() => void 0);
+}, "clearUi");
+var normalizeClassicOutcome = /* @__PURE__ */ __name((payload) => ({
+  ...payload,
+  components: payload.components ?? []
+}), "normalizeClassicOutcome");
+var outcomeReplacement = /* @__PURE__ */ __name(async (opts, ctx, confirmed, timedOut) => {
+  const outcomes = opts.outcomeUi;
+  if (isV2(opts)) {
+    const v2Outcomes = outcomes;
+    if (timedOut) return await resolveFactory(v2Outcomes.onTimeout, ctx);
+    if (!confirmed) return await resolveFactory(v2Outcomes.onCancel, ctx);
+    if (v2Outcomes.onConfirm) return await resolveFactory(v2Outcomes.onConfirm, ctx);
+    return null;
+  }
+  const classicOutcomes = outcomes;
+  if (timedOut) return normalizeClassicOutcome(await resolveFactory(classicOutcomes.onTimeout, ctx));
+  if (!confirmed) return normalizeClassicOutcome(await resolveFactory(classicOutcomes.onCancel, ctx));
+  if (classicOutcomes.onConfirm) {
+    return normalizeClassicOutcome(await resolveFactory(classicOutcomes.onConfirm, ctx));
+  }
+  return null;
+}, "outcomeReplacement");
+function Confirmable(question, options) {
+  return function(_target, _propertyKey, descriptor) {
+    const original = descriptor.value;
+    descriptor.value = async function(...args) {
+      if (!original) throw new SeedcordError(SeedcordErrorCode.DecoratorMethodNotFound);
+      const ix = this.getEvent();
+      const isSlash = ix.isChatInputCommand();
+      const isContext = ix.isContextMenuCommand();
+      const { ephemeral = true } = options;
+      await maybeDefer(ix, options, isSlash, isContext);
+      const q = typeof question === "function" ? await question.apply(this) : question;
+      const ctx = {
+        handler: this,
+        interaction: ix,
+        question: q
+      };
+      const prompt = await buildPrompt(options, ctx);
+      const promptMsg = await sendPrompt(ix, prompt, ephemeral, isSlash, isContext);
+      const { button, timedOut } = await awaitComponent(promptMsg, ix, options);
+      let confirmed = false;
+      if (button) {
+        await button.deferUpdate().catch(() => void 0);
+        confirmed = await decide(options, button);
+      }
+      const replacement = await outcomeReplacement(options, ctx, confirmed, timedOut);
+      if (replacement) {
+        if (isSlash || isContext) {
+          await ix.editReply(replacement).catch(() => void 0);
+        } else {
+          await promptMsg.edit(replacement).catch(async () => {
+            await ix.deleteReply(promptMsg).catch(() => void 0);
+            await ix.followUp(replacement).catch(() => void 0);
+          });
+        }
+      } else {
+        await clearUi(ix, promptMsg, options, isSlash);
+      }
+      if (options.onResolved) {
+        await options.onResolved({
+          confirmed,
+          timedOut,
+          handler: this,
+          interaction: ix,
+          question: q,
+          ...button ? {
+            button
+          } : {}
+        });
+      }
+      if (confirmed) {
+        await original.apply(this, args);
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Confirmable, "Confirmable");
 
 // src/bot/errors/Channels.ts
 var ChannelNotFoundError = class extends CustomError {
@@ -2045,7 +2307,9 @@ function checkPermissions(client, roleOrChannel, scope = "all", inverse = false)
   if (roleOrChannel instanceof Role) {
     permissions = roleOrChannel.permissions;
   } else {
-    if (!client.user) throw new Error("Client user is not available");
+    if (!client.user) {
+      throw new SeedcordError(SeedcordErrorCode.CoreClientUserUnavailable);
+    }
     permissions = roleOrChannel.permissionsFor(client.user, true);
   }
   if (!permissions) {
@@ -2064,12 +2328,16 @@ function checkPermissions(client, roleOrChannel, scope = "all", inverse = false)
   }
 }
 __name(checkPermissions, "checkPermissions");
-
-// src/bot/utilities/roles/getBotRole.ts
 function getBotRole(client, guild) {
-  if (!client.user) throw new Error("Client user is not available");
+  if (!client.user) {
+    throw new SeedcordError(SeedcordErrorCode.CoreClientUserUnavailable);
+  }
   const botRole = guild.roles.botRoleFor(client.user);
-  if (!botRole) throw new Error("Bot role not found in guild");
+  if (!botRole) {
+    throw new SeedcordError(SeedcordErrorCode.CoreBotRoleMissing, [
+      guild.id
+    ]);
+  }
   return botRole;
 }
 __name(getBotRole, "getBotRole");
@@ -2181,6 +2449,6 @@ async function updateMemberRoles(rolesToAdd, rolesToRemove, member) {
 }
 __name(updateMemberRoles, "updateMemberRoles");
 
-export { AutocompleteHandler, AutocompleteRoute, BaseComponent, BaseErrorEmbed, BaseHandler, Bot, BuilderComponent, BuilderTypes, ButtonRoute, CannotAssignBotRole, CannotSendEmbedsError, Catchable, ChannelNotFoundError, ChannelNotTextChannel, Checkable, CommandMetadataKey, CommandRegistry, ContextMenuRoute, CouldNotFindChannel, CustomError, DatabaseError, EffectMetadataKey, EffectsEmitter, EffectsHandler, EffectsRegistry, EmojiInjector, EventCatchable, EventController, EventHandler, EventMetadataKey, EventMiddleware, GenericError, HasDangerousPermissions, InteractionController, InteractionHandler, InteractionMetadataKey, InteractionMiddleware, InteractionRoutes, Middleware, MiddlewareMetadataKey, MiddlewareType, MissingPermissions, ModalRoute, PERM_GROUPS, PermissionNames, Pluggable, Plugin, RegisterCommand, RegisterEffect, RegisterEvent, RoleDoesNotExist, RoleHigherThanMe, RowComponent, RowTypes, Seedcord, SelectMenuRoute, SelectMenuType, SlashRoute, UnhandledEvent, UnknownException, UserNotFound, UserNotInGuild, WebhookLog, attemptSendDM, buildSlashRoute, checkBotPermissions, checkPermissions, extractErrorResponse, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, hasPermsToAssign, sendInText, throwCustomError, updateMemberRoles };
+export { AutocompleteHandler, AutocompleteRoute, BaseComponent, BaseErrorEmbed, BaseHandler, Bot, BuilderComponent, BuilderTypes, ButtonRoute, CannotAssignBotRole, CannotSendEmbedsError, Catchable, ChannelNotFoundError, ChannelNotTextChannel, Checkable, CommandMetadataKey, CommandRegistry, Confirmable, ContextMenuRoute, CouldNotFindChannel, CustomError, DatabaseError, EffectMetadataKey, EffectsEmitter, EffectsHandler, EffectsRegistry, EmojiInjector, Emojis, EventCatchable, EventController, EventHandler, EventMetadataKey, EventMiddleware, GenericError, HasDangerousPermissions, InteractionController, InteractionHandler, InteractionMetadataKey, InteractionMiddleware, InteractionRoutes, Middleware, MiddlewareMetadataKey, MiddlewareType, MissingPermissions, ModalRoute, PERM_GROUPS, PermissionNames, Pluggable, Plugin, RegisterCommand, RegisterEffect, RegisterEvent, RoleDoesNotExist, RoleHigherThanMe, RowComponent, RowTypes, Seedcord, SelectMenuRoute, SelectMenuType, SlashRoute, UnhandledEvent, UnknownException, UserNotFound, UserNotInGuild, WebhookLog, attemptSendDM, buildSlashRoute, checkBotPermissions, checkPermissions, extractErrorResponse, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, hasPermsToAssign, sendInText, throwCustomError, updateMemberRoles };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map