@seedcord/gateway 0.0.1 → 0.1.0-next.1

package/dist/index.mjs

@@ -1,7 +1,3924 @@
-//#region src/index.ts
+import "reflect-metadata";
+import { BuilderComponent, CustomId, DispatchContext, Fault, Notice, RegisterCommand, RowComponent, Silence, defineGate, paginate } from "@seedcord/core";
+import { CommandMetadataKey, ComponentDefsKey, EventMetadataKey, GateNotice, GatedMetadataKey, InteractionMetadataKey, InteractionRouteKeys, InteractionRoutes, MiddlewareMetadataKey, NotInGuild, NoticeCard, PAGE_MAX, SubscribeMetadataKey, decodeFor, pageCursor, pickNotice, prefixOf, routeIdOf, runHandlerGates, setBotColor } from "@seedcord/core/internal";
+import { ApplicationCommandType, AttachmentBuilder, ButtonStyle, Client, Collection, ComponentType, DiscordAPIError, Events, Guild, GuildMember, Message, MessageFlags, PermissionFlagsBits, RESTJSONErrorCodes, Role, SeparatorSpacingSize, SnowflakeUtil, TextChannel, User, WebhookClient, chatInputApplicationCommandMention } from "discord.js";
+import { SeedcordErrorCode } from "@seedcord/errors";
+import { SeedcordError, SeedcordRangeError, SeedcordTypeError, validateDiscordToken } from "@seedcord/errors/internal";
+import { filterCirculars, formatFilePath, hasKeys, prettify, traverseDirectory } from "@seedcord/utils";
+import { CoordinatedShutdown, CoordinatedStartup, HealthCheck, Logger, ShutdownPhase, StartupPhase } from "@seedcord/services";
+import chalk from "chalk";
+import { ActionRowBuilder, ButtonBuilder, ContextMenuCommandBuilder, SlashCommandBuilder, TextDisplayBuilder } from "@discordjs/builders";
+import { buildSlashRoute, routeLeavesOf } from "@seedcord/utils/internal";
+import { TypedEventEmitter } from "@seedcord/event-emitter";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { MemoryRateLimiter } from "@seedcord/rate-limiter";
+import { SeedcordBrand, wrapHot } from "@seedcord/types/internal";
+import { Envapt, Envapter } from "envapt";
+import * as crypto from "node:crypto";
+
+export * from "@seedcord/core"
+
+export * from "@seedcord/errors"
+
+export * from "@seedcord/utils"
+
+export * from "@seedcord/services"
+
+export * from "@seedcord/event-emitter"
+
+export * from "@seedcord/rate-limiter"
+
+//#region src/bot/decorators/Events.ts
+/**
+* Registers an event handler class with one or more Discord.js events.
+*
+* Associates the decorated class with the provided Discord client events for automatic registration and execution when those events are emitted.
+*
+* Supply any number of event tuples. Each tuple can include per event options.
+*
+* @typeParam EventKey - Union of Discord.js ClientEvents keys to register for
+* @param defs - One or more tuples of [event, options]
+* @decorator
+* @example
+* ```ts
+* \@RegisterEvent([Events.MessageCreate])
+* class MessageHandler extends EventHandler<Events.MessageCreate> {
+*   async execute() {
+*     // Handle message creation
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+* class MessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+*   async execute() {
+*     // Handle message creation or update
+*   }
+* }
+* ```
+*
+* @example
+* ```ts
+* \@RegisterEvent([Events.MessageCreate, { frequency: 'once' }], [Events.MessageUpdate])
+* class OneTimeMessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+*   async execute() {
+*     // Handle only the first message creation, and message update normally
+*   }
+* }
+* ```
+*/
+function RegisterEvent(...defs) {
+	return function(constructor) {
+		const existing = Reflect.getMetadata(EventMetadataKey, constructor) ?? [];
+		const entries = defs.map(([event, options]) => ({
+			event,
+			frequency: options?.frequency ?? "on"
+		}));
+		Reflect.defineMetadata(EventMetadataKey, [...existing, ...entries], constructor);
+	};
+}
+
+//#endregion
+//#region src/bot/decorators/Gated.ts
+/**
+* Attaches gates to a handler. The gates run before `execute`, and a gate refusing stops the handler with
+* the reply or drop the gate threw. Multiple gates are ANDed, so each must pass. A gate that requires a
+* context the handler does not provide (a button gate on a slash handler, an interaction gate on an event
+* handler) is a compile error at this line, and the error names the gate and the handler kind. Place it
+* above the route decorator.
+*
+* Combine gates with {@link and} or {@link or} to build a single gate from multiple arms.
+*
+* @example
+* ```ts
+* import { PermissionFlagsBits } from 'discord.js';
+*
+* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.Administrator]))
+* \@SlashRoute('maintenance')
+* class Maintenance extends SlashHandler<'maintenance'> {
+*     async execute() {
+*         // both gates passed, so this runs in a guild with an admin caller
+*     }
+* }
+* ```
+*
+* @typeParam Gates - The non-empty tuple of gates to run, in order, against the handler's context.
+* @typeParam TCtor - The decorated handler's constructor, checked against every gate's required context.
+* @param gates - One or more gates to attach, each ANDed so the handler runs only when all pass.
+* @param ctor - The handler class being decorated, rejected at compile time when a gate needs a context it lacks.
+*
+* @see {@link defineGate}
+* @see {@link defineEffectGate}
+* @decorator
+*/
+function Gated(...gates) {
+	return function(ctor) {
+		const existing = Reflect.getMetadata(GatedMetadataKey, ctor) ?? [];
+		Reflect.defineMetadata(GatedMetadataKey, [...existing, ...gates], ctor);
+	};
+}
+
+//#endregion
+//#region src/miscellaneous/areRoutes.ts
+/**
+* Checks if the provided value is an array of strings.
+*
+* @internal
+*/
+function areRoutes(routes) {
+	return Array.isArray(routes) && routes.every((r) => typeof r === "string");
+}
+
+//#endregion
+//#region src/bot/decorators/Interactions.ts
+/**
+* Types of select menus supported for routing
+*/
+let SelectMenuKind = /* @__PURE__ */ function(SelectMenuKind) {
+	SelectMenuKind["String"] = "string";
+	SelectMenuKind["User"] = "user";
+	SelectMenuKind["Role"] = "role";
+	SelectMenuKind["Channel"] = "channel";
+	SelectMenuKind["Mentionable"] = "mentionable";
+	return SelectMenuKind;
+}({});
+/**
+* Routes one or more slash commands to a {@link SlashHandler}.
+*
+* Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
+* commands branch with `this.match`. The decorator routes and the generic must match exactly, so listing
+* fewer or more than the handler declares is a compile error. Subcommands use a slash path.
+*
+* @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
+* @decorator
+* @example
+* ```ts
+* \@SlashRoute('ban')
+* class BanHandler extends SlashHandler<'ban'> {
+*     async execute() {
+*         const target = this.options.getUser('target');
+*     }
+* }
+* ```
+*
+* @example
+* ```ts
+* \@SlashRoute('ban', 'kick')
+* class ModerationHandler extends SlashHandler<'ban' | 'kick'> {
+*     async execute() {
+*         await this.match({ ban: (o) => o.getUser('target'), kick: (o) => o.getUser('member') });
+*     }
+* }
+* ```
+*/
+function SlashRoute(...routes) {
+	return function(constructor) {
+		storeMetadata(InteractionRoutes.Slash, routes, constructor);
+	};
+}
+/**
+* Routes button interactions to handler classes.
+*
+* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
+* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
+* matches the stable prefix, so a wire minted from an older shape still reaches the handler, where
+* reading this.params throws StaleCustomId and the controller boundary turns it into a reply.
+*
+* @param defs - The customId definition(s) this handler decodes, one per route.
+* @decorator
+*/
+function ButtonRoute(...defs) {
+	return function(constructor) {
+		storeComponentRoute(InteractionRoutes.Button, defs, constructor);
+	};
+}
+/**
+* Routes modal submissions to handler classes.
+*
+* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
+* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
+* matches the stable prefix, so an older-shape wire still reaches the handler and throws StaleCustomId
+* on read, the same as a button route.
+*
+* @param defs - The customId definition(s) this handler decodes, one per route.
+* @decorator
+*/
+function ModalRoute(...defs) {
+	return function(constructor) {
+		storeComponentRoute(InteractionRoutes.Modal, defs, constructor);
+	};
+}
+/**
+* Routes one or more context-menu commands to a {@link ContextMenuHandler}.
+*
+* Pass the kind (`ApplicationCommandType.User` or `ApplicationCommandType.Message`) and the command name(s),
+* each checked against that kind's registry, so a typo is a compile error. The same kind must sit on the
+* handler's generic, cross-checked both directions. Context menus carry no options, so a multi-name handler
+* reads `this.target` uniformly with no branch.
+*
+* @param kind - The context-menu kind, `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+* @param names - The command name(s) this handler serves, keyed off the matching registry.
+* @decorator
+* @example
+* ```ts
+* \@ContextMenuRoute(ApplicationCommandType.User, 'View Profile')
+* class ViewProfile extends ContextMenuHandler<ApplicationCommandType.User> {
+*     async execute() {
+*         const user = this.target;
+*     }
+* }
+* ```
+*/
+function ContextMenuRoute(kind, ...names) {
+	return function(constructor) {
+		storeMetadata(kind === ApplicationCommandType.User ? InteractionRoutes.UserContextMenu : InteractionRoutes.MessageContextMenu, names, constructor);
+	};
+}
+/**
+* Routes one or more commands' autocomplete to an {@link AutocompleteHandler}.
+*
+* Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
+* over its autocompletable fields, several commands share one handler whose arms span every command's
+* fields. The decorator routes and the generic must match exactly, so listing fewer or more than the
+* handler declares is a compile error.
+*
+* @param routes - The command route string(s) this handler serves, e.g. `'search'` or `'search', 'find'`.
+* @decorator
+* @example
+* ```ts
+* \@AutocompleteRoute('search')
+* class SearchAutocomplete extends AutocompleteHandler<'search'> {
+*     async execute() {
+*         await this.match({ query: (value, respond) => respond([{ name: value, value }]) });
+*     }
+* }
+* ```
+*/
+function AutocompleteRoute(...routes) {
+	return function(constructor) {
+		storeMetadata(InteractionRoutes.Autocomplete, routes, constructor);
+	};
+}
+/**
+* Routes select menu interactions to handler classes.
+*
+* Pass the select kind and the {@link CustomId} definition(s) this handler decodes. The handler's
+* generic must list the same definitions, and its second generic argument must be the matching select
+* interaction type, or it is a compile error.
+*
+* @param type - Select menu kind from {@link SelectMenuKind}.
+* @param defs - The customId definition(s) this handler decodes, one per route.
+* @decorator
+*
+* @example
+* ```typescript
+* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
+* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+*   // handles user select menus minted from AssignId
+* }
+* ```
+*/
+function SelectMenuRoute(type, ...defs) {
+	return function(constructor) {
+		storeComponentRoute({
+			["string"]: InteractionRoutes.StringMenu,
+			["user"]: InteractionRoutes.UserMenu,
+			["role"]: InteractionRoutes.RoleMenu,
+			["channel"]: InteractionRoutes.ChannelMenu,
+			["mentionable"]: InteractionRoutes.MentionableMenu
+		}[type], defs, constructor);
+	};
+}
+function storeComponentRoute(route, defs, constructor) {
+	storeMetadata(route, defs.map((def) => def.prefix), constructor);
+	Reflect.defineMetadata(ComponentDefsKey, defs, constructor);
+}
+function storeMetadata(route, routes, constructor) {
+	const key = InteractionRouteKeys[route];
+	const savedRoutes = Reflect.getMetadata(key, constructor);
+	const existing = areRoutes(savedRoutes) ? savedRoutes : [];
+	const toStore = Array.isArray(routes) ? routes : [routes];
+	Reflect.defineMetadata(key, [...existing, ...toStore], constructor);
+	Reflect.defineMetadata(InteractionMetadataKey, true, constructor);
+}
+
+//#endregion
+//#region src/bot/decorators/Middlewares.ts
+/**
+* Middleware types supported by Seedcord
+*/
+let MiddlewareType = /* @__PURE__ */ function(MiddlewareType) {
+	MiddlewareType["Interaction"] = "interaction";
+	MiddlewareType["Event"] = "event";
+	return MiddlewareType;
+}({});
+/**
+* Decorator used to register middleware with priority ordering. The lower the priority number, the earlier it runs.
+*
+* Interaction middleware cannot specify event filters.
+*
+* @param type - Middleware kind from {@link MiddlewareType}
+* @param priority - Ordering value where lower runs earlier. {@default `0`}
+* @param options - Additional registration options
+*
+* @decorator
+*
+* @example
+* ```ts
+* \@Middleware(MiddlewareType.Event, 10, { events: [Events.MessageCreate, Events.MessageUpdate] })
+* class MyEventMiddleware extends EventMiddleware {}
+* ```
+* @throws A **SeedcordTypeError** If priority is not a finite number
+* @throws A **SeedcordError** If interaction middleware specifies event filters
+*/
+function Middleware(type, priority = 0, options = {}) {
+	return (ctor) => {
+		const normalizedPriority = Number(priority);
+		if (!Number.isFinite(normalizedPriority)) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInvalidMiddlewarePriority);
+		if (type === "interaction" && Array.isArray(options.events) && options.events.length > 0) throw new SeedcordError(SeedcordErrorCode.DecoratorInteractionEventFilter);
+		const metadata = {
+			priority: normalizedPriority,
+			type,
+			...options.events && options.events.length > 0 && { events: options.events }
+		};
+		Reflect.defineMetadata(MiddlewareMetadataKey, metadata, ctor);
+	};
+}
+
+//#endregion
+//#region src/bot/gates/catalog/IgnoreBots.ts
+/**
+* Drops a client event whose actor is a bot, with a {@link Silence} so nothing is replied. Event-only, because a
+* Silence on an interaction would leave Discord's failed-interaction state. It rejects an interaction handler at
+* the decorator line. Takes no options, so attach it directly without calling it.
+*
+* @see {@link Gated}
+*
+* @example
+* ```ts
+* import { Events } from 'discord.js';
+*
+* \@Gated(IgnoreBots)
+* class OnMessage extends EventHandler<Events.MessageCreate> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+const IgnoreBots = defineGate("IgnoreBots", (ctx) => {
+	if (ctx.user?.bot) throw new Silence("actor is a bot");
+});
+
+//#endregion
+//#region src/bot/notices/utils.ts
+function mentionFor(subject) {
+	if (subject instanceof Role) return `<@&${subject.id}>`;
+	if (subject instanceof TextChannel) return `<#${subject.id}>`;
+	if (subject instanceof GuildMember) return `<@${subject.id}>`;
+	return `\`${subject.name}\``;
+}
+function labelFor(subject) {
+	if (subject instanceof Role) return "role";
+	if (subject instanceof TextChannel) return "channel";
+	if (subject instanceof GuildMember) return "member";
+	return "guild";
+}
+
+//#endregion
+//#region src/bot/notices/index.ts
+var NotNsfw = class extends GateNotice {
+	constructor(message = "This can only be used in an age-restricted channel.") {
+		super(message);
+	}
+};
+var MissingRole = class extends GateNotice {
+	role;
+	constructor(message, role) {
+		super(message ?? (role ? `You need the ${role.name} role to use this.` : "You do not have the required role."));
+		this.role = role;
+	}
+};
+var RoleHigherThanMe = class extends Notice {
+	role;
+	botRole;
+	constructor(message, role, botRole) {
+		super(message);
+		this.role = role;
+		this.botRole = botRole;
+	}
+	render() {
+		return { components: [new NoticeCard(`I cannot assign a role that is higher than me.\n\nThe role <@&${this.role.id}> is higher than my role <@&${this.botRole.id}> in the hierarchy.`).component] };
+	}
+};
+var CannotAssignBotRole = class extends Notice {
+	constructor(message = "I cannot assign a managed role.") {
+		super(message);
+	}
+	render() {
+		return { components: [new NoticeCard("I cannot assign a managed role.").component] };
+	}
+};
+var MissingPermissions = class extends Notice {
+	where;
+	missingPerms;
+	constructor(message, where, missingPerms) {
+		super(message);
+		this.where = where;
+		this.missingPerms = missingPerms;
+	}
+	render() {
+		const bullets = this.missingPerms.map((perm) => `• ${perm}`).join("\n");
+		return { components: [new NoticeCard(`The ${labelFor(this.where)} ${mentionFor(this.where)} is missing the following permission entries:\n\n${bullets}`).component] };
+	}
+};
+var HasDangerousPermissions = class extends Notice {
+	target;
+	dangerousPerms;
+	constructor(message, target, dangerousPerms) {
+		super(message);
+		this.target = target;
+		this.dangerousPerms = dangerousPerms;
+	}
+	render() {
+		const bullets = this.dangerousPerms.map((perm) => `• ${perm}`).join("\n");
+		return { components: [new NoticeCard(`The ${labelFor(this.target)} ${mentionFor(this.target)} has the following permission entries that must not be enabled:\n\n${bullets}`).component] };
+	}
+};
+var UserNotFound = class extends Notice {
+	userArg;
+	constructor(userArg) {
+		super(`User not found: ${userArg}`);
+		this.userArg = userArg;
+	}
+	render() {
+		return { components: [new NoticeCard(`User probably doesn't exist or was deleted.\n**User Argument:** \`${this.userArg}\`\nPlease check the user ID and try again. Only pass valid user IDs as the argument.`, "User Not Found").component] };
+	}
+};
+var UserNotInGuild = class extends Notice {
+	constructor(message = "User is not in the guild.") {
+		super(message);
+	}
+	render() {
+		return { components: [new NoticeCard(this.message).component] };
+	}
+};
+var RoleDoesNotExist = class extends Notice {
+	roleId;
+	constructor(message, roleId) {
+		super(message);
+		this.roleId = roleId;
+	}
+	render() {
+		return { components: [new NoticeCard(`The role with ID \`${this.roleId}\` does not exist.`).component] };
+	}
+};
+var CouldNotFindChannel = class extends Notice {
+	channelId;
+	constructor(message, channelId) {
+		super(message);
+		this.channelId = channelId;
+	}
+	render() {
+		return { components: [new NoticeCard(`Could not find channel with ID \`${this.channelId}\`. It could also be that the channel is not a text channel.`).component] };
+	}
+};
+
+//#endregion
+//#region src/bot/gates/catalog/Nsfw.ts
+function channelIsNsfw(channel) {
+	if (!channel) return false;
+	if (channel.isThread()) return channel.parent?.nsfw ?? false;
+	return "nsfw" in channel ? channel.nsfw : false;
+}
+/**
+* Requires an age-restricted channel, else refuses. Pass {@link GateNoticeOptions} to reword or replace the refusal.
+*
+* A thread inherits its parent channel's nsfw flag. ModalSubmit has no reliable channel, so it is excluded.
+*
+* @param options - Reword the default refusal with `message`, or replace it with `notice`.
+*
+* @see {@link Gated}
+*
+* @example
+* ```ts
+* \@Gated(Nsfw())
+* \@SlashRoute('nsfwcmd')
+* class NsfwHandler extends SlashHandler<'nsfwcmd'> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function Nsfw(options) {
+	return defineGate("Nsfw", (ctx) => {
+		if (channelIsNsfw(ctx.interaction.channel)) return;
+		throw pickNotice(options, (message) => new NotNsfw(message));
+	});
+}
+
+//#endregion
+//#region src/bot/utilities/permissions/checkPermissions.ts
+/**
+* Map of permission bits to their prettified human readable names.
+*/
+const PermissionNames = new Map(Object.entries(PermissionFlagsBits).map(([key, bit]) => [bit, prettify(key)]));
+function checkPermissions(a, b, c, d, e) {
+	const { for: pFor, in: pIn, scope, inverse = false, missing: missingCtor, dangerous: dangerousCtor } = a instanceof Role || a instanceof GuildMember ? {
+		for: a,
+		in: b,
+		scope: c,
+		inverse: d ?? false,
+		...e
+	} : a;
+	const Missing = missingCtor ?? MissingPermissions;
+	const Dangerous = dangerousCtor ?? HasDangerousPermissions;
+	const perms = pIn instanceof Guild ? pFor.permissions : pIn.permissionsFor(pFor, true);
+	const names = (bits) => bits.map((bit) => PermissionNames.get(bit) ?? String(bit));
+	const present = scope.filter((bit) => perms.has(bit, true));
+	const presentNames = names(present);
+	if (inverse) {
+		if (present.length > 0) throw new Dangerous(`${pFor instanceof Role ? "Role" : "Member"} has dangerous permissions in this ${pIn instanceof Guild ? "guild" : "channel"}`, pFor, presentNames);
+		return;
+	}
+	const missingBits = scope.filter((bit) => !perms.has(bit, true));
+	if (missingBits.length > 0) throw new Missing("Missing Any/All/No Permissions", pFor, names(missingBits));
+}
+
+//#endregion
+//#region src/bot/gates/catalog/permissions.ts
+const UNCACHED_MEMBER = "Your server member data could not be resolved. Try again.";
+/**
+* Requires the caller to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
+*
+* Interaction-only and excludes ModalSubmit, since a modal lacks a reliable cached caller member.
+*
+* @param scope - The permission flag bits the caller must all hold.
+* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
+*
+* @see {@link Gated}
+*
+* @example
+* ```ts
+* import { PermissionFlagsBits } from 'discord.js';
+*
+* \@Gated(RequirePermissions([PermissionFlagsBits.BanMembers]))
+* \@SlashRoute('ban')
+* class BanHandler extends SlashHandler<'ban'> {
+*     async execute() {
+*         const target = this.options.getUser('target');
+*     }
+* }
+* ```
+*/
+function RequirePermissions(scope, options) {
+	return defineGate("RequirePermissions", (ctx) => {
+		if (!ctx.guild) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message));
+		if (!ctx.member) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message ?? UNCACHED_MEMBER));
+		checkPermissions(ctx.member, ctx.guild, scope, false, options?.missing ? { missing: options.missing } : void 0);
+	});
+}
+/**
+* Requires the bot to hold every permission in `scope`, via `checkPermissions`. Refuses outside a guild.
+*
+* It reads the bot's own member, so it attaches to modal handlers as well.
+*
+* @param scope - The permission flag bits the bot must all hold.
+* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-permissions one with `missing`.
+*
+* @see {@link Gated}
+*
+* @example
+* ```ts
+* import { PermissionFlagsBits } from 'discord.js';
+*
+* \@Gated(RequireBotPermissions([PermissionFlagsBits.BanMembers]))
+* \@ModalRoute(MyModalId)
+* class MyModalHandler extends ModalHandler<[typeof MyModalId]> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function RequireBotPermissions(scope, options) {
+	return defineGate("RequireBotPermissions", (ctx) => {
+		const botMember = ctx.guild?.members.me;
+		if (!ctx.guild || !botMember) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message));
+		checkPermissions(botMember, ctx.guild, scope, false, options?.missing ? { missing: options.missing } : void 0);
+	});
+}
+/**
+* Requires the caller to have `roleId`, read from the member's role cache. Refuses outside a guild first, then
+* when the role is missing.
+*
+* Interaction-only and excludes ModalSubmit.
+*
+* @param roleId - The role snowflake the caller must hold, read from the member's role cache.
+* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
+*
+* @see {@link Gated}
+*
+* @example
+* ```ts
+* \@Gated(RequireRole('123456789012345678'))
+* \@SlashRoute('vip')
+* class VipHandler extends SlashHandler<'vip'> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function RequireRole(roleId, options) {
+	return defineGate("RequireRole", (ctx) => {
+		if (!ctx.guild) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message));
+		if (!ctx.member) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message ?? UNCACHED_MEMBER));
+		if (ctx.member.roles.cache.has(roleId)) return;
+		const role = ctx.guild.roles.cache.get(roleId) ?? null;
+		throw pickNotice(options?.missingRole, (message) => new MissingRole(message, role));
+	});
+}
+
+//#endregion
+//#region src/bot/injectors/EmojiInjector.ts
+const emojiStorage = {};
+function isEmojiTuple(v) {
+	return Array.isArray(v) && v.length === 2 && typeof v[0] === "string" && typeof v[1] === "string";
+}
+/**
+* Global emoji mappings object
+*
+* @see {@link EmojiMap}
+*/
+const Emojis = emojiStorage;
+/**
+* Loads and injects emojis based on bot configuration.
+*
+* For emojis injected from specific guilds, ensure that the Guilds intent is provided in client options.
+*
+* @internal
+*/
+var EmojiInjector = class {
+	core;
+	logger = new Logger("Emojis");
+	constructor(core) {
+		this.core = core;
+	}
+	async init() {
+		this.clearEmojis();
+		if (!this.core.config.bot.emojis || Object.keys(this.core.config.bot.emojis).length === 0) {
+			this.logger.debug(chalk.bold.yellow("No emojis configured, skipping emoji injection."));
+			return;
+		}
+		const configEmojis = this.core.config.bot.emojis;
+		await this.core.bot.client.application?.emojis.fetch();
+		const failures = [];
+		const fetchedGuilds = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(configEmojis)) if (isEmojiTuple(value)) await this.resolveTuple(key, value, failures, fetchedGuilds);
+		else if (typeof value === "string") this.resolveString(key, value, failures);
+		else failures.push(`  - "${key}" has an invalid value (expected a name or [name, guildId])`);
+		if (failures.length > 0) throw new SeedcordError(SeedcordErrorCode.ConfigEmojiUnresolved, [failures.length, failures.join("\n")]);
+		this.logger.utils.summary("Loaded emojis", { emojis: Object.keys(emojiStorage).length });
+	}
+	async resolveTuple(key, value, failures, fetchedGuilds) {
+		const [emojiName, guildId] = value;
+		const guild = this.core.bot.client.guilds.cache.get(guildId);
+		if (!guild) {
+			failures.push(`  - "${emojiName}" for "${key}" targets guild ${guildId}, which is not available (check the Guilds intent)`);
+			return;
+		}
+		if (!fetchedGuilds.has(guildId)) {
+			await guild.emojis.fetch();
+			fetchedGuilds.add(guildId);
+		}
+		const guildEmoji = guild.emojis.cache.find((e) => e.name === emojiName);
+		if (!guildEmoji) {
+			failures.push(`  - "${emojiName}" for "${key}" was not found in guild ${guildId}`);
+			return;
+		}
+		emojiStorage[key] = guildEmoji;
+	}
+	resolveString(key, emojiName, failures) {
+		const appEmoji = this.core.bot.client.application?.emojis.cache.find((e) => e.name === emojiName);
+		if (!appEmoji) {
+			failures.push(`  - "${emojiName}" for "${key}" was not found among the application emojis`);
+			return;
+		}
+		emojiStorage[key] = appEmoji;
+	}
+	clearEmojis() {
+		for (const key of Object.keys(emojiStorage)) Reflect.deleteProperty(emojiStorage, key);
+	}
+};
+
+//#endregion
+//#region src/bot/injectors/CommandMentionInjector.ts
+const mentionStorage = {};
+/**
+* Ready-to-send command mention strings, keyed by {@link SlashOptionRegistry}.
+*
+* A value is a clickable `</name:id>` when the command's id resolved from the deploy, otherwise the plain
+* `/name` text. Populated by {@link CommandMentionInjector} after each deploy.
+*/
+const CommandMentions = mentionStorage;
+const MULTI_GUILD = Symbol("seedcord:commandmentions:multi-guild");
+/**
+* Turns each deployed slash route into a clickable command mention exposed through {@link CommandMentions}.
+*
+* Consumes the ids {@link DeployResult} carries, so it runs after a deploy rather than resolving from a name
+* cache (discord.js offers none for command ids). A global command is clickable everywhere by its app-wide id.
+* A guild command deployed to one guild is clickable by that guild's id. A command deployed to two or more
+* guilds mints a different id per guild, so one accessor key cannot resolve it, and it falls back to plain
+* `/name` text with one warn. On a non-owning shard a guild command also falls back to plain text.
+*
+* @internal
+*/
+var CommandMentionInjector = class {
+	core;
+	logger = new Logger("CommandMentions");
+	constructor(core) {
+		this.core = core;
+	}
+	inject(deploy) {
+		this.clear();
+		const globalIds = this.indexByName(deploy.global);
+		const guildIds = this.indexGuilds(deploy.guilds);
+		const warned = /* @__PURE__ */ new Set();
+		let clickable = 0;
+		for (const command of this.allSlashBuilders()) {
+			const id = this.resolveId(command.name, globalIds, guildIds, warned);
+			for (const leaf of routeLeavesOf(command.toJSON())) {
+				mentionStorage[leaf.route] = id ? this.toMention(leaf.route, id) : this.toPlain(leaf.route);
+				if (id) clickable++;
+			}
+		}
+		this.logger.utils.summary("Linked mentions", {
+			clickable,
+			plain: Object.keys(mentionStorage).length - clickable
+		});
+	}
+	allSlashBuilders() {
+		const registry = this.core.bot.commands;
+		if (!registry) return [];
+		const slash = [...registry.globalCommands, ...registry.guildCommands.values()].flat().filter((command) => command instanceof SlashCommandBuilder);
+		return [...new Set(slash)];
+	}
+	indexByName(collection) {
+		const map = /* @__PURE__ */ new Map();
+		for (const command of collection.values()) map.set(command.name, command.id);
+		return map;
+	}
+	indexGuilds(guilds) {
+		const map = /* @__PURE__ */ new Map();
+		for (const collection of guilds.values()) for (const command of collection.values()) {
+			const existing = map.get(command.name);
+			if (existing === void 0) map.set(command.name, command.id);
+			else if (existing !== command.id) map.set(command.name, MULTI_GUILD);
+		}
+		return map;
+	}
+	resolveId(name, globalIds, guildIds, warned) {
+		const global = globalIds.get(name);
+		if (global) return global;
+		const guild = guildIds.get(name);
+		if (guild === void 0) return void 0;
+		if (guild === MULTI_GUILD) {
+			if (!warned.has(name)) {
+				this.logger.warn(`${name} is deployed to multiple guilds, falling back to plain text (not clickable).`);
+				warned.add(name);
+			}
+			return;
+		}
+		return guild;
+	}
+	toMention(route, id) {
+		const [name, middle, sub] = route.split("/");
+		if (name && middle && sub) return chatInputApplicationCommandMention(name, middle, sub, id);
+		if (name && middle) return chatInputApplicationCommandMention(name, middle, id);
+		return chatInputApplicationCommandMention(name ?? route, id);
+	}
+	toPlain(route) {
+		return `/${route.replaceAll("/", " ")}`;
+	}
+	clear() {
+		for (const key of Object.keys(mentionStorage)) Reflect.deleteProperty(mentionStorage, key);
+	}
+};
+
+//#endregion
+//#region src/bot/utilities/channels/fetchText.ts
+/**
+* Fetches and validates a text channel. Refuses when the channel doesn't exist or isn't a text channel.
+*
+* @param client - The Discord client instance
+* @param channelId - Channel ID or TextChannel instance
+* @returns Promise resolving to the text channel
+*/
+async function fetchText(client, channelId) {
+	if (channelId instanceof TextChannel) return channelId;
+	let channel = client.channels.cache.get(channelId);
+	if (!channel) try {
+		channel = await client.channels.fetch(channelId);
+	} catch (err) {
+		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownChannel) throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
+		throw err;
+	}
+	if (channel?.isTextBased()) return channel;
+	throw new CouldNotFindChannel("Channel not found or not a text channel", channelId);
+}
+
+//#endregion
+//#region src/bot/utilities/permissions/checkBotPermissions.ts
+/**
+* Checks if the bot has required permissions in a {@link Guild} or {@link TextChannel}. Refuses when a
+* required permission is missing.
+*
+* @param target - Guild or text channel to check in
+* @param scope - Permission bits to validate
+* @param inverse - Whether to check for absence of the given permissions
+* @param errors - Optional custom error constructors
+*
+* @example
+* ```ts
+* import { PermissionFlagsBits } from 'discord.js';
+* import { checkBotPermissions } from '@seedcord/gateway';
+*
+* // Check if the bot has SendMessages and ViewChannel permissions in a text channel
+* checkBotPermissions(textChannel, [
+*   PermissionFlagsBits.SendMessages,
+*   PermissionFlagsBits.ViewChannel
+* ]);
+* ```
+*/
+function checkBotPermissions(target, scope, inverse = false, errors) {
+	if (target instanceof Guild) {
+		const me = target.members.me;
+		if (!me) {
+			const names = scope.map((bit) => PermissionNames.get(bit) ?? String(bit));
+			throw new ((errors?.missing) ?? MissingPermissions)("Missing Permissions", target, names);
+		}
+		checkPermissions(me, target, scope, inverse, errors);
+		return;
+	}
+	const me = target.guild.members.me;
+	if (!me) {
+		new Logger("checkBotPermissions").warn(`Bot member is unavailable in guild ${target.guild.id} while checking permissions in channel ${target.id}`);
+		const names = scope.map((bit) => PermissionNames.get(bit) ?? String(bit));
+		throw new ((errors?.missing) ?? MissingPermissions)("Missing Permissions", target, names);
+	}
+	checkPermissions(me, target, scope, inverse, errors);
+}
+
+//#endregion
+//#region src/bot/utilities/roles/getBotRole.ts
+/**
+* Gets the bot's managed role in a guild.
+*
+* @param guild - The guild to get the bot role from
+* @returns The bot's managed role in the guild
+* @throws A **SeedcordError** if the client user is unavailable or if the bot role is missing
+*/
+function getBotRole(guild) {
+	const botRole = guild.roles.botRoleFor(guild.client.user);
+	if (!botRole) throw new SeedcordError(SeedcordErrorCode.CoreBotRoleMissing, [guild.id]);
+	return botRole;
+}
+
+//#endregion
+//#region src/bot/utilities/permissions/hasPermsToAssign.ts
+/**
+* Validates if the bot can assign a target role. Refuses when the target role is above the bot's, is managed, or the bot lacks Manage Roles.
+*
+* @param roleOrOptions - Target role or complete options for the check
+*
+* @example
+* ```ts
+* import { hasPermsToAssign } from '@seedcord/gateway';
+*
+* // Check if the bot can assign a specific role
+* hasPermsToAssign(role);
+*
+* // Check with custom error handling
+* hasPermsToAssign({
+*   targetRole: role,
+*   errors: {
+*     higher: CustomHigherError,
+*     managed: CustomManagedError,
+*     missing: CustomMissingPermissionsError
+*   }
+* });
+* ```
+*/
+function hasPermsToAssign(roleOrOptions) {
+	const { targetRole, errors } = roleOrOptions instanceof Role ? {
+		targetRole: roleOrOptions,
+		errors: void 0
+	} : roleOrOptions;
+	const HigherErr = errors?.higher ?? RoleHigherThanMe;
+	const ManagedErr = errors?.managed ?? CannotAssignBotRole;
+	const Missing = errors?.missing ?? MissingPermissions;
+	const botRole = getBotRole(targetRole.guild);
+	if (targetRole.comparePositionTo(botRole) >= 0) throw new HigherErr("Role is higher than me", targetRole, botRole);
+	if (targetRole.managed) throw new ManagedErr(`Cannot assign managed role ${targetRole.name}`);
+	checkBotPermissions(targetRole.guild, [PermissionFlagsBits.ManageRoles], false, { missing: Missing });
+}
+
+//#endregion
+//#region src/bot/utilities/roles/fetchRole.ts
+function isUnknownRole(err) {
+	return err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownRole;
+}
+async function fetchRoleInGuild(guild, roleId) {
+	const cached = guild.roles.cache.get(roleId);
+	if (cached) return cached;
+	try {
+		return await guild.roles.fetch(roleId);
+	} catch (err) {
+		if (isUnknownRole(err)) throw new RoleDoesNotExist("Role not found in specified guild", roleId);
+		throw err;
+	}
+}
+async function scanGuildsForRole(client, roleId) {
+	const cached = client.guilds.cache.map((guild) => guild.roles.cache.get(roleId)).find(Boolean);
+	if (cached) return cached;
+	for (const guild of client.guilds.cache.values()) try {
+		const role = await guild.roles.fetch(roleId);
+		if (role) return role;
+	} catch (err) {
+		if (isUnknownRole(err)) continue;
+		throw err;
+	}
+	return null;
+}
+/**
+* Fetches a role by ID from a client or guild. Refuses when the role doesn't exist.
+*
+* @param clientOrGuild - Discord client or guild instance
+* @param roleId - The role ID to fetch
+* @returns Promise resolving to the role
+*/
+async function fetchRole(clientOrGuild, roleId) {
+	if (!roleId) throw new RoleDoesNotExist("Role ID is null or undefined", roleId);
+	const role = clientOrGuild instanceof Guild ? await fetchRoleInGuild(clientOrGuild, roleId) : await scanGuildsForRole(clientOrGuild, roleId);
+	if (!role) throw new RoleDoesNotExist("Role not found", roleId);
+	return role;
+}
+
+//#endregion
+//#region src/bot/utilities/users/fetchGuildMember.ts
+/**
+* Fetches a guild member by user ID. Refuses when the user is not in the guild.
+*
+* @param guild - The guild to fetch the member from
+* @param userId - The Discord user ID
+* @returns Promise resolving to the guild member
+*/
+async function fetchGuildMember(guild, userId) {
+	let user = guild.members.cache.get(userId);
+	user ??= await guild.members.fetch(userId).catch((err) => {
+		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownMember) throw new UserNotInGuild(`User with ID ${userId} not found in guild`);
+		throw err;
+	});
+	return user;
+}
+
+//#endregion
+//#region src/bot/utilities/users/fetchManyGuildMembers.ts
+/**
+* Fetches multiple guild members by user IDs.
+*
+* @param guild - The guild to fetch members from
+* @param userIds - Array of Discord user IDs
+* @returns Promise resolving to array of successfully fetched members
+*/
+async function fetchManyGuildMembers(guild, userIds) {
+	return (await Promise.allSettled(userIds.map((userId) => fetchGuildMember(guild, userId)))).filter((result) => result.status === "fulfilled").map((result) => result.value);
+}
+
+//#endregion
+//#region src/bot/utilities/users/fetchUser.ts
+/**
+* Fetches a Discord user by ID. Refuses when the user doesn't exist, with `options.throwAs` or the default.
+*
+* @param client - The Discord client instance
+* @param userId - The Discord user ID
+* @param options - Optional overrides, including the {@link FetchUserOptions.throwAs} notice
+* @returns Promise resolving to the user
+*/
+async function fetchUser(client, userId, options) {
+	const Throw = options?.throwAs ?? UserNotFound;
+	let user = client.users.cache.get(userId);
+	user ??= await client.users.fetch(userId).catch((err) => {
+		if (err instanceof DiscordAPIError && err.code === RESTJSONErrorCodes.UnknownUser) throw new Throw(userId);
+		throw err;
+	});
+	return user;
+}
+
+//#endregion
+//#region src/bot/utilities/users/fetchManyUsers.ts
+/**
+* Fetches multiple Discord users by IDs.
+*
+* @param client - The Discord client instance
+* @param userIds - Array of Discord user IDs
+* @param options - Optional overrides threaded to each {@link fetchUser} call
+* @returns Promise resolving to array of successfully fetched users
+*/
+async function fetchManyUsers(client, userIds, options) {
+	return (await Promise.allSettled(userIds.map((userId) => fetchUser(client, userId, options)))).filter((result) => result.status === "fulfilled").map((result) => result.value);
+}
+
+//#endregion
+//#region src/bot/utilities/users/updateMemberRoles.ts
+/**
+* Updates a guild member's roles by adding and removing specified roles.
+*
+* @param rolesToAdd - Array of role IDs to add to the member
+* @param rolesToRemove - Array of role IDs to remove from the member
+* @param member - The guild member to update
+* @returns Promise that resolves when roles are updated
+*/
+async function updateMemberRoles(rolesToAdd, rolesToRemove, member) {
+	const current = new Set(member.roles.cache.map((r) => r.id));
+	const toAdd = new Set(rolesToAdd);
+	const toRemove = new Set(rolesToRemove);
+	const updated = current.union(toAdd).difference(toRemove);
+	await member.roles.set([...updated]);
+}
+
+//#endregion
+//#region src/bot/harmlessApiCodes.ts
+/**
+* Discord API error codes that mean a dead end on an interaction, a dead token, a double ack, or a gone
+* message. There is nothing to show the user and no bug to report. The controller boundary drops them on
+* the original throw, and {@link ReplySender} drops them on its own send.
+*
+* @internal
+*/
+const HARMLESS_API_CODES = new Set([
+	RESTJSONErrorCodes.UnknownInteraction,
+	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
+	RESTJSONErrorCodes.UnknownMessage
+]);
+
+//#endregion
+//#region src/miscellaneous/flagsFor.ts
+/**
+* Builds the `flags` bitfield for a framework reply. Every framework reply is ComponentsV2, so the
+* IsComponentsV2 flag is always set.
+*
+* @param ephemeral - Whether the reply is ephemeral.
+* @returns The OR'd `MessageFlags` value as a plain number.
+*
+* @internal
+*/
+function flagsFor(ephemeral) {
+	let flags = MessageFlags.IsComponentsV2;
+	if (ephemeral) flags |= MessageFlags.Ephemeral;
+	return flags;
+}
+
+//#endregion
+//#region src/bot/ReplySender.ts
+/**
+* Sends a {@link ReplyResponse} to an interaction, picking reply, editReply, or followUp from the live
+* acknowledgement state. Logs and drops its own send failures so a dead token never escapes into the
+* controller.
+*/
+var ReplySender = class {
+	interaction;
+	logger = new Logger("ReplySender");
+	constructor(interaction) {
+		this.interaction = interaction;
+	}
+	/**
+	* Sends the reply and returns the sent message so a caller can attach a collector to it. Never throws,
+	* a failed send is logged and dropped and resolves to `undefined`.
+	*
+	* @param response - The ComponentsV2 reply to show.
+	* @param ephemeral - Whether the reply is ephemeral. {@default `true`}
+	* @returns The sent {@link Message}, or `undefined` when the send was swallowed.
+	*/
+	async send(response, ephemeral = true) {
+		try {
+			return await this.dispatch(response, ephemeral);
+		} catch (error) {
+			this.logSwallowed("send", error);
+			return;
+		}
+	}
+	/**
+	* Edits an already-sent message to a new {@link ReplyResponse}. Used to swap a confirmation prompt for
+	* its outcome. Never throws, a failed edit is logged and dropped.
+	*
+	* @param message - The message to edit (the handle a prior {@link send} returned).
+	* @param response - The reply to replace it with.
+	*/
+	async edit(message, response) {
+		try {
+			await this.interaction.webhook.editMessage(message, this.editBody(response));
+		} catch (error) {
+			this.logSwallowed("edit", error);
+		}
+	}
+	async dispatch(response, ephemeral) {
+		if (this.interaction.replied) return await this.interaction.followUp(this.replyOptions(response, ephemeral));
+		if (this.interaction.deferred) {
+			if (this.interaction.ephemeral === null) return await this.interaction.followUp(this.replyOptions(response, ephemeral));
+			return await this.interaction.editReply(this.editBody(response));
+		}
+		await this.interaction.reply(this.replyOptions(response, ephemeral));
+		return await this.interaction.fetchReply();
+	}
+	replyOptions(response, ephemeral) {
+		return {
+			components: response.components,
+			flags: flagsFor(ephemeral),
+			...response.allowedMentions && { allowedMentions: response.allowedMentions },
+			...response.files && { files: response.files }
+		};
+	}
+	editBody(response) {
+		return {
+			components: response.components,
+			flags: MessageFlags.IsComponentsV2,
+			...response.allowedMentions && { allowedMentions: response.allowedMentions },
+			...response.files && { files: response.files }
+		};
+	}
+	logSwallowed(action, error) {
+		if (error instanceof DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
+			this.logger.debug(`reply ${action} hit harmless code ${error.code}`);
+			return;
+		}
+		this.logger.error(`reply ${action} failed`, error);
+	}
+};
+
+//#endregion
+//#region src/bot/confirm/reserved.ts
+const RESERVED_CONFIRM_PREFIX = "__seedcord_confirm";
+/**
+* The reserved confirm/cancel codec. It has no route, so the dispatcher ignores its clicks and only the
+* in-process collector reads them. Do not mint a real component from it.
+*
+* @internal
+*/
+const CONFIRM_DEF = new CustomId(RESERVED_CONFIRM_PREFIX).oneOf("choice", ["confirm", "cancel"]);
+
+//#endregion
+//#region src/bot/confirm/getConfirmation.ts
+const DEFAULT_TIMEOUT_MS = 3e4;
+const CONFIRM_IDS = {
+	confirm: CONFIRM_DEF.encode({ choice: "confirm" }),
+	cancel: CONFIRM_DEF.encode({ choice: "cancel" })
+};
+var ConfirmButtons = class extends RowComponent {
+	constructor(options) {
+		super("button");
+		this.instance.addComponents(new ButtonBuilder().setCustomId(CONFIRM_IDS.confirm).setLabel(options?.confirmLabel ?? "Confirm").setStyle(options?.confirmStyle ?? ButtonStyle.Danger), new ButtonBuilder().setCustomId(CONFIRM_IDS.cancel).setLabel(options?.cancelLabel ?? "Cancel").setStyle(ButtonStyle.Secondary));
+	}
+};
+var ConfirmPromptCard = class extends BuilderComponent {
+	constructor(text, options) {
+		super("container");
+		this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(text)).addActionRowComponents(new ConfirmButtons(options).component);
+	}
+};
+function defaultPrompt(text, options) {
+	return { components: [new ConfirmPromptCard(text, options).component] };
+}
+async function collectChoice(message, userId, timeoutMs) {
+	try {
+		return await message.awaitMessageComponent({
+			componentType: ComponentType.Button,
+			time: timeoutMs,
+			filter: (click) => click.user.id === userId && CONFIRM_DEF.owns(click.customId)
+		});
+	} catch {
+		return null;
+	}
+}
+async function settle(sender, interaction, message, outcome) {
+	if (outcome === void 0) {
+		await interaction.deleteReply(message).catch(() => void 0);
+		return;
+	}
+	await sender.edit(message, typeof outcome === "function" ? await outcome() : outcome);
+}
+async function getConfirmation(interaction, prompt, options) {
+	const { ephemeral = true, timeoutMs = DEFAULT_TIMEOUT_MS } = options ?? {};
+	const response = typeof prompt === "string" ? defaultPrompt(prompt, options) : await prompt(CONFIRM_IDS);
+	const sender = new ReplySender(interaction);
+	const message = await sender.send(response, ephemeral);
+	if (!message) return false;
+	const winner = await collectChoice(message, interaction.user.id, timeoutMs);
+	if (!winner) {
+		await settle(sender, interaction, message, options?.onTimeout);
+		return false;
+	}
+	await winner.deferUpdate().catch(() => void 0);
+	const confirmed = winner.customId === CONFIRM_IDS.confirm;
+	await settle(sender, interaction, message, confirmed ? options?.onConfirm : options?.onCancel);
+	return confirmed;
+}
+
+//#endregion
+//#region src/hmr/devChannel.ts
+let channel;
+function setDevChannel(next) {
+	channel = next;
+}
+function getDevChannel() {
+	return channel;
+}
+
+//#endregion
+//#region src/interfaces/Plugin.ts
+/**
+* Base class for Seedcord plugins
+*
+* Extend this class to create plugins that integrate with the Seedcord lifecycle.
+* Plugins have access to the core instance and must implement initialization logic.
+*/
+var Plugin = class extends TypedEventEmitter {
+	pluggable;
+	name = this.constructor.name;
+	constructor(pluggable) {
+		super();
+		this.pluggable = pluggable;
+	}
+	/**
+	* Reloads plugin state on an HMR update. The base implementation is a no-op, override it in your plugin.
+	* @virtual
+	*/
+	onHmr(_event) {
+		return Promise.resolve();
+	}
+	/**
+	* Registers critical file patterns that should trigger a full restart when changed in Dev HMR.
+	* @param patterns - Glob patterns relative to the project root
+	*/
+	registerCriticalFiles(patterns) {
+		getDevChannel()?.send("seedcord:register-critical-files", { patterns });
+	}
+	/** @internal */
+	removeListener(event, listener) {
+		return super.removeListener(event, listener);
+	}
+	/** @internal */
+	removeAllListeners(event) {
+		return super.removeAllListeners(event);
+	}
+};
+/**
+* Base class for objects that can have plugins attached.
+*
+* Provides plugin attachment capabilities and lifecycle management. Plugins are attached during
+* configuration and initialized during startup. Not constructed directly, the host is a {@link Seedcord}.
+*/
+var Pluggable = class Pluggable extends TypedEventEmitter {
+	isInitialized = false;
+	shutdown;
+	startup;
+	plugins = [];
+	static PLUGIN_INIT_TIMEOUT_MS = 15e3;
+	constructor(shutdown, startup) {
+		super();
+		this.shutdown = shutdown;
+		this.startup = startup;
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return this;
+		await this.startup.run();
+		this.isInitialized = true;
+		return this;
+	}
+	/**
+	* Attaches a plugin to this instance
+	*
+	* Plugins provide external functionality and are initialized during the specified startup phase.
+	* The plugin instance becomes available as a property in `core` wherever it's available.
+	*
+	* Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
+	*
+	* @typeParam Key - The property name for accessing the plugin
+	* @typeParam Ctor - The plugin constructor type
+	* @param key - Property name to access the plugin instance
+	* @param Plugin - Plugin constructor class
+	* @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 A **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, Plugin, startupPhase, ...args) {
+		if (this.isInitialized) throw new SeedcordError(SeedcordErrorCode.CorePluginAfterInit);
+		if (key in this) throw new SeedcordError(SeedcordErrorCode.CorePluginKeyExists, [key]);
+		const instance = new Plugin(this, ...args);
+		this.plugins.push(instance);
+		const entry = { [key]: instance };
+		this.startup.addTask(startupPhase, `Plugin:${key}`, async () => {
+			instance.logger.utils.initialization(key, "start");
+			await instance.init();
+			instance.logger.utils.initialization(key, "end");
+		}, Pluggable.PLUGIN_INIT_TIMEOUT_MS);
+		return Object.assign(this, entry);
+	}
+	/** @internal */
+	removeListener(event, listener) {
+		return super.removeListener(event, listener);
+	}
+	/** @internal */
+	removeAllListeners(event) {
+		return super.removeAllListeners(event);
+	}
+};
+
+//#endregion
+//#region src/handlers/BaseHandler.ts
+/**
+* Base class for a Discord event or interaction handler. Don't register handlers directly, use the more specific handler subclasses.
+*/
+var BaseHandler = class {
+	core;
+	event;
+	logger;
+	dispatch;
+	constructor(event, core, dispatch) {
+		this.core = core;
+		this.event = event;
+		this.logger = new Logger(this.constructor.name);
+		this.dispatch = dispatch;
+	}
+	/** @internal */
+	getEvent() {
+		return this.event;
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.ts
+/**
+* Base class for interaction middleware
+*
+* Middleware runs before interaction handlers and can modify behavior or block execution.
+* Unlike handlers, middleware should not send responses directly.
+*
+* @typeParam Repliable - The interaction type this middleware processes
+*/
+var InteractionMiddleware = class extends BaseHandler {
+	constructor(event, core) {
+		super(event, core);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/InteractionHandler.ts
+/**
+* Shared base the typed interaction handlers extend.
+*
+* Not a public entry point. You should be using {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+* or {@link SelectMenuHandler} instead. This class only carries the repliable-event plumbing those bases share,
+* so DO NOT use it directly.
+*
+* @typeParam Repliable - The interaction type this handler processes
+*/
+var InteractionHandler = class extends BaseHandler {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch);
+	}
+};
+
+//#endregion
+//#region src/bot/utilities/miscellaneous/slashRouteOf.ts
+/**
+* Computes the dispatch route for a chat-input or autocomplete interaction. The controller and
+* `seedcord codegen` both assemble route keys through the same {@link buildSlashRoute}, so a dispatched
+* interaction and a generated registry key always match.
+*
+* @internal
+*/
+function slashRouteOf(interaction) {
+	const group = interaction.options.getSubcommandGroup(false) ?? void 0;
+	const subcommand = interaction.options.getSubcommand(false) ?? void 0;
+	return buildSlashRoute(interaction.commandName, subcommand, group);
+}
+
+//#endregion
+//#region src/handlers/interaction/SlashHandler.ts
+/**
+* Base class for a chat-input (slash) command handler.
+*
+* Pass the route from the generated registry as the generic, the same string as `@SlashRoute`, then read
+* `this.options` for a single command or `this.match` for several. Command authoring stays plain
+* discord.js, `seedcord codegen` reads its `toJSON()` to type these options.
+*
+* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@SlashRoute('ban')
+* class BanHandler extends SlashHandler<'ban'> {
+*     async execute() {
+*         const target = this.options.getUser('target'); // User
+*         const reason = this.options.getString('reason'); // string | null
+*     }
+* }
+* ```
+*/
+var SlashHandler = class extends InteractionHandler {
+	/**
+	* The typed options for this command's route. Required options drop the null, choices narrow to their
+	* literal union, and only the getters for kinds this command actually uses appear. Use `this.event.options`
+	* directly for anything outside this view, such as narrowing a channel option by type.
+	*/
+	get options() {
+		return this.event.options;
+	}
+	/**
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* routes. A single-route handler reads `this.options` directly instead, match buys nothing there.
+	*
+	* Provide one arm per registered route, keyed by its route string, and each arm receives that route's
+	* own narrowed options. The arms must cover every route in the generic, a missing route or an unknown
+	* key is a compile error.
+	*
+	* @param arms - One handler per registered route, keyed by route string.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@SlashRoute('ban', 'kick')
+	* class ModHandler extends SlashHandler<'ban' | 'kick'> {
+	*     async execute() {
+	*         await this.match({
+	*             ban: (options) => this.event.guild?.members.ban(options.getUser('target', true).id),
+	*             kick: (options) => this.event.guild?.members.kick(options.getUser('member', true).id)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		const route = slashRouteOf(this.event);
+		const arm = arms[route];
+		if (!arm) throw new SeedcordError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
+		return await arm(this.options);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.ts
+/**
+* Base class for a context-menu command handler (right-click a user or a message).
+*
+* Pass the kind from `discord.js`'s {@link ApplicationCommandType} as the generic, the same value as
+* `@ContextMenuRoute`. Read the right-clicked entity from `this.target`, a `User` for a user menu and a
+* `Message` for a message menu. Context menus carry no options, so a handler registered for several names
+* reads `this.target` uniformly with no per-name branch.
+*
+* @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@ContextMenuRoute(ApplicationCommandType.Message, 'Report Message')
+* class ReportMessage extends ContextMenuHandler<ApplicationCommandType.Message> {
+*     async execute() {
+*         const message = this.target;
+*     }
+* }
+* ```
+*/
+var ContextMenuHandler = class extends InteractionHandler {
+	get target() {
+		const event = this.event;
+		return "targetUser" in event ? event.targetUser : event.targetMessage;
+	}
+	/**
+	* The invoking guild member, resolved only on user menus. Reading it on a message menu is a compile
+	* error since the type is `never` there.
+	*/
+	get targetMember() {
+		return this.event.targetMember;
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.ts
+/**
+* Base class for a Discord autocomplete handler.
+*
+* Pass the command route(s) from the generated registry as the generic, the same string(s) as
+* `@AutocompleteRoute`. Branch on the focused field with `this.match`, read already-entered sibling options
+* with `this.options`, and find which command fired with `this.route`.
+*
+* @typeParam Route - One or more route keys from {@link SlashOptionRegistry}, e.g. `'search'` or `'search' | 'find'`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@AutocompleteRoute('search')
+* class SearchAutocomplete extends AutocompleteHandler<'search'> {
+*     async execute() {
+*         await this.match({
+*             query: (value, respond) => respond([{ name: value, value }])
+*         });
+*     }
+* }
+* ```
+*/
+var AutocompleteHandler = class extends BaseHandler {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch);
+	}
+	/**
+	* The focused option for this interaction. `value` is always the raw partial string the user is typing,
+	* even for an integer or number option, so coerce it yourself when you need a number.
+	*/
+	decodedFocused;
+	get focused() {
+		if (this.decodedFocused) return this.decodedFocused;
+		const raw = this.event.options.getFocused(true);
+		const focused = {
+			name: raw.name,
+			value: raw.value
+		};
+		this.decodedFocused = focused;
+		return focused;
+	}
+	/**
+	* Run the arm for the focused field. An autocomplete always dispatches by which field is focused, so
+	* match is how you read it. There is no single-field shortcut the way slash/component handlers have one.
+	*
+	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
+	* arm receives the focused partial value and a `respond` pinned to that field's choice value type. The
+	* arms must cover every autocompletable field, a missing field or an unknown key is a compile error. A
+	* focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
+	*
+	* @param arms - One handler per autocompletable field, keyed by field name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@AutocompleteRoute('search')
+	* class SearchAutocomplete extends AutocompleteHandler<'search'> {
+	*     async execute() {
+	*         await this.match({
+	*             query: (value, respond) => respond(titles(value).map((s) => ({ name: s, value: s }))),
+	*             tag: (value, respond) => respond(tags(value).map((s) => ({ name: s, value: s })))
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		const { name, value } = this.focused;
+		const respond = (choices) => this.event.respond(choices);
+		const arm = arms[name];
+		if (!arm) throw new SeedcordError(SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
+		return await arm(value, respond);
+	}
+	/** The firing command route, for a field whose completion differs per registered command. */
+	get route() {
+		return slashRouteOf(this.event);
+	}
+	/**
+	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
+	* (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
+	* types the focused field. Read the focused field from `this.focused`, not here.
+	*/
+	get options() {
+		return this.event.options;
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/components/ComponentHandler.ts
+/**
+* Shared base the customId-routed component handlers extend.
+*
+* Not a public entry point. You should be using {@link ButtonHandler}, {@link SelectMenuHandler}, or
+* {@link ModalHandler} instead. This class only carries the customId decode and route-matching plumbing
+* those bases share, so DO NOT use it directly.
+*
+* @typeParam Event - The component interaction type this handler processes
+* @typeParam Defs - The customId route definitions registered on the concrete handler
+*/
+var ComponentHandler = class extends InteractionHandler {
+	get registeredDefs() {
+		const defs = Reflect.getMetadata(ComponentDefsKey, this.constructor);
+		if (!defs) throw new SeedcordError(SeedcordErrorCode.CustomIdHandlerRouteMissing, [this.constructor.name]);
+		return defs;
+	}
+	decoded;
+	get route() {
+		if (this.decoded) return this.decoded;
+		const decoded = decodeFor(this.registeredDefs, this.event.customId);
+		this.decoded = decoded;
+		return decoded;
+	}
+	/**
+	* The decoded params of the single route this handler is registered for.
+	*
+	* Reading this decodes `this.event.customId` once (cached after the first read) and throws
+	* `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
+	* controller boundary turns into a reply. On a handler registered for several routes this is
+	* `never`, so use {@link match} instead.
+	*/
+	get params() {
+		return this.route.params;
+	}
+	/**
+	* Run the arm for whichever route the component was minted from. Use this only when the handler is
+	* registered for several routes. A single-route handler reads `this.params` directly. On a multi-route
+	* handler `this.params` is `never`, so match is the only way to read the decoded params.
+	*
+	* Provide one arm per registered route, keyed by its prefix, and each arm receives that route's own
+	* decoded params. The arms must cover every registered def, a missing prefix or an unknown key is a
+	* compile error. Decoding runs before any arm, so a stale or corrupt wire throws before an arm body executes.
+	*
+	* @param arms - One handler per registered route, keyed by prefix.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@ButtonRoute(Approve, Reject)
+	* class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
+	*     async execute() {
+	*         await this.match({
+	*             approve: ({ userId }) => this.event.reply(`approved <@${userId}>`),
+	*             reject: ({ userId }) => this.event.reply(`rejected <@${userId}>`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		const { prefix, params } = this.route;
+		const arm = arms[prefix];
+		if (!arm) throw new SeedcordError(SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
+		return await arm(params);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/components/ButtonHandler.ts
+/**
+* Base class for a button interaction handler.
+*
+* Register the customId definitions this handler decodes with `@ButtonRoute`, list the same ones in the
+* generic, then read `this.params` for a single route or `this.match` for several. Passing different
+* definitions to the decorator and the generic is a compile error.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@ButtonRoute(ApproveId)
+* class ApproveButton extends ButtonHandler<[typeof ApproveId]> {
+*     async execute() {
+*         const { userId } = this.params;
+*         await this.event.reply(`approved <@${userId}>`);
+*     }
+* }
+* ```
+*/
+var ButtonHandler = class extends ComponentHandler {};
+
+//#endregion
+//#region src/handlers/interaction/components/ModalHandler.ts
+/**
+* Base class for a modal submit handler.
+*
+* Register the customId definitions this handler decodes with `@ModalRoute`, list the same ones in the
+* generic, then read `this.params` for a single route or `this.match` for several. Read the submitted
+* inputs from `this.event.fields`.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@ModalRoute(ConfigId)
+* class ConfigModal extends ModalHandler<[typeof ConfigId]> {
+*     async execute() {
+*         const { guildId } = this.params;
+*         const name = this.event.fields.getTextInputValue('name');
+*         await this.event.reply(`saved ${name} for ${guildId}`);
+*     }
+* }
+* ```
+*/
+var ModalHandler = class extends ComponentHandler {};
+
+//#endregion
+//#region src/handlers/interaction/components/SelectMenuHandler.ts
+/**
+* Base class for a select menu handler.
+*
+* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
+* so `this.event` and `this.event.values` are narrowed to that kind. Read `this.params` for a single
+* route or `this.match` for several.
+*
+* @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+* @typeParam Cache - The interaction cache state, `'cached'` by default.
+*
+* @example
+* ```ts
+* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
+* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {
+*     async execute() {
+*         const { roleId } = this.params;
+*         await this.event.reply(`assigning ${this.event.values.length} member(s) to <@&${roleId}>`);
+*     }
+* }
+* ```
+*/
+var SelectMenuHandler = class extends ComponentHandler {};
+
+//#endregion
+//#region src/handlers/event/EventHandler.ts
+/**
+* Base class for a Discord client event handler.
+*
+* Pass the event name(s) as the generic, the same one(s) as `@RegisterEvent`. A single-event handler reads
+* `this.event` (the payload tuple) directly. A handler registered for several events branches with `this.match`,
+* keyed by event name, since the union of payload tuples is not directly readable.
+*
+* @typeParam Names - One or more `ClientEvents` keys, e.g. `Events.MessageCreate` or `Events.MessageCreate | Events.MessageUpdate`.
+*
+* @example
+* ```ts
+* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+* class PingPong extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+*     async execute() {
+*         await this.match({
+*             [Events.MessageCreate]: (message) => message.reply('pong'),
+*             [Events.MessageUpdate]: (_oldMessage, edited) => edited.reply('pong')
+*         });
+*     }
+* }
+* ```
+*/
+var EventHandler = class extends BaseHandler {
+	firedEvent;
+	constructor(event, core, eventName) {
+		super(event, core);
+		this.firedEvent = eventName;
+	}
+	/**
+	* Run the arm for whichever event fired. Use this only when the handler is registered for several
+	* events. A single-event handler reads `this.event` directly. On a multi-event handler `this.event` is
+	* `never`, so match is the only way to read the payload.
+	*
+	* Provide one arm per registered event, keyed by its name, and each arm receives that event's own
+	* payload tuple. The arms must cover every event in the generic, a missing event or an unknown key is a
+	* compile error.
+	*
+	* @param arms - One handler per registered event, keyed by event name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@RegisterEvent([Events.MessageCreate], [Events.MessageUpdate])
+	* class MessageWatcher extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+	*     async execute() {
+	*         await this.match({
+	*             [Events.MessageCreate]: (message) => this.scan(message),
+	*             [Events.MessageUpdate]: (_old, updated) => this.scan(updated)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		const name = this.firedEvent;
+		if (name === void 0) throw new SeedcordError(SeedcordErrorCode.EventMatchArmMissing, ["<no event>"]);
+		const arm = arms[name];
+		if (typeof arm !== "function") throw new SeedcordError(SeedcordErrorCode.EventMatchArmMissing, [name]);
+		return await arm(...this.getEvent());
+	}
+};
+
+//#endregion
+//#region src/handlers/event/EventMiddleware.ts
+/**
+* Base class for Discord event middleware.
+*
+* Middleware runs before event handlers and can stop the event by throwing a `Silence`. Unlike `EventHandler`, it
+* runs the SAME for every event it is registered for, so it has no `match`. Specify a single event in the
+* generic and `{ events }` to read `this.event` fully typed. Span several events (or omit `{ events }` for a
+* catchall) and `this.event` narrows to `never`, read `this.eventName` and do work that does not depend on the
+* payload shape. A middleware that needs each event's payload is written one event per class.
+*
+* @typeParam EventName - One or more `ClientEvents` keys. Defaults to every event (catchall).
+*/
+var EventMiddleware = class extends BaseHandler {
+	firedEvent;
+	constructor(event, core, eventName) {
+		super(event, core);
+		this.firedEvent = eventName;
+	}
+	/**
+	* The event that fired this middleware. Read it on a catchall or multi-event middleware, where `this.event`
+	* is `never`, to do work that does not depend on the payload shape. A single-event middleware reads
+	* `this.event` directly and does not need this.
+	*/
+	get eventName() {
+		if (this.firedEvent === void 0) throw new SeedcordError(SeedcordErrorCode.EventMiddlewareNameUnavailable);
+		return this.firedEvent;
+	}
+};
+
+//#endregion
+//#region src/pagination/controls.ts
+const DEFAULT_LABEL = {
+	first: "First",
+	prev: "Prev",
+	indicator: "",
+	next: "Next",
+	last: "Last"
+};
+const CONTROL_SLOT = {
+	first: 0,
+	prev: 1,
+	indicator: 2,
+	next: 3,
+	last: 4
+};
+const MAX_BUTTONS_PER_ROW = 5;
+var Controls = class {
+	cursor;
+	view;
+	constructor(cursor, view) {
+		this.cursor = cursor;
+		this.view = view;
+	}
+	button(key, cosmetics) {
+		const { target, disabled } = this.navState(key);
+		const defaultLabel = key === "indicator" ? this.indicatorText() : DEFAULT_LABEL[key];
+		const label = cosmetics?.label ?? (key === "indicator" || !cosmetics?.emoji ? defaultLabel : void 0);
+		const button = new ButtonBuilder().setCustomId(this.cursor.encode({
+			page: Math.min(Math.max(0, target), PAGE_MAX),
+			slot: CONTROL_SLOT[key]
+		})).setStyle(cosmetics?.style ?? ButtonStyle.Secondary).setDisabled(disabled);
+		if (label !== void 0) button.setLabel(label);
+		if (cosmetics?.emoji) button.setEmoji(cosmetics.emoji);
+		return button;
+	}
+	navState(key) {
+		const { page, totalPages, hasPrev, hasNext } = this.view;
+		const knownTotal = totalPages !== void 0;
+		return {
+			target: {
+				first: 0,
+				prev: page - 1,
+				indicator: page,
+				next: page + 1,
+				last: knownTotal ? totalPages - 1 : page
+			}[key],
+			disabled: {
+				first: !hasPrev,
+				prev: !hasPrev,
+				indicator: true,
+				next: !hasNext || page + 1 > PAGE_MAX,
+				last: !hasNext || !knownTotal || totalPages - 1 > PAGE_MAX
+			}[key]
+		};
+	}
+	row(...keys) {
+		if (keys.length === 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationEmptyControls);
+		if (keys.length > MAX_BUTTONS_PER_ROW) throw new SeedcordRangeError(SeedcordErrorCode.PaginationTooManyControls, [keys.length]);
+		const seen = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			if (seen.has(key)) throw new SeedcordTypeError(SeedcordErrorCode.PaginationDuplicateControls, [key]);
+			seen.add(key);
+		}
+		return new ActionRowBuilder().addComponents(keys.map((key) => this.button(key)));
+	}
+	indicatorText() {
+		const { page, totalPages } = this.view;
+		return totalPages === void 0 ? `Page ${page + 1}` : `Page ${page + 1} of ${totalPages}`;
+	}
+};
+
+//#endregion
+//#region src/pagination/render.ts
+var PageContainer = class extends BuilderComponent {
+	constructor(view, renderItem, controlRow) {
+		super("container");
+		const base = view.page * view.perPage;
+		let lines = [];
+		const flush = () => {
+			if (lines.length === 0) return;
+			this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(lines.join("\n")));
+			lines = [];
+		};
+		view.items.forEach((item, offset) => {
+			const rendered = renderItem(item, base + offset);
+			if (typeof rendered === "string") {
+				lines.push(rendered);
+				return;
+			}
+			flush();
+			this.instance.addSectionComponents(rendered.component);
+		});
+		flush();
+		this.instance.addActionRowComponents(controlRow);
+	}
+};
+function toReplyResponse(renderable) {
+	if (typeof renderable === "string") return { components: [new TextDisplayBuilder().setContent(renderable)] };
+	if (Array.isArray(renderable)) return { components: renderable };
+	return renderable;
+}
+const ARRAY_KEYS = [
+	"first",
+	"prev",
+	"indicator",
+	"next",
+	"last"
+];
+const CURSOR_KEYS = [
+	"prev",
+	"indicator",
+	"next"
+];
+/**
+* Build a page's V2 reply. A `render` override builds the whole tree, otherwise the default container lists
+* the items and appends the controls (all five for a known total, prev/indicator/next for a cursor source).
+*/
+function renderPage(view, cursor, config) {
+	const controls = new Controls(cursor, view);
+	if (config.render) return toReplyResponse(config.render(view, controls));
+	return { components: [new PageContainer(view, config.renderItem ?? String, controls.row(...view.totalPages === void 0 ? CURSOR_KEYS : ARRAY_KEYS)).component] };
+}
+
+//#endregion
+//#region src/pagination/Paginator.ts
+function contextOf(interaction, core) {
+	return {
+		interaction,
+		user: interaction.user,
+		guild: interaction.guild,
+		...core && { core }
+	};
+}
+/**
+* A restart-proof paginator. Each nav button's customId encodes its full target page, so clicks are
+* idempotent and survive a restart. A persistent `@ButtonRoute` on `Handler` dispatches the clicks.
+*
+* @typeParam Item - The item type, inferred from the source.
+* @typeParam Prefix - The route prefix, inferred from `config.prefix`.
+*
+* @example
+* ```ts
+* export const Bans = new Paginator({
+*     prefix: 'bans',
+*     source: new ArraySource((ctx) => ctx.guild.bans.fetch().then((b) => [...b.values()]), { perPage: 10 }),
+*     renderItem: (ban) => ban.user.tag
+* });
+*
+* \@ButtonRoute(Bans.cursor)
+* export class BansNav extends Bans.Handler {}
+* ```
+*/
+var Paginator = class {
+	/** The page cursor, pass it to your `@ButtonRoute`. */
+	cursor;
+	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
+	Handler;
+	config;
+	constructor(config) {
+		this.cursor = pageCursor(config.prefix);
+		this.config = config;
+		const loadPage = (ctx, n) => this.page(ctx, n);
+		this.Handler = class Nav extends ButtonHandler {
+			async execute() {
+				await this.event.deferUpdate();
+				const response = await loadPage(contextOf(this.event, this.core), this.params.page);
+				await new ReplySender(this.event).edit(this.event.message, response);
+			}
+		};
+	}
+	/** Render page 0 and send it, picking reply or followUp from the interaction's state. */
+	async start(interaction, core) {
+		const response = await this.page(contextOf(interaction, core), 0);
+		return new ReplySender(interaction).send(response, this.config.ephemeral ?? false);
+	}
+	/** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
+	async page(ctx, n) {
+		return renderPage(await this.config.source.page(ctx, n), this.cursor, this.config);
+	}
+};
+
+//#endregion
+//#region src/pagination/sources.ts
+const DEFAULT_PER_PAGE = 10;
+/**
+* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
+* page via {@link paginate}, so the real total is known (a real last button, "Page X of Y"). Cache inside
+* your loader if the load is expensive.
+*
+* @typeParam Item - The item type, inferred from the loader's return.
+*/
+var ArraySource = class {
+	load;
+	perPage;
+	constructor(load, opts) {
+		this.load = load;
+		this.perPage = opts?.perPage ?? DEFAULT_PER_PAGE;
+		if (!Number.isSafeInteger(this.perPage) || this.perPage <= 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationInvalidPerPage, [this.perPage]);
+	}
+	async page(ctx, n) {
+		return paginate(await this.load(ctx), n, this.perPage);
+	}
+};
+/**
+* A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
+* The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
+* source has no cheap total, so `totalPages` is undefined, the last button is omitted, and the indicator
+* reads "Page X".
+*
+* @typeParam Item - The item type, inferred from the fetcher's slice.
+*/
+var CursorSource = class {
+	fetch;
+	perPage;
+	constructor(fetch, opts) {
+		this.fetch = fetch;
+		this.perPage = opts?.perPage ?? DEFAULT_PER_PAGE;
+		if (!Number.isSafeInteger(this.perPage) || this.perPage <= 0) throw new SeedcordRangeError(SeedcordErrorCode.PaginationInvalidPerPage, [this.perPage]);
+	}
+	async page(ctx, n) {
+		const page = Math.max(0, Math.trunc(n));
+		const { items, hasNext } = await this.fetch(ctx, page, this.perPage);
+		return {
+			items: [...items],
+			page,
+			perPage: this.perPage,
+			hasPrev: page > 0,
+			hasNext
+		};
+	}
+};
+
+//#endregion
+//#region src/subscribers/Subscriber.ts
+/**
+* Abstract base class for handling application subscribers.
+*
+* Provides type-safe access to subscribers data and the core framework instance.
+* Extend this class to create custom subscriber handlers.
+*
+* @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+*/
+var Subscriber = class {
+	data;
+	core;
+	logger;
+	/**
+	* Instantiates the subscriber with event data and core.
+	*
+	* @param data - The subscriber event data
+	* @param core - The core framework instance
+	*/
+	constructor(data, core) {
+		this.data = data;
+		this.core = core;
+		this.logger = new Logger(this.constructor.name);
+	}
+};
+
+//#endregion
+//#region src/subscribers/decorators/Subscribe.ts
+/**
+* Registers a subscriber handler class with a specific subscriber event.
+*
+* Associates the decorated class with a subscriber event type for automatic
+* registration and execution when the subscriber is emitted.
+*
+* @typeParam TSubscriber - The subscriber event name to register for
+* @param subscriber - The subscriber event name to register for
+* @param options - Options to configure the subscriber handler registration.
+* @decorator
+* @example
+* ```typescript
+* \@Subscribe('userJoin')
+* class WelcomeHandler extends Subscriber<'userJoin'> {
+*   async execute() {
+*     // Handle user join event
+*   }
+* }
+* ```
+* @example
+* ```ts
+* \@Subscribe('userJoin', { frequency: 'once' })
+* // or
+* \@Subscribe('userJoin')
+* ```
+*/
+function Subscribe(subscriber, options) {
+	return function(constructor) {
+		const meta = {
+			subscriber,
+			frequency: options?.frequency
+		};
+		Reflect.defineMetadata(SubscribeMetadataKey, meta, constructor);
+	};
+}
+
+//#endregion
+//#region src/subscribers/bases/WebhookLog.ts
+/**
+* Abstract webhook logging handler for subscriber events.
+*
+* Extends Subscriber to provide webhook-based logging capabilities.
+* Implementations must define the webhook client to send messages to by implementing the webhook property.
+*
+* @typeParam KeyOfSubscribers - The specific subscriber type this handler processes
+*/
+var WebhookLog = class extends Subscriber {
+	constructor(data, core) {
+		super(data, core);
+	}
+};
+
+//#endregion
+//#region src/hmr/HmrModuleHandler.ts
+/**
+* Reloads THandler and optional TMiddleware modules on HMR updates.
+*
+* You can either implement a custom `onHmr()` method in your class by extending `HmrAware`, or if it's a plugin, override the existing `onHmr()` with fully custom logic. Or, use this class's `handle()` method inside your `onHmr()` to get standard HMR handling for your modules based on the provided options you give to the constructor.
+*
+* This is only useful during development.
+*/
+var HmrModuleHandler = class {
+	store;
+	options;
+	constructor(options) {
+		this.options = {
+			...options,
+			logger: options.logger.inChannel("hmr")
+		};
+		this.store = {
+			fileToHandlers: /* @__PURE__ */ new Map(),
+			fileToMiddlewares: /* @__PURE__ */ new Map(),
+			handlerArtifacts: /* @__PURE__ */ new Map()
+		};
+	}
+	/**
+	* Handles an HMR update event by reloading affected modules based on the event details and config. It receives an {@link HmrUpdateEvent}, then checks the type of update.
+	*
+	* - If it's a deletion, it unloads the module.
+	* - If it's an update/creation, it checks if the file is tracked, unloads it if so, then reloads the file if it is in the handlers or middlewares directory and is a valid handler/middleware.
+	*/
+	async handle(event) {
+		const { file, affectedModules, type } = event;
+		const { logger, handlersDir, middlewaresDir } = this.options;
+		if (type === "delete" || type === "deleteDir") {
+			this.unload(file);
+			return;
+		}
+		if (type === "update" && !existsSync(file)) {
+			if (this.isTracked(file)) {
+				logger.info(`Received update for non-existent file: ${formatFilePath(file)}, treating as delete`);
+				this.unload(file);
+			}
+			return;
+		}
+		const rollbackEnabled = event.rollback ?? true;
+		const filesToReload = affectedModules && affectedModules.length > 0 ? affectedModules : [file];
+		const absHandlersDir = resolve(process.cwd(), handlersDir);
+		const absMiddlewaresDir = middlewaresDir ? resolve(process.cwd(), middlewaresDir) : null;
+		for (const fileToReload of filesToReload) {
+			const isHandler = fileToReload.startsWith(absHandlersDir);
+			const isMiddleware = absMiddlewaresDir ? fileToReload.startsWith(absMiddlewaresDir) : false;
+			if (!isHandler && !isMiddleware) continue;
+			await this.reloadWithRollback(fileToReload, rollbackEnabled);
+		}
+	}
+	async reloadWithRollback(file, rollbackEnabled) {
+		const { logger } = this.options;
+		const snapshot = this.snapshotUnits(file);
+		this.unload(file);
+		if (await this.reloadFile(file)) return;
+		this.unload(file);
+		if (!rollbackEnabled) return;
+		this.restoreUnits(file, snapshot);
+		logger.warn(`${chalk.yellow.bold("Rolled back")} ${chalk.gray(formatFilePath(file))} to the last-good version`);
+	}
+	/**
+	* Tracks a handler module as being loaded from a specific file.
+	* @param file - The file path the handler was loaded from.
+	* @param handler - The handler module instance.
+	*/
+	trackHandler(file, handler) {
+		let set = this.store.fileToHandlers.get(file);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.store.fileToHandlers.set(file, set);
+		}
+		set.add(handler);
+		if (this.options.getArtifacts) {
+			const artifacts = this.options.getArtifacts(handler);
+			this.store.handlerArtifacts.set(handler, artifacts);
+		}
+	}
+	/**
+	* Tracks a middleware module as being loaded from a specific file.
+	* @param file - The file path the middleware was loaded from.
+	* @param middleware - The middleware module instance.
+	*/
+	trackMiddleware(file, middleware) {
+		let set = this.store.fileToMiddlewares.get(file);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.store.fileToMiddlewares.set(file, set);
+		}
+		set.add(middleware);
+	}
+	isTracked(file) {
+		return this.store.fileToHandlers.has(file) || this.store.fileToMiddlewares.has(file);
+	}
+	unload(file) {
+		const { logger } = this.options;
+		const handlers = this.store.fileToHandlers.get(file);
+		if (handlers) {
+			for (const handler of handlers) {
+				const artifacts = this.store.handlerArtifacts.get(handler);
+				this.options.unregisterHandler(handler, artifacts);
+				this.store.handlerArtifacts.delete(handler);
+				const name = handler.name ?? "Handler";
+				logger.info(`${chalk.red.bold("Unloaded")} ${chalk.cyan.bold(name)} from ${chalk.gray(formatFilePath(file))}`);
+			}
+			this.store.fileToHandlers.delete(file);
+		}
+		const middlewares = this.store.fileToMiddlewares.get(file);
+		if (middlewares) {
+			for (const middleware of middlewares) {
+				this.options.unregisterMiddleware?.(middleware);
+				const name = middleware.name ?? "Middleware";
+				logger.info(`${chalk.red.bold("Unloaded")} ${chalk.cyan.bold(name)} from ${chalk.gray(formatFilePath(file))}`);
+			}
+			this.store.fileToMiddlewares.delete(file);
+		}
+	}
+	async reloadFile(file) {
+		const { logger, isHandler, isMiddleware, registerHandler, registerMiddleware } = this.options;
+		if (!existsSync(file)) {
+			logger.info(`File does not exist, skipping reload: ${formatFilePath(file)}`);
+			return false;
+		}
+		try {
+			let fileUrl = pathToFileURL(file).href;
+			if (process.env.VITEST === "true") fileUrl += `?update=${Date.now()}`;
+			const imported = await import(fileUrl);
+			for (const val of Object.values(imported)) if (isHandler(val)) {
+				registerHandler(val, file);
+				this.trackHandler(file, val);
+				const name = val.name ?? "Handler";
+				logger.info(`${chalk.blue.bold("Reloaded")} ${chalk.cyan.bold(name)} from ${chalk.gray(formatFilePath(file))}`);
+			} else if (isMiddleware && registerMiddleware && isMiddleware(val)) {
+				registerMiddleware(val, file);
+				this.trackMiddleware(file, val);
+				const name = val.name ?? "Middleware";
+				logger.info(`${chalk.blue.bold("Reloaded")} ${chalk.cyan.bold(name)} from ${chalk.gray(formatFilePath(file))}`);
+			}
+			return true;
+		} catch (error) {
+			logger.error(`Failed to reload file: ${file}`, error);
+			return false;
+		}
+	}
+	snapshotUnits(file) {
+		return {
+			handlers: [...this.store.fileToHandlers.get(file) ?? []],
+			middlewares: [...this.store.fileToMiddlewares.get(file) ?? []]
+		};
+	}
+	restoreUnits(file, snapshot) {
+		for (const handler of snapshot.handlers) {
+			this.options.registerHandler(handler, file);
+			this.trackHandler(file, handler);
+		}
+		if (this.options.registerMiddleware) for (const middleware of snapshot.middlewares) {
+			this.options.registerMiddleware(middleware, file);
+			this.trackMiddleware(file, middleware);
+		}
+	}
+};
+
+//#endregion
+//#region src/bot/utilities/miscellaneous/contextMenuLeaves.ts
+/**
+* Collects the names of every registered context-menu command across a set of command builders, split into a
+* user set and a message set. The same builder may appear more than once (a guild command is pushed once per
+* guild), and slash commands carry no context-menu name, so both collapse here. The split mirrors the
+* controller's two name-keyed maps, so the boot guard checks each name against its own kind.
+*
+* @internal
+*/
+function contextMenuLeaves(commands) {
+	const user = /* @__PURE__ */ new Set();
+	const message = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		if (!(command instanceof ContextMenuCommandBuilder)) continue;
+		if (command.type === ApplicationCommandType.User) user.add(command.name);
+		else message.add(command.name);
+	}
+	return {
+		user,
+		message
+	};
+}
+
+//#endregion
+//#region src/bot/utilities/miscellaneous/slashRouteLeaves.ts
+/**
+* Collects the route keys of every executable slash leaf across a set of command builders, deduplicated. The
+* same builder may appear more than once (a guild command is pushed once per guild), and context-menu
+* commands carry no slash route, so both collapse here. Route keys come from the same {@link routeLeavesOf}
+* that `seedcord codegen` reads, so the boot-time check compares against the generated registry's keys.
+*
+* @internal
+*/
+function slashRouteLeaves(commands) {
+	const leaves = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		if (!(command instanceof SlashCommandBuilder)) continue;
+		for (const leaf of routeLeavesOf(command.toJSON())) leaves.add(leaf.route);
+	}
+	return leaves;
+}
+
+//#endregion
+//#region src/bot/controllers/CommandRegistry.ts
+/**
+* Manages Discord application command registration and deployment.
+*
+* Scans command directories, builds command structures, and registers both global and guild-scoped commands
+* to Discord's API. Accessed via `core.bot.commands`. Do not construct it directly.
+*/
+var CommandRegistry = class {
+	core;
+	onDeployed;
+	name = "Commands";
+	logger = new Logger("Commands");
+	isInitialised = false;
+	globalCommands = [];
+	guildCommands = new Collection();
+	ctorToCommand = /* @__PURE__ */ new Map();
+	hmrHandler;
+	pendingEvents = /* @__PURE__ */ new Map();
+	constructor(core, onDeployed) {
+		this.core = core;
+		this.onDeployed = onDeployed;
+		const commandsDir = this.core.config.bot.commands.path;
+		if (!commandsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["CommandRegistry", "commands"]);
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: commandsDir,
+			isHandler: this.isCommandClass.bind(this),
+			registerHandler: this.registerCommand.bind(this),
+			unregisterHandler: this.unregisterCommand.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: this.logger
+		});
+	}
+	getArtifacts(ctor) {
+		return this.ctorToCommand.get(ctor);
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialised) return;
+		this.isInitialised = true;
+		const commandsDir = this.core.config.bot.commands.path;
+		if (!commandsDir) return;
+		this.logger.info(chalk.bold(commandsDir));
+		await this.loadCommands(commandsDir);
+		this.logger.utils.summary("Loaded commands", {
+			global: this.globalCommands.length,
+			"guild groups": this.guildCommands.size
+		});
+		getDevChannel()?.on("seedcord:refresh-commands", (data) => {
+			this.refresh(data.shouldRefresh);
+		});
+	}
+	/** @internal */
+	async refresh(shouldRefresh = true) {
+		if (!shouldRefresh) {
+			this.logger.info(chalk.italic("Command refresh cancelled."));
+			this.pendingEvents.clear();
+			return;
+		}
+		this.logger.info(chalk.italic("Refreshing commands..."));
+		for (const event of this.pendingEvents.values()) await this.hmrHandler?.handle(event);
+		this.pendingEvents.clear();
+		await this.setCommands();
+	}
+	/** @internal */
+	async onHmr(event) {
+		const commandsDir = this.core.config.bot.commands.path;
+		if (commandsDir && event.file.startsWith(resolve(process.cwd(), commandsDir))) {
+			this.pendingEvents.delete(event.file);
+			this.pendingEvents.set(event.file, event);
+			getDevChannel()?.send("seedcord:commands-update-prompt", { files: [...this.pendingEvents.keys()].map((f) => formatFilePath(f)) });
+		} else await this.hmrHandler?.handle(event);
+	}
+	async loadCommands(dir) {
+		await traverseDirectory(dir, (fullPath, rel, mod) => {
+			for (const exported of Object.values(mod)) if (this.isCommandClass(exported)) {
+				this.registerCommand(exported, rel);
+				this.hmrHandler?.trackHandler(fullPath, exported);
+			}
+		}, this.logger);
+	}
+	isCommandClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof BuilderComponent && Reflect.hasMetadata(CommandMetadataKey, obj);
+	}
+	registerCommand(ctor, rel) {
+		const meta = Reflect.getMetadata(CommandMetadataKey, ctor);
+		if (!meta) return;
+		const comp = new ctor().component;
+		const commandType = comp instanceof SlashCommandBuilder ? "slash command" : "context menu command";
+		if (meta.scope === "global") {
+			this.globalCommands.push(comp);
+			this.logger.utils.registration(ctor.name, rel);
+			this.logger.utils.item(`Global ${commandType}: ${chalk.bold.cyan(comp.name)}`);
+		} else {
+			for (const g of meta.guilds) {
+				const arr = this.guildCommands.get(g) ?? [];
+				arr.push(comp);
+				this.guildCommands.set(g, arr);
+			}
+			this.logger.utils.registration(ctor.name, rel);
+			this.logger.utils.item(`Guild ${commandType}: ${chalk.bold.cyan(comp.name)} for ${chalk.magenta.bold(meta.guilds.length)} guild(s)`);
+		}
+		this.ctorToCommand.set(ctor, {
+			name: comp.name,
+			scope: meta.scope,
+			...meta.scope === "guild" && { guilds: meta.guilds }
+		});
+	}
+	unregisterCommand(ctor, artifacts) {
+		const info = artifacts ?? this.ctorToCommand.get(ctor);
+		if (!info) return;
+		if (info.scope === "global") {
+			const idx = this.globalCommands.findIndex((c) => c.name === info.name);
+			if (idx !== -1) this.globalCommands.splice(idx, 1);
+		} else for (const g of info.guilds ?? []) {
+			const arr = this.guildCommands.get(g);
+			if (arr) {
+				const idx = arr.findIndex((c) => c.name === info.name);
+				if (idx !== -1) arr.splice(idx, 1);
+			}
+		}
+		this.ctorToCommand.delete(ctor);
+	}
+	/** @internal */
+	async setCommands() {
+		const result = {
+			global: new Collection(),
+			guilds: new Collection()
+		};
+		if (this.globalCommands.length > 0) {
+			const deployed = await this.core.bot.client.application?.commands.set(this.globalCommands);
+			if (deployed) result.global = deployed;
+			const tag = this.globalCommands.length === 1 ? "command" : "commands";
+			this.logger.utils.summary("Configured global", { [tag]: this.globalCommands.length });
+			this.logger.utils.item(`${this.globalCommands.map((command) => chalk.bold.cyan(command.name)).join(", ")}`);
+		}
+		for (const [guildId, commands] of this.guildCommands.entries()) {
+			const guild = this.core.bot.client.guilds.cache.get(guildId);
+			if (!guild) {
+				this.logger.warn(`Guild with ID ${guildId} not found, skipping command registration.`);
+				continue;
+			}
+			const deployed = await guild.commands.set(commands);
+			result.guilds.set(guildId, deployed);
+			const tag = commands.length === 1 ? "command" : "commands";
+			this.logger.utils.summary(`Configured commands for ${chalk.bold.yellow(guild.name)}`, { [tag]: commands.length });
+			this.logger.utils.item(`${commands.map((command) => chalk.bold.cyan(command.name)).join(", ")}`);
+		}
+		this.onDeployed?.(result);
+		return result;
+	}
+	/** The deduplicated slash route keys across every global and guild command. @internal */
+	routeLeaves() {
+		return slashRouteLeaves([...this.globalCommands, ...this.guildCommands.values()].flat());
+	}
+	/** The registered context-menu command names, split by kind, across every global and guild command. @internal */
+	contextMenuLeaves() {
+		return contextMenuLeaves([...this.globalCommands, ...this.guildCommands.values()].flat());
+	}
+};
+
+//#endregion
+//#region src/miscellaneous/deriveEventActor.ts
+function deriveEventActor(args) {
+	const tuple = Array.isArray(args) ? args : [args];
+	for (const arg of tuple) {
+		if (arg instanceof Message) return {
+			guild: arg.guild,
+			member: arg.member,
+			user: arg.author,
+			channelId: arg.channelId
+		};
+		if (arg instanceof GuildMember) return {
+			guild: arg.guild,
+			member: arg,
+			user: arg.user,
+			channelId: null
+		};
+		if (arg instanceof User) return {
+			guild: null,
+			member: null,
+			user: arg,
+			channelId: null
+		};
+	}
+	return {
+		guild: null,
+		member: null,
+		user: null,
+		channelId: null
+	};
+}
+
+//#endregion
+//#region src/bot/gates/runGates.ts
+function interactionGateContext(interaction, core) {
+	const rawMember = interaction.member;
+	const memberRoleIds = rawMember instanceof GuildMember ? [...rawMember.roles.cache.keys()].filter((id) => id !== interaction.guildId) : rawMember?.roles ?? [];
+	return {
+		kind: "interaction",
+		interaction,
+		core,
+		user: interaction.user,
+		guild: interaction.guild,
+		member: rawMember instanceof GuildMember ? rawMember : null,
+		userId: interaction.user.id,
+		guildId: interaction.guildId,
+		channelId: interaction.channelId,
+		memberRoleIds,
+		memberPermissions: interaction.memberPermissions?.bitfield ?? null,
+		routeId: null
+	};
+}
+function eventGateContext(eventName, args, core) {
+	const actor = deriveEventActor(args);
+	return {
+		kind: "event",
+		core,
+		eventName,
+		payload: args,
+		user: actor.user,
+		guild: actor.guild,
+		member: actor.member,
+		userId: actor.user?.id ?? null,
+		guildId: actor.guild?.id ?? null,
+		channelId: actor.channelId,
+		memberRoleIds: actor.member ? [...actor.member.roles.cache.keys()].filter((id) => id !== actor.guild?.id) : [],
+		memberPermissions: actor.member?.permissions.bitfield ?? null,
+		routeId: null
+	};
+}
+
+//#endregion
+//#region src/miscellaneous/FaultThrottle.ts
+/**
+* Drops duplicate fault reports inside a fixed window so a recurring fault (a database outage on a
+* hot path) reports once per window instead of flooding the webhook. Keyed on a structural string, so
+* the map stays small, and a stale entry is evicted on the next read of its key.
+*
+* @internal
+*/
+var FaultThrottle = class {
+	windowMs;
+	now;
+	lastReportedAt = /* @__PURE__ */ new Map();
+	constructor(windowMs = 6e4, now = () => Date.now()) {
+		this.windowMs = windowMs;
+		this.now = now;
+	}
+	/** Evicts the entry for this key if it has aged out, so the map never holds stale keys forever. */
+	shouldReport(key) {
+		const last = this.lastReportedAt.get(key);
+		if (last === void 0) return true;
+		if (this.now() - last < this.windowMs) return false;
+		this.lastReportedAt.delete(key);
+		return true;
+	}
+	markReported(key) {
+		this.lastReportedAt.set(key, this.now());
+	}
+	clear() {
+		this.lastReportedAt.clear();
+	}
+};
+
+//#endregion
+//#region src/miscellaneous/extractErrorResponse.ts
+const logger$2 = new Logger("ErrorsHandling");
+/**
+* The single throttle for every fault publish, so a recurring fault reports once per window across both
+* the interaction and event paths. Exported so tests reset it between cases.
+*
+* @internal
+*/
+const faultThrottle = new FaultThrottle();
+/**
+* Processes an error into a user-facing reply and routes its report.
+*
+* A {@link Notice} always renders its own reply. A reporting denial (`report: true`) additionally
+* publishes `handledException` on the interaction path. A raw, non-denial throw publishes
+* `unknownException` and renders the configured `defaultError` (or a generic {@link Fault}). One uuid is
+* threaded into both the reply and the bus payload.
+*
+* @internal
+*/
+function extractErrorResponse(error, core, origin) {
+	const uuid = crypto.randomUUID();
+	const developerUsername = core.config.notifications?.developerUsername;
+	const ctx = developerUsername === void 0 ? { uuid } : {
+		uuid,
+		developerUsername
+	};
+	if (error instanceof Notice) {
+		if (error.report) reportFault(error, core, origin, uuid);
+		return {
+			uuid,
+			response: error.render(ctx)
+		};
+	}
+	reportRawFault(error, core, origin, uuid);
+	const override = core.config.errors?.defaultError;
+	return {
+		uuid,
+		response: override ? new override(uuid).render(ctx) : new Fault().render(ctx)
+	};
+}
+function withThrottle(origin, error, publish) {
+	const key = faultKey(origin, error);
+	if (!faultThrottle.shouldReport(key)) {
+		logger$2.info(`throttled duplicate fault ${key}`);
+		return;
+	}
+	publish();
+	faultThrottle.markReported(key);
+}
+function reportFault(denial, core, origin, uuid) {
+	withThrottle(origin, denial, () => {
+		logger$2.error(`${denial.name}: ${uuid}`, denial);
+		if (origin.interaction) core.bus.publish("handledException", {
+			denial,
+			uuid,
+			source: buildInteractionSource(origin.interaction)
+		});
+		else if (origin.event) core.bus.publish("handledException", {
+			denial,
+			uuid,
+			source: buildEventSource(origin.event, origin)
+		});
+		else core.bus.publish("unknownException", {
+			uuid,
+			error: denial,
+			guild: origin.guild,
+			user: origin.user,
+			metadata: metadataFor(origin)
+		});
+	});
+}
+function reportRawFault(error, core, origin, uuid) {
+	withThrottle(origin, error, () => {
+		if (core.config.errors?.errorStack ?? false) logger$2.error(uuid, error);
+		else logger$2.error(`${uuid} | ${error.message}`);
+		core.bus.publish("unknownException", {
+			uuid,
+			error,
+			guild: origin.guild,
+			user: origin.user,
+			metadata: metadataFor(origin)
+		});
+	});
+}
+function metadataFor(origin) {
+	if (origin.event) return {
+		eventName: origin.event.name,
+		handler: origin.event.handler,
+		args: origin.event.args
+	};
+	return origin.metadata;
+}
+function buildEventSource(event, origin) {
+	return {
+		kind: "event",
+		eventName: event.name,
+		handler: event.handler,
+		userId: origin.user?.id ?? null,
+		guildId: origin.guild?.id ?? null,
+		channelId: event.channelId,
+		raw: event.args
+	};
+}
+function faultKey(origin, error) {
+	const name = error instanceof Notice ? error.name : error instanceof DiscordAPIError ? String(error.code) : error.constructor.name;
+	if (origin.event) return `${origin.event.name}:${origin.event.handler}:${name}`;
+	if (origin.interaction) return `${interactionRoute(origin.interaction)}:${name}`;
+	if (origin.route) return `autocomplete:${origin.route}:${name}`;
+	return `autocomplete:${name}`;
+}
+function interactionRoute(interaction) {
+	if (interaction.isChatInputCommand()) return slashRouteOf(interaction);
+	if (interaction.isContextMenuCommand()) return interaction.commandName;
+	if (interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit()) return prefixOf(interaction.customId) || interaction.customId;
+	return "interaction";
+}
+function buildInteractionSource(interaction) {
+	const command = interaction.isChatInputCommand() ? slashRouteOf(interaction) : interaction.isContextMenuCommand() ? interaction.commandName : null;
+	const customId = interaction.isButton() || interaction.isAnySelectMenu() || interaction.isModalSubmit() ? interaction.customId : null;
+	return {
+		kind: "interaction",
+		interactionKind: interactionKind(interaction),
+		command,
+		customId,
+		userId: interaction.user.id,
+		guildId: interaction.guildId,
+		channelId: interaction.channelId,
+		interactionId: interaction.id,
+		raw: interaction
+	};
+}
+function interactionKind(interaction) {
+	if (interaction.isChatInputCommand()) return "slash";
+	if (interaction.isContextMenuCommand()) return "context-menu";
+	if (interaction.isButton()) return "button";
+	if (interaction.isAnySelectMenu()) return "select";
+	return "modal";
+}
+
+//#endregion
+//#region src/bot/handleEventFault.ts
+const logger$1 = new Logger("EventBoundary");
+/**
+* The event controller boundary. Reports a throw from an event handler and never replies, since a
+* generic event has no reply target. A {@link Silence} or a non-reporting {@link Notice} stops quietly, a
+* reporting denial or a raw error publishes a fault with a best-effort actor derived from the args.
+*
+* @internal
+*/
+function handleEventFault(caught, eventName, handlerName, args, core) {
+	if (caught instanceof Silence) {
+		if (caught.reason !== void 0) logger$1.debug(`Silence: ${caught.reason}`);
+		return;
+	}
+	if (!Error.isError(caught)) throw caught;
+	const ignore = new Set(core.config.errors?.ignoreEventApiCodes ?? []);
+	if (caught instanceof DiscordAPIError && ignore.has(caught.code)) {
+		logger$1.debug(`swallowed api code ${caught.code}`);
+		return;
+	}
+	if (caught instanceof Notice && !caught.report) return;
+	const actor = deriveEventActor(args);
+	extractErrorResponse(caught, core, {
+		event: {
+			name: eventName,
+			handler: handlerName,
+			args,
+			channelId: actor.channelId
+		},
+		guild: actor.guild,
+		user: actor.user
+	});
+}
+
+//#endregion
+//#region src/bot/controllers/EventDispatcher.ts
+/**
+* Scans event handler directories, registers handlers with Discord client events,
+* and coordinates event execution through the handler system. Does not handle interactions.
+* Multiple handlers can point to one event.
+*
+* @internal
+*/
+var EventDispatcher = class {
+	core;
+	logger = new Logger("Events");
+	isInitialized = false;
+	name = "Events";
+	eventMap = /* @__PURE__ */ new Map();
+	middlewares = [];
+	executedOnceHandlers = /* @__PURE__ */ new Set();
+	attachedEvents = /* @__PURE__ */ new Set();
+	hmrHandler;
+	constructor(core) {
+		this.core = core;
+		const eventsDir = this.core.config.bot.events.path;
+		if (!eventsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["EventDispatcher", "events"]);
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: eventsDir,
+			...hasKeys(this.core.config.bot.events, ["middlewares"]) && { middlewaresDir: this.core.config.bot.events.middlewares },
+			isHandler: this.isEventHandlerClass.bind(this),
+			isMiddleware: this.isMiddlewareClass.bind(this),
+			registerHandler: this.registerHandler.bind(this),
+			registerMiddleware: this.registerMiddleware.bind(this),
+			unregisterHandler: this.unregisterHandler.bind(this),
+			unregisterMiddleware: this.unregisterMiddleware.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: this.logger
+		});
+	}
+	getArtifacts(ctor) {
+		const events = [];
+		for (const [event, handlers] of this.eventMap.entries()) if (handlers.some((h) => h.ctor === ctor)) events.push(event);
+		return events;
+	}
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		const handlersDir = this.core.config.bot.events.path;
+		if (!handlersDir) return;
+		this.logger.info(chalk.bold(handlersDir));
+		const middlewareDir = hasKeys(this.core.config.bot.events, ["middlewares"]) ? this.core.config.bot.events.middlewares : void 0;
+		if (middlewareDir) {
+			this.logger.info(`${chalk.bold(middlewareDir)} ${chalk.gray("(middlewares)")}`);
+			await this.loadMiddlewares(middlewareDir);
+		}
+		await this.loadHandlers(handlersDir);
+		this.attachToClient();
+		this.logger.info(`${chalk.bold.green("Loaded event handlers:")}`);
+		const eventList = [`${chalk.magenta.bold(this.middlewares.length)} middlewares`];
+		this.eventMap.forEach((handlers, eventName) => {
+			eventList.push(`${chalk.magenta.bold(handlers.length)} ${eventName}`);
+		});
+		this.logger.utils.list(eventList);
+	}
+	async loadHandlers(dir) {
+		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
+			for (const val of Object.values(imported)) {
+				if (!this.isEventHandlerClass(val)) continue;
+				this.registerHandler(val, relativePath);
+				this.hmrHandler?.trackHandler(fullPath, val);
+			}
+		}, this.logger);
+	}
+	async loadMiddlewares(dir) {
+		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
+			for (const val of Object.values(imported)) {
+				if (!this.isMiddlewareClass(val)) continue;
+				this.registerMiddleware(val, relativePath);
+				this.hmrHandler?.trackMiddleware(fullPath, val);
+			}
+		}, this.logger);
+	}
+	/** @internal For use in dev mode */
+	async onHmr(event) {
+		await this.hmrHandler?.handle(event);
+	}
+	unregisterHandler(handlerClass, artifacts) {
+		const events = artifacts ?? [...this.eventMap.keys()];
+		for (const event of events) {
+			const handlers = this.eventMap.get(event);
+			if (!handlers) continue;
+			const index = handlers.findIndex((h) => h.ctor === handlerClass);
+			if (index !== -1) {
+				handlers.splice(index, 1);
+				if (handlers.length === 0) this.eventMap.delete(event);
+			}
+		}
+	}
+	unregisterMiddleware(middlewareCtor) {
+		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
+		if (index !== -1) this.middlewares.splice(index, 1);
+	}
+	registerMiddleware(middlewareCtor, relativePath) {
+		const metadata = Reflect.getMetadata(MiddlewareMetadataKey, middlewareCtor);
+		if (metadata?.type !== "event") return;
+		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
+		this.middlewares.push({
+			ctor: middlewareCtor,
+			priority: metadata.priority,
+			...metadata.events && { events: metadata.events }
+		});
+		this.middlewares.sort((a, b) => a.priority - b.priority);
+		this.logger.utils.registration(`${middlewareCtor.name} ${chalk.gray(`(${metadata.priority})`)}`, relativePath, "event middleware");
+	}
+	async runMiddlewares(eventName, args) {
+		for (const { ctor, events } of this.middlewares) {
+			if (events && !events.includes(eventName)) continue;
+			try {
+				await new ctor(args, this.core, eventName).execute();
+			} catch (caught) {
+				handleEventFault(caught, String(eventName), ctor.name, args, this.core);
+				return false;
+			}
+		}
+		return true;
+	}
+	isEventHandlerClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof EventHandler && Reflect.hasMetadata(EventMetadataKey, obj);
+	}
+	isMiddlewareClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof EventMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+	}
+	registerHandler(handlerClass, relativePath) {
+		const raw = Reflect.getMetadata(EventMetadataKey, handlerClass);
+		const register = (key, frequency) => {
+			let handlers = this.eventMap.get(key);
+			if (!handlers) {
+				handlers = [];
+				this.eventMap.set(key, handlers);
+			}
+			handlers.push({
+				ctor: handlerClass,
+				frequency
+			});
+			if (this.isInitialized && !this.attachedEvents.has(key)) this.attachListener(key);
+		};
+		if (Array.isArray(raw)) for (const entry of raw) register(entry.event, entry.frequency);
+		else {
+			const names = areRoutes(raw) ? raw : typeof raw === "string" ? [raw] : [];
+			for (const name of names) register(name, "on");
+		}
+		this.logger.utils.registration(handlerClass.name, relativePath);
+	}
+	attachToClient() {
+		for (const [eventName] of this.eventMap) this.attachListener(eventName);
+	}
+	attachListener(eventName) {
+		if (this.attachedEvents.has(eventName)) return;
+		this.attachedEvents.add(eventName);
+		const handlerEntries = this.eventMap.get(eventName);
+		this.logger.debug(`Attaching ${chalk.bold.green(eventName)} to the client with ${chalk.gray(handlerEntries?.length ?? 0)} handler(s)`);
+		this.core.bot.client.on(eventName, (...args) => {
+			this.core.bot.emitSafe("any:event", eventName, ...args);
+			(async () => {
+				await this.processEvent(eventName, args).catch((err) => {
+					this.logger.error(`[${chalk.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+					this.core.bot.emit("error:unhandled:event", err);
+				});
+			})();
+		});
+	}
+	async processEvent(eventName, args) {
+		const handlerEntries = this.eventMap.get(eventName);
+		if (!handlerEntries || handlerEntries.length === 0) return;
+		const handlersToExecute = handlerEntries.filter((entry) => entry.frequency !== "once" || !this.executedOnceHandlers.has(entry.ctor));
+		if (handlersToExecute.length === 0) return;
+		if (!await this.runMiddlewares(eventName, args)) return;
+		for (const entry of handlersToExecute) {
+			if (entry.frequency === "once") {
+				if (this.executedOnceHandlers.has(entry.ctor)) continue;
+				this.executedOnceHandlers.add(entry.ctor);
+			}
+			await this.processHandler(eventName, entry.ctor, args);
+		}
+	}
+	async processHandler(eventName, ctor, args) {
+		try {
+			this.logger.debug(`Processing ${chalk.bold.green(eventName)} with ${chalk.gray(ctor.name)}`);
+			const handler = new ctor(args, this.core, eventName);
+			await runHandlerGates(ctor, eventGateContext(eventName, args, this.core));
+			await handler.execute();
+		} catch (caught) {
+			handleEventFault(caught, String(eventName), ctor.name, args, this.core);
+		}
+	}
+};
+
+//#endregion
+//#region src/bot/defaults/UnhandledEvent.ts
+/**
+* Default handler for unhandled interactions. A reply failure here rides the controller boundary as a
+* raw fault, so it needs no decorator of its own.
+*
+* @internal
+*/
+var UnhandledEvent = class extends InteractionHandler {
+	async execute() {
+		await this.event.reply({
+			content: `Feature not implemented yet.`,
+			flags: MessageFlags.Ephemeral
+		});
+	}
+};
+
+//#endregion
+//#region src/bot/handleInteractionFault.ts
+const logger = new Logger("InteractionBoundary");
+/**
+* The interaction controller boundary. Sorts a throw from any handler-lifecycle phase into the right
+* user reply plus the right bus event, building a {@link ReplySender} lazily so it reads the live
+* acknowledgement state at catch time.
+*
+* @internal
+*/
+async function handleInteractionFault(caught, interaction, core) {
+	if (caught instanceof Silence) {
+		if (caught.reason !== void 0) logger.debug(`Silence: ${caught.reason}`);
+		return;
+	}
+	if (!Error.isError(caught)) throw caught;
+	const ignore = new Set(core.config.errors?.ignoreApiCodes ?? []);
+	if (caught instanceof DiscordAPIError && ignore.has(caught.code)) {
+		logger.debug(`swallowed api code ${caught.code}`);
+		return;
+	}
+	if (interaction.isAutocomplete()) {
+		extractErrorResponse(caught, core, {
+			guild: interaction.guild,
+			user: interaction.user,
+			metadata: interaction,
+			route: slashRouteOf(interaction)
+		});
+		return;
+	}
+	const { response } = extractErrorResponse(caught, core, {
+		interaction,
+		guild: interaction.guild,
+		user: interaction.user,
+		metadata: interaction
+	});
+	await new ReplySender(interaction).send(response, caught instanceof Notice ? caught.ephemeral : true);
+}
+
+//#endregion
+//#region src/bot/controllers/InteractionDispatcher.ts
+/**
+* Scans handler directories, routes each interaction to its registered handler, and runs the handler.
+* One handler per interaction.
+*
+* @internal
+*/
+var InteractionDispatcher = class {
+	core;
+	logger = new Logger("Interactions");
+	isInitialized = false;
+	name = "Interactions";
+	slashMap = /* @__PURE__ */ new Map();
+	buttonMap = /* @__PURE__ */ new Map();
+	modalMap = /* @__PURE__ */ new Map();
+	stringSelectMap = /* @__PURE__ */ new Map();
+	userSelectMap = /* @__PURE__ */ new Map();
+	roleSelectMap = /* @__PURE__ */ new Map();
+	channelSelectMap = /* @__PURE__ */ new Map();
+	mentionableSelectMap = /* @__PURE__ */ new Map();
+	messageContextMenuMap = /* @__PURE__ */ new Map();
+	userContextMenuMap = /* @__PURE__ */ new Map();
+	autocompleteMap = /* @__PURE__ */ new Map();
+	keysToIgnore = /* @__PURE__ */ new Set();
+	middlewares = [];
+	hmrHandler;
+	routeTypes = [
+		[InteractionRoutes.Slash, this.slashMap],
+		[InteractionRoutes.Button, this.buttonMap],
+		[InteractionRoutes.Modal, this.modalMap],
+		[InteractionRoutes.StringMenu, this.stringSelectMap],
+		[InteractionRoutes.UserMenu, this.userSelectMap],
+		[InteractionRoutes.RoleMenu, this.roleSelectMap],
+		[InteractionRoutes.ChannelMenu, this.channelSelectMap],
+		[InteractionRoutes.MentionableMenu, this.mentionableSelectMap],
+		[InteractionRoutes.MessageContextMenu, this.messageContextMenuMap],
+		[InteractionRoutes.UserContextMenu, this.userContextMenuMap],
+		[InteractionRoutes.Autocomplete, this.autocompleteMap]
+	];
+	constructor(core) {
+		this.core = core;
+		const ignoredKeysFromConfig = hasKeys(this.core.config.bot.interactions, ["ignoreCustomIds"]) ? this.core.config.bot.interactions.ignoreCustomIds : void 0;
+		if (ignoredKeysFromConfig) for (const ignoredKey of ignoredKeysFromConfig) this.keysToIgnore.add(ignoredKey);
+		this.keysToIgnore.add(CONFIRM_DEF);
+		const interactionsDir = this.core.config.bot.interactions.path;
+		if (!interactionsDir) throw new SeedcordError(SeedcordErrorCode.CoreControllerPathMissing, ["InteractionDispatcher", "interactions"]);
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir: interactionsDir,
+			...hasKeys(this.core.config.bot.interactions, ["middlewares"]) && this.core.config.bot.interactions.middlewares && { middlewaresDir: this.core.config.bot.interactions.middlewares },
+			isHandler: this.isHandlerClass.bind(this),
+			isMiddleware: this.isMiddlewareClass.bind(this),
+			registerHandler: this.registerHandler.bind(this),
+			registerMiddleware: this.registerMiddleware.bind(this),
+			unregisterHandler: this.unregisterHandler.bind(this),
+			unregisterMiddleware: this.unregisterMiddleware.bind(this),
+			getArtifacts: this.getArtifacts.bind(this),
+			logger: this.logger
+		});
+	}
+	/**
+	* Warns for each command route with no registered `@SlashRoute` handler, which would fall through to
+	* UnhandledEvent at runtime. A bot may route commands outside the registry, so this does not throw.
+	*
+	* @internal
+	*/
+	warnUnhandledRoutes(commandLeaves) {
+		for (const route of commandLeaves) if (!this.slashMap.has(route)) this.logger.warn(`Slash route ${chalk.bold.cyan(route)} has no registered ${chalk.bold("@SlashRoute")} handler.`);
+	}
+	/**
+	* Warns for each context-menu command with no matching handler, which would fall through to UnhandledEvent
+	* at runtime. Checked per kind since a user and a message command can share a name.
+	*
+	* @internal
+	*/
+	warnUnhandledContextMenuRoutes(leaves) {
+		for (const name of leaves.user) if (!this.userContextMenuMap.has(name)) this.logger.warn(`User context menu ${chalk.bold.cyan(name)} has no registered ${chalk.bold("@ContextMenuRoute")} handler.`);
+		for (const name of leaves.message) if (!this.messageContextMenuMap.has(name)) this.logger.warn(`Message context menu ${chalk.bold.cyan(name)} has no registered ${chalk.bold("@ContextMenuRoute")} handler.`);
+	}
+	getArtifacts(handlerClass) {
+		const artifacts = [];
+		for (const [routeType] of this.routeTypes) {
+			const meta = Reflect.getMetadata(InteractionRouteKeys[routeType], handlerClass);
+			if (areRoutes(meta)) artifacts.push({
+				routeType,
+				routes: meta
+			});
+		}
+		return artifacts;
+	}
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		const handlersDir = this.core.config.bot.interactions.path;
+		if (!handlersDir) return;
+		this.logger.info(chalk.bold(handlersDir));
+		const middlewareDir = hasKeys(this.core.config.bot.interactions, ["middlewares"]) ? this.core.config.bot.interactions.middlewares : void 0;
+		if (middlewareDir) {
+			this.logger.info(`${chalk.bold(middlewareDir)} ${chalk.gray("(middlewares)")}`);
+			await this.loadMiddlewares(middlewareDir);
+		}
+		await this.loadHandlers(handlersDir);
+		this.attachToClient();
+		this.logger.info(`${chalk.bold.green("Loaded interaction handlers:")}`);
+		this.logger.utils.list([
+			`${chalk.magenta.bold(this.middlewares.length)} middlewares`,
+			`${chalk.magenta.bold(this.slashMap.size)} slash commands`,
+			`${chalk.magenta.bold(this.buttonMap.size)} buttons`,
+			`${chalk.magenta.bold(this.modalMap.size)} modals`,
+			`${chalk.magenta.bold(this.stringSelectMap.size)} string selects`,
+			`${chalk.magenta.bold(this.userSelectMap.size)} user selects`,
+			`${chalk.magenta.bold(this.roleSelectMap.size)} role selects`,
+			`${chalk.magenta.bold(this.channelSelectMap.size)} channel selects`,
+			`${chalk.magenta.bold(this.mentionableSelectMap.size)} mentionable selects`,
+			`${chalk.magenta.bold(this.messageContextMenuMap.size)} message context menus`,
+			`${chalk.magenta.bold(this.userContextMenuMap.size)} user context menus`,
+			`${chalk.magenta.bold(this.autocompleteMap.size)} autocomplete`
+		]);
+	}
+	async loadHandlers(dir) {
+		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
+			for (const val of Object.values(imported)) {
+				if (!this.isHandlerClass(val)) continue;
+				this.registerHandler(val, relativePath);
+				this.hmrHandler?.trackHandler(fullPath, val);
+			}
+		}, this.logger);
+	}
+	async loadMiddlewares(dir) {
+		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
+			for (const val of Object.values(imported)) {
+				if (!this.isMiddlewareClass(val)) continue;
+				this.registerMiddleware(val, relativePath);
+				this.hmrHandler?.trackMiddleware(fullPath, val);
+			}
+		}, this.logger);
+	}
+	registerMiddleware(middlewareCtor, relativePath) {
+		const metadata = Reflect.getMetadata(MiddlewareMetadataKey, middlewareCtor);
+		if (metadata?.type !== "interaction") return;
+		if (this.middlewares.some((entry) => entry.ctor === middlewareCtor)) return;
+		if (this.middlewares.some((entry) => entry.ctor.name === middlewareCtor.name)) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateMiddleware, [middlewareCtor.name]);
+		this.middlewares.push({
+			ctor: middlewareCtor,
+			priority: metadata.priority
+		});
+		this.middlewares.sort((a, b) => a.priority - b.priority);
+		this.logger.utils.registration(`${middlewareCtor.name} ${chalk.gray(`(${metadata.priority})`)}`, relativePath, "middleware");
+	}
+	isHandlerClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof InteractionHandler && Reflect.hasMetadata(InteractionMetadataKey, obj) || obj.prototype instanceof AutocompleteHandler && Reflect.hasMetadata(InteractionMetadataKey, obj);
+	}
+	isMiddlewareClass(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(MiddlewareMetadataKey, obj);
+	}
+	registerHandler(handlerClass, relativePath) {
+		const writes = [];
+		for (const [routeType, map] of this.routeTypes) {
+			const meta = Reflect.getMetadata(InteractionRouteKeys[routeType], handlerClass);
+			if (!areRoutes(meta)) continue;
+			for (const route of meta) {
+				const existing = map.get(route);
+				if (existing && existing !== handlerClass) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateRoute, [
+					route,
+					existing.name,
+					handlerClass.name
+				]);
+				writes.push([map, route]);
+			}
+			this.logger.utils.registration(handlerClass.name, formatFilePath(relativePath));
+		}
+		for (const [map, route] of writes) map.set(route, handlerClass);
+	}
+	/** @internal For use in dev mode */
+	async onHmr(event) {
+		await this.hmrHandler?.handle(event);
+	}
+	unregisterHandler(handlerClass, artifacts) {
+		if (artifacts) {
+			for (const { routeType, routes } of artifacts) {
+				const map = this.routeTypes.find(([type]) => type === routeType)?.[1];
+				if (map) routes.forEach((route) => map.delete(route));
+			}
+			return;
+		}
+		for (const [routeType, map] of this.routeTypes) {
+			const meta = Reflect.getMetadata(InteractionRouteKeys[routeType], handlerClass);
+			if (!areRoutes(meta)) continue;
+			meta.forEach((route) => map.delete(route));
+		}
+	}
+	unregisterMiddleware(middlewareCtor) {
+		const index = this.middlewares.findIndex((entry) => entry.ctor === middlewareCtor);
+		if (index !== -1) this.middlewares.splice(index, 1);
+	}
+	attachToClient() {
+		this.core.bot.client.on(Events.InteractionCreate, (interaction) => {
+			this.core.bot.emitSafe("any:interaction", interaction);
+			this.handleInteraction(interaction).catch((err) => {
+				this.logger.error(`[${chalk.bold.red("UNHANDLED ERROR AT ROOT")}] ${err.name}`, err.stack);
+				this.core.bot.emit("error:unhandled:interaction", err);
+			});
+		});
+	}
+	async handleCustomIdInteraction(interaction, getMap, interactionType) {
+		if ([...this.keysToIgnore].some((matcher) => matcher.owns(interaction.customId))) return;
+		const prefix = prefixOf(interaction.customId);
+		if (!prefix) return this.logger.warn(`${interactionType} has invalid customId: ${interaction.customId}`);
+		await this.processInteraction(interaction, () => prefix, (key) => getMap().get(key));
+	}
+	async processInteraction(interaction, extractKey, getHandler) {
+		const key = extractKey(interaction);
+		try {
+			if (!interaction.isAutocomplete()) for (const { ctor } of this.middlewares) await new ctor(interaction, this.core).execute();
+			let HandlerCtor = getHandler(key);
+			if (!HandlerCtor) {
+				this.logger.warn(`No handler found for key ${chalk.bold.cyan(key)}. Falling back to UnhandledEvent.`);
+				HandlerCtor = UnhandledEvent;
+			}
+			this.logger.debug(`Processing ${chalk.bold.green(key)} with ${chalk.gray(HandlerCtor.name)}`);
+			const dispatch = new DispatchContext(routeIdOf(HandlerCtor));
+			const handler = new HandlerCtor(interaction, this.core, dispatch);
+			if (!interaction.isAutocomplete()) await runHandlerGates(HandlerCtor, interactionGateContext(interaction, this.core));
+			await handler.execute();
+		} catch (caught) {
+			await handleInteractionFault(caught, interaction, this.core);
+		}
+	}
+	async handleInteraction(interaction) {
+		switch (true) {
+			case interaction.isChatInputCommand():
+				await this.handleSlashCommand(interaction);
+				break;
+			case interaction.isButton():
+				await this.handleButton(interaction);
+				break;
+			case interaction.isModalSubmit():
+				await this.handleModal(interaction);
+				break;
+			case interaction.isStringSelectMenu():
+				await this.handleStringSelectMenu(interaction);
+				break;
+			case interaction.isUserSelectMenu():
+				await this.handleUserSelectMenu(interaction);
+				break;
+			case interaction.isRoleSelectMenu():
+				await this.handleRoleSelectMenu(interaction);
+				break;
+			case interaction.isChannelSelectMenu():
+				await this.handleChannelSelectMenu(interaction);
+				break;
+			case interaction.isMentionableSelectMenu():
+				await this.handleMentionableSelectMenu(interaction);
+				break;
+			case interaction.isMessageContextMenuCommand():
+				await this.handleMessageContextMenu(interaction);
+				break;
+			case interaction.isUserContextMenuCommand():
+				await this.handleUserContextMenu(interaction);
+				break;
+			case interaction.isAutocomplete():
+				await this.handleAutocomplete(interaction);
+				break;
+			default:
+				this.logger.warn(`Unhandled interaction type: ${interaction.type}`);
+				break;
+		}
+	}
+	async handleSlashCommand(interaction) {
+		const route = slashRouteOf(interaction);
+		await this.processInteraction(interaction, () => route, (key) => this.slashMap.get(key));
+	}
+	async handleButton(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.buttonMap, "Button");
+	}
+	async handleModal(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.modalMap, "Modal");
+	}
+	async handleStringSelectMenu(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.stringSelectMap, "String select menu");
+	}
+	async handleUserSelectMenu(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.userSelectMap, "User select menu");
+	}
+	async handleRoleSelectMenu(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.roleSelectMap, "Role select menu");
+	}
+	async handleChannelSelectMenu(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.channelSelectMap, "Channel select menu");
+	}
+	async handleMentionableSelectMenu(interaction) {
+		await this.handleCustomIdInteraction(interaction, () => this.mentionableSelectMap, "Mentionable select menu");
+	}
+	async handleMessageContextMenu(interaction) {
+		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.messageContextMenuMap.get(key));
+	}
+	async handleUserContextMenu(interaction) {
+		await this.processInteraction(interaction, () => interaction.commandName, (key) => this.userContextMenuMap.get(key));
+	}
+	async handleAutocomplete(interaction) {
+		const route = slashRouteOf(interaction);
+		if (!this.autocompleteMap.has(route)) {
+			this.logger.warn(`No autocomplete handler for ${chalk.bold.cyan(route)}.`);
+			await interaction.respond([]);
+			return;
+		}
+		await this.processInteraction(interaction, () => route, (key) => this.autocompleteMap.get(key));
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.135.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/bot/Bot.ts
+/**
+* Discord bot implementation that manages client and controllers
+*
+* Don't instantiate this class directly. Use `core.bot` instead.
+*/
+var Bot = class extends Plugin {
+	/** @internal */
+	logger = new Logger("Bot");
+	isInitialized = false;
+	_client;
+	interactions;
+	events;
+	commands;
+	emojiInjector;
+	emojis = Emojis;
+	mentions = CommandMentions;
+	/** @internal For use in dev mode */
+	async onHmr(event) {
+		if (this.interactions) await this.interactions.onHmr(event);
+		if (this.events) await this.events.onHmr(event);
+		if (this.commands) await this.commands.onHmr(event);
+	}
+	/** @internal */
+	constructor(core) {
+		super(core);
+		this._client = new Client(core.config.bot.clientOptions);
+		if (core.config.bot.interactions.path) this.interactions = new InteractionDispatcher(core);
+		if (core.config.bot.events.path) this.events = new EventDispatcher(core);
+		if (core.config.bot.commands.path) {
+			const mentionInjector = new CommandMentionInjector(core);
+			this.commands = new CommandRegistry(core, (result) => {
+				mentionInjector.inject(result);
+			});
+		}
+		this.emojiInjector = new EmojiInjector(core);
+		core.shutdown.addTask(ShutdownPhase.DiscordCleanup, "stop-bot", async () => await this.stop(), 2e3);
+	}
+	/**
+	* Initializes Discord client and all controllers
+	* @internal
+	*/
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		const token = this.botToken;
+		if (this.interactions) await this.interactions.init();
+		if (this.events) await this.events.init();
+		await this.login(token);
+		await this.emojiInjector.init();
+		if (this.commands) {
+			await this.commands.init();
+			await this.commands.setCommands();
+			this.interactions?.warnUnhandledRoutes(this.commands.routeLeaves());
+			this.interactions?.warnUnhandledContextMenuRoutes(this.commands.contextMenuLeaves());
+		}
+	}
+	/**
+	* Stops the bot and cleans up connections
+	* @internal
+	*/
+	async stop() {
+		this._client.removeAllListeners();
+		await this.logout();
+	}
+	/**
+	* Logs the bot into Discord using the configured token
+	*/
+	async login(token) {
+		await this._client.login(token);
+		this.logger.info(`Logged in as ${chalk.bold.magenta(this._client.user?.username)}!`);
+		return this;
+	}
+	/**
+	* Logs out and destroys the Discord client connection
+	*/
+	async logout() {
+		await this._client.destroy();
+		this.logger.info(chalk.bold.red("Logged out of Discord!"));
+	}
+	get client() {
+		return this._client;
+	}
+	emit(event, ...args) {
+		return super.emit(event, ...args);
+	}
+	emitSafe(event, ...args) {
+		return super.emitSafe(event, ...args);
+	}
+	onListenerError(error, event) {
+		this.logger.error(`listener for ${String(event)} threw`, error);
+	}
+};
+__decorate([Envapt("DISCORD_BOT_TOKEN", { converter: (raw) => validateDiscordToken(raw) }), __decorateMetadata("design:type", String)], Bot.prototype, "botToken", void 0);
+
+//#endregion
+//#region src/hmr/HmrManager.ts
+var HmrManager = class {
+	logger = new Logger("HMR", { channel: "hmr" });
+	listeners = /* @__PURE__ */ new Set();
+	constructor() {}
+	/** @internal */
+	init() {
+		if (!import.meta.hot) return;
+		setDevChannel(wrapHot(import.meta.hot));
+		if (Envapter.isDevelopment || Envapter.isTest) {
+			this.logger.info("Enabled");
+			getDevChannel()?.on("seedcord:hmr", (payload) => {
+				const affected = payload.affectedModules?.length ?? 0;
+				this.logger.info(`${chalk.bold("1")} module changed, ${chalk.bold(affected)} affected modules`);
+				if (payload.affectedModules) this.logger.utils.list(payload.affectedModules.map((mod) => formatFilePath(mod)), "Affected modules: ");
+				this.handleUpdate(payload);
+			});
+		}
+	}
+	/** @internal */
+	register(listener) {
+		this.listeners.add(listener);
+	}
+	/** @internal */
+	unregister(listener) {
+		this.listeners.delete(listener);
+	}
+	async handleUpdate(event) {
+		const promises = [...this.listeners].map(async (listener) => {
+			try {
+				await listener.onHmr(event);
+			} catch (error) {
+				this.logger.error(`Error handling HMR update in ${chalk.bold(listener.name)}: `, error);
+			}
+		});
+		await Promise.all(promises);
+	}
+};
+
+//#endregion
+//#region src/subscribers/bases/webhookHelpers.ts
+const DISCORD_WEBHOOK_REGEX = new RegExp(String.raw`^https?:\/\/(?:canary\.|ptb\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w$-]+$`);
+/**
+* Whether a string is a well-formed Discord webhook URL.
+*
+* @internal
+*/
+function isDiscordWebhookUrl(value) {
+	return URL.canParse(value) && DISCORD_WEBHOOK_REGEX.test(value);
+}
+/**
+* Serializes a value to a JSON attachment, made circular-safe first.
+*
+* @internal
+*/
+function jsonAttachment(name, description, data) {
+	const content = filterCirculars(data);
+	return new AttachmentBuilder(Buffer.from(JSON.stringify(content, void 0, 2), "utf8"), {
+		name,
+		description
+	});
+}
+/**
+* The small divider the default webhook reporters place between sections.
+*
+* @internal
+*/
+var WebhookSeparator = class extends BuilderComponent {
+	constructor() {
+		super("separator");
+		this.instance.setSpacing(SeparatorSpacingSize.Small).setDivider(true);
+	}
+};
+
+//#endregion
+//#region src/subscribers/default/HandledException.ts
+var _HandledException;
+function webhookUrlValidator$1(raw) {
+	if (raw !== null && typeof raw !== "string") throw new SeedcordError(SeedcordErrorCode.ConfigHandledExceptionWebhookInvalid);
+	const value = raw?.trim() ?? "";
+	if (value === "") throw new SeedcordError(SeedcordErrorCode.ConfigHandledExceptionWebhookMissing);
+	if (!isDiscordWebhookUrl(value)) throw new SeedcordError(SeedcordErrorCode.ConfigHandledExceptionWebhookInvalid);
+	return value;
+}
+let HandledException = class HandledException extends WebhookLog {
+	static {
+		_HandledException = this;
+	}
+	webhook = new WebhookClient({ url: _HandledException.handledExceptionWebhookUrl });
+	async execute() {
+		const { source } = this.data;
+		try {
+			await this.webhook.send({
+				flags: flagsFor(false),
+				withComponents: true,
+				username: "Handled Exception",
+				components: [new HandledExceptionContainer(this.data).component],
+				files: [jsonAttachment("source.json", "The raw source the fault came from", source.raw)]
+			});
+		} catch (error) {
+			this.logger.error("Failed to send handled exception webhook", error);
+		}
+	}
+};
+__decorate([Envapt("HANDLED_EXCEPTION_WEBHOOK_URL", { converter: (raw) => webhookUrlValidator$1(raw) }), __decorateMetadata("design:type", String)], HandledException, "handledExceptionWebhookUrl", void 0);
+HandledException = _HandledException = __decorate([Subscribe("handledException")], HandledException);
+var HandledExceptionContainer = class extends BuilderComponent {
+	constructor(data) {
+		super("container");
+		const { denial, uuid, source } = data;
+		this.instance.addTextDisplayComponents((text) => text.setContent(faultSummary(denial, source))).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${causeStack(denial)}\`\`\``)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Source")).addFileComponents((file) => file.setURL("attachment://source.json"));
+	}
+};
+/**
+* The summary block of a fault report, narrowed per source kind so an interaction fault shows its
+* command and customId while an event fault shows its event name and handler.
+*
+* @internal
+*/
+function faultSummary(denial, source) {
+	const head = `### A handled fault was reported: \`${denial.name}\`\n**Message:** ${denial.message}\n`;
+	if (source.kind === "event") return `${head}**Event:** ${source.eventName}\n**Handler:** ${source.handler}\n**User ID:** \`${source.userId ?? "n/a"}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\``;
+	return `${head}**Kind:** ${source.interactionKind}\n**Command:** ${source.command ?? "n/a"}\n**CustomId:** ${source.customId ?? "n/a"}\n**User ID:** \`${source.userId}\`\n**Guild ID:** \`${source.guildId ?? "n/a"}\`\n**Channel ID:** \`${source.channelId ?? "n/a"}\`\n**Interaction ID:** \`${source.interactionId}\``;
+}
+/**
+* The text shown for a denial's cause in the report. Tolerates a non-serializable cause (a bigint or a
+* circular object) so building the report never throws.
+*
+* @internal
+*/
+function causeStack(denial) {
+	const { cause } = denial;
+	if (Error.isError(cause)) return cause.stack ?? cause.message;
+	if (typeof cause === "string") return cause;
+	if (typeof cause === "bigint" || typeof cause === "symbol" || typeof cause === "function") return cause.toString();
+	if (cause !== void 0) try {
+		return JSON.stringify(cause);
+	} catch {
+		return "[unserializable cause]";
+	}
+	return denial.stack ?? "No cause recorded.";
+}
+
+//#endregion
+//#region src/subscribers/default/UnknownException.ts
+var _UnknownException;
+function webhookUrlValidator(raw) {
+	if (raw !== null && typeof raw !== "string") throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
+	const value = raw?.trim() ?? "";
+	if (value === "") throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookMissing);
+	if (!isDiscordWebhookUrl(value)) throw new SeedcordError(SeedcordErrorCode.ConfigUnknownExceptionWebhookInvalid);
+	return value;
+}
+let UnknownException = class UnknownException extends WebhookLog {
+	static {
+		_UnknownException = this;
+	}
+	webhook = new WebhookClient({ url: _UnknownException.unknownExceptionWebhookUrl });
+	async execute() {
+		const { metadata } = this.data;
+		const metadataFile = metadata ? jsonAttachment("metadata.json", "Metadata associated with the error", metadata) : null;
+		try {
+			await this.webhook.send({
+				flags: flagsFor(false),
+				withComponents: true,
+				username: "Unknown Exception",
+				components: [new UnhandledErrorContainer(this.data).component],
+				files: metadataFile ? [metadataFile] : []
+			});
+		} catch (error) {
+			this.logger.error("Failed to send unknown exception webhook", error);
+		}
+	}
+};
+__decorate([Envapt("UNKNOWN_EXCEPTION_WEBHOOK_URL", { converter: (raw) => webhookUrlValidator(raw) }), __decorateMetadata("design:type", String)], UnknownException, "unknownExceptionWebhookUrl", void 0);
+UnknownException = _UnknownException = __decorate([Subscribe("unknownException")], UnknownException);
+var UnhandledErrorContainer = class extends BuilderComponent {
+	constructor(data) {
+		super("container");
+		const { uuid, error, guild, user, metadata } = data;
+		this.instance.addTextDisplayComponents((text) => text.setContent(`### An unknown exception was thrown\n**Guild ID:** \`${guild?.id ?? "Not used in a guild"}\`\n**Guild Name:** ${guild?.name ?? "Not used in a guild"}\n**User ID:** \`${user?.id ?? "Missing user info"}\`\n**Username:** ${user?.username ?? "Missing user info"}\n`)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### UUID \`${uuid}\`\n\`\`\`${error.stack}\`\`\``));
+		this.addTimestampsIfAvailable(error);
+		this.addMetadataIfAvailable(metadata);
+	}
+	addTimestampsIfAvailable(error) {
+		if (!(error instanceof DiscordAPIError)) return;
+		const now = Date.now();
+		const snowflake = error.url.match(/\/interactions\/(\d+)\//)?.[1];
+		if (!snowflake) return void 0;
+		const interactionTs = Number(SnowflakeUtil.deconstruct(snowflake).timestamp);
+		const diff = now - interactionTs;
+		const seconds = Math.floor(diff / 1e3);
+		const millis = diff % 1e3;
+		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent(`### Timestamps\n- **\`Interaction sent\` :** ${new Date(interactionTs).toISOString()} (${interactionTs})\n- **\`Error logged    \` :** ${new Date(now).toISOString()} (${now})\n- **\`Offset          \` :** ${seconds}s ${millis}ms`));
+	}
+	addMetadataIfAvailable(metadata) {
+		if (!metadata) return;
+		this.instance.addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Metadata")).addFileComponents((file) => file.setURL("attachment://metadata.json"));
+	}
+};
+
+//#endregion
+//#region src/subscribers/Bus.ts
+/**
+* Manages application subscribers and event handling
+*
+* Provides a centralized system for registering and executing custom subscribers
+* throughout the application lifecycle. Bus subscribers are loaded from configured directories
+* and can be triggered programmatically or by framework events. Accessed via `core.bus`. Do not
+* construct it directly.
+*/
+var Bus = class extends Plugin {
+	core;
+	logger = new Logger("Subscribers");
+	/** @internal */
+	name = "Subscribers";
+	isInitialized = false;
+	subscribersMap = /* @__PURE__ */ new Map();
+	executedOnceHandlers = /* @__PURE__ */ new Set();
+	hmrHandler;
+	constructor(core) {
+		super(core);
+		this.core = core;
+		if (this.core.config.subscribers.path) {
+			if (!Envapter.isDevelopment && !Envapter.isTest) return;
+			this.hmrHandler = new HmrModuleHandler({
+				handlersDir: this.core.config.subscribers.path,
+				isHandler: this.isSubscriber.bind(this),
+				registerHandler: this.registerSubscriber.bind(this),
+				unregisterHandler: this.unregisterSubscriber.bind(this),
+				getArtifacts: this.getArtifacts.bind(this),
+				logger: this.logger
+			});
+		}
+	}
+	getArtifacts(ctor) {
+		return [Reflect.getMetadata(SubscribeMetadataKey, ctor).subscriber];
+	}
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		this.registerSubscriber(UnknownException);
+		this.registerSubscriber(HandledException);
+		Envapter.require("UNKNOWN_EXCEPTION_WEBHOOK_URL", "HANDLED_EXCEPTION_WEBHOOK_URL");
+		const subscribersDir = this.core.config.subscribers.path;
+		if (subscribersDir) {
+			this.logger.info(chalk.bold(subscribersDir));
+			await this.loadSubscribers(subscribersDir);
+			const totalSubscribers = [...this.subscribersMap.values()].reduce((acc, handlers) => acc + handlers.length, 0);
+			this.logger.utils.list([`${chalk.bold.magenta(totalSubscribers)} subscribers`], chalk.bold.green("Loaded"));
+		}
+	}
+	/** @internal For use in dev mode */
+	async onHmr(event) {
+		if (this.hmrHandler) await this.hmrHandler.handle(event);
+	}
+	async loadSubscribers(dir) {
+		await traverseDirectory(dir, (fullPath, relativePath, imported) => {
+			for (const exportName of Object.keys(imported)) {
+				const val = imported[exportName];
+				if (this.isSubscriber(val)) {
+					this.registerSubscriber(val);
+					this.hmrHandler?.trackHandler(fullPath, val);
+					this.logger.utils.registration(val.name, relativePath);
+				}
+			}
+		}, this.logger);
+	}
+	registerSubscriber(handler) {
+		const options = Reflect.getMetadata(SubscribeMetadataKey, handler);
+		let handlers = this.subscribersMap.get(options.subscriber);
+		if (!handlers) {
+			handlers = [];
+			this.subscribersMap.set(options.subscriber, handlers);
+		}
+		handlers.push({
+			ctor: handler,
+			frequency: options.frequency ?? "on"
+		});
+	}
+	unregisterSubscriber(handler, artifacts) {
+		const subscribers = artifacts ?? [...this.subscribersMap.keys()];
+		for (const subscriber of subscribers) {
+			const handlers = this.subscribersMap.get(subscriber);
+			if (!handlers) continue;
+			const index = handlers.findIndex((entry) => entry.ctor === handler);
+			if (index !== -1) handlers.splice(index, 1);
+		}
+	}
+	isSubscriber(obj) {
+		if (typeof obj !== "function") return false;
+		return obj.prototype instanceof Subscriber && Reflect.hasMetadata(SubscribeMetadataKey, obj);
+	}
+	/**
+	* Publishes an event to its subscribers and native listeners.
+	*
+	* Fire-and-forget, so subscriber handlers run asynchronously and this returns before they
+	* complete, and callers must not assume side effects have landed. Errors thrown by a subscriber
+	* are caught and logged, never surfaced here. A `'once'` subscriber is marked as executed when
+	* it starts (even if it throws), so it never runs twice.
+	*
+	* @param event - The subscription key to publish
+	* @param data - Payload passed to each subscriber
+	* @returns Whether the underlying emitter had native listeners for the event
+	*/
+	publish(event, data) {
+		this.processSubscriber(event, data);
+		return super.emit(event, ...[data]);
+	}
+	async processSubscriber(subscriberName, data) {
+		const handlers = this.subscribersMap.get(subscriberName);
+		if (!handlers) return;
+		for (const entry of handlers) {
+			if (entry.frequency === "once" && this.executedOnceHandlers.has(entry.ctor)) continue;
+			try {
+				if (entry.frequency === "once") this.executedOnceHandlers.add(entry.ctor);
+				const Ctor = entry.ctor;
+				await new Ctor(data, this.core).execute();
+			} catch (err) {
+				this.logger.error(`Error in subscriber ${String(subscriberName)} handler ${entry.ctor.name}:`, err);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/version.ts
 /** Package version */
-const version = "0.0.1";
+const version = "0.1.0-next.1";
+
+//#endregion
+//#region src/Seedcord.ts
+/**
+* Main Seedcord bot framework class
+*
+* Primary entry point for creating Discord bots with Seedcord.
+* Manages component lifecycle and provides plugin support.
+*/
+var Seedcord = class Seedcord extends Pluggable {
+	config;
+	/** @internal */
+	[SeedcordBrand] = true;
+	/** @internal */
+	augmentTarget = "@seedcord/gateway";
+	/** @internal */
+	version = version;
+	static isInstantiated = false;
+	/** @see {@link CoordinatedShutdown} */
+	shutdown;
+	/** @see {@link CoordinatedStartup} */
+	startup;
+	/** @see {@link Bus} */
+	bus;
+	/** @see {@link Bot} */
+	bot;
+	/** @see {@link IRateLimiter} */
+	rateLimiter;
+	/** @see {@link HealthCheck} */
+	healthCheck;
+	/** @see {@link HmrManager} */
+	hmrManager;
+	/**
+	* Creates a new Seedcord instance
+	*
+	* @param config - Bot configuration including paths and Discord client options
+	* @throws A **SeedcordError** When attempting to create multiple instances (singleton)
+	*/
+	constructor(config) {
+		if (Seedcord.isInstantiated) throw new SeedcordError(SeedcordErrorCode.CoreSingletonViolation);
+		Seedcord.isInstantiated = true;
+		const shutdown = new CoordinatedShutdown(config.shutdownEnabled);
+		const startup = new CoordinatedStartup();
+		super(shutdown, startup);
+		this.config = config;
+		setBotColor(config.botColor);
+		this.shutdown = shutdown;
+		this.startup = startup;
+		this.hmrManager = new HmrManager();
+		this.hmrManager.init();
+		this.bus = new Bus(this);
+		this.bot = new Bot(this);
+		this.rateLimiter = config.store ?? new MemoryRateLimiter();
+		this.healthCheck = new HealthCheck(this.shutdown, config.healthCheck);
+		this.registerStartupTasks();
+	}
+	/** @internal */
+	static reset() {
+		Seedcord.isInstantiated = false;
+	}
+	/**
+	* Registers default startup tasks
+	* @internal
+	*/
+	registerStartupTasks() {
+		if (Envapter.isDevelopment || Envapter.isTest) this.registerHmrAwareModules();
+		this.startup.addTask(StartupPhase.Configuration, "Bus Initialization", async () => {
+			this.bus.logger.utils.initialization("Subscribers", "start");
+			await this.bus.init();
+			this.bus.logger.utils.initialization("Subscribers", "end");
+		});
+		this.startup.addTask(StartupPhase.Instantiation, "Bot Initialization", async () => {
+			this.bot.logger.utils.initialization("Bot", "start");
+			await this.bot.init();
+			this.bot.logger.utils.initialization("Bot", "end");
+		});
+		this.startup.addTask(StartupPhase.Ready, "Health Check", async () => {
+			this.healthCheck.logger.utils.initialization("HealthCheck", "start");
+			await this.healthCheck.init();
+			this.healthCheck.logger.utils.initialization("HealthCheck", "end");
+		});
+	}
+	/**
+	* Starts the bot and runs all initialization tasks
+	*
+	* @returns This Seedcord instance when fully initialized
+	*/
+	async start() {
+		await super.init();
+		return this;
+	}
+	registerHmrAwareModules() {
+		this.startup.addTask(StartupPhase.Configuration, "HMR Registration", async () => {
+			this.hmrManager.register(this.bot);
+			this.hmrManager.register(this.bus);
+			for (const plugin of this.plugins) this.hmrManager.register(plugin);
+			await Promise.resolve();
+		});
+	}
+};
 
 //#endregion
-export { version };
+export { ArraySource, AutocompleteHandler, AutocompleteRoute, ButtonHandler, ButtonRoute, CommandMentions, ContextMenuHandler, ContextMenuRoute, CursorSource, Emojis, EventHandler, EventMiddleware, Gated, HmrModuleHandler, IgnoreBots, InteractionHandler, InteractionMiddleware, Middleware, MiddlewareType, ModalHandler, ModalRoute, Nsfw, Paginator, Pluggable, Plugin, RegisterCommand, RegisterEvent, ReplySender, RequireBotPermissions, RequirePermissions, RequireRole, Seedcord, SelectMenuHandler, SelectMenuKind, SelectMenuRoute, SlashHandler, SlashRoute, Subscribe, Subscriber, WebhookLog, checkBotPermissions, checkPermissions, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, getConfirmation, hasPermsToAssign, updateMemberRoles, version };
 //# sourceMappingURL=index.mjs.map