@seedcord/core 0.10.0 → 0.11.0

package/dist/subscribers-Ce3SWy23.mjs

@@ -0,0 +1,1913 @@
+import { t as PublishDefault } from "./publishDefault-D3dAyzZ9.mjs";
+import "reflect-metadata";
+import { CustomId, decodeFor } from "@seedcord/custom-id";
+import { ActionRowBuilder, ButtonBuilder, ChannelSelectMenuBuilder, CheckboxBuilder, CheckboxGroupBuilder, CheckboxGroupOptionBuilder, ContainerBuilder, ContextMenuCommandBuilder, EmbedBuilder, FileBuilder, FileUploadBuilder, LabelBuilder, MediaGalleryBuilder, MentionableSelectMenuBuilder, ModalBuilder, RadioGroupBuilder, RadioGroupOptionBuilder, RoleSelectMenuBuilder, SectionBuilder, SeparatorBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, TextDisplayBuilder, TextInputBuilder, UserSelectMenuBuilder } from "@discordjs/builders";
+import { ApplicationCommandType, InteractionContextType, MessageFlags, PermissionFlagsBits, Routes, SeparatorSpacingSize } from "discord-api-types/v10";
+import { SeedcordErrorCode, paint } from "@seedcord/errors";
+import { SeedcordError, SeedcordRangeError, SeedcordTypeError } from "@seedcord/errors/internal";
+import { Logger } from "@seedcord/logger";
+import { asError, isStringArray, pluralize, routeLeavesOf } from "@seedcord/utils/internal";
+import { filterCirculars, prettify, stripAnsi, timestampFromSnowflake, toEpochSeconds } from "@seedcord/utils";
+import { TypedEventEmitter } from "@seedcord/event-emitter";
+import { Envapter } from "envapt";
+import { DiscordAPIError, REST } from "@discordjs/rest";
+
+//#region src/stops/Notice.ts
+/**
+* Base class for a user-facing refusal or a reported fault.
+*
+* Throw a `Notice` to stop a handler and reply to the user. The framework catches it at the controller
+* boundary and renders {@link Notice.render}, which always decides what the user sees. With `report`
+* false that render is all that happens. With `report` true the framework also logs the fault and
+* publishes it to the `handledException` bus. A raw, non-Notice throw shows the generic message.
+*
+* @example
+* ```ts
+* import { Notice, BuilderComponent, type RenderContext, type ReplyResponse } from '@seedcord/gateway';
+* import { TextDisplayBuilder } from '@discordjs/builders';
+*
+* // reading `.component` applies the configured bot color to the container accent
+* class TooPoorCard extends BuilderComponent<'container'> {
+*     constructor(balance: number) {
+*         super('container');
+*         this.instance.addTextDisplayComponents(
+*             new TextDisplayBuilder().setContent(`### Insufficient balance\nYou need more than ${balance} coins.`)
+*         );
+*     }
+* }
+*
+* class TooPoor extends Notice {
+*     constructor(private readonly balance: number) {
+*         super(`balance ${balance} is below the cost`);
+*     }
+*
+*     render(_ctx: RenderContext): ReplyResponse {
+*         return { components: [new TooPoorCard(this.balance).component] };
+*     }
+* }
+*
+* // in a handler, throwing stops the handler and replies with render(ctx)
+* if (wallet.balance < cost) throw new TooPoor(wallet.balance);
+* ```
+*/
+var Notice = class extends Error {
+	/**
+	* Whether this denial is a reported fault. True also logs it and publishes it to the `handledException`
+	* bus. The user always sees {@link Notice.render} either way.
+	*
+	* @defaultValue `false`
+	*/
+	report = false;
+	/**
+	* Whether the reply is ephemeral, seen only by the invoking user. Set it false for a refusal the
+	* whole channel should see.
+	*
+	* @defaultValue `true`
+	*/
+	ephemeral = true;
+	/**
+	* A short one-line reason. When every arm of an {@link or} gate refuses and each one sets this, `or`
+	* throws a refusal listing them under `You need to meet at least one of these:`. Write a verb phrase that
+	* finishes that line, for example, "be the bot owner".
+	*/
+	summary;
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region src/components/botColorHolder.ts
+const DEFAULT_COLOR = "Default";
+let readBotColor = () => void 0;
+function bindBotColor(read) {
+	readBotColor = read;
+}
+function getBotColor() {
+	return readBotColor() ?? DEFAULT_COLOR;
+}
+
+//#endregion
+//#region src/components/builderTypes.ts
+/**
+* Available Discord.js builder classes for use with BuilderComponent for commands, embeds, modals, etc.
+*
+* @internal
+*/
+const BuilderTypes = {
+	command: SlashCommandBuilder,
+	context_menu: ContextMenuCommandBuilder,
+	subcommand: SlashCommandSubcommandBuilder,
+	group: SlashCommandSubcommandGroupBuilder,
+	embed: EmbedBuilder,
+	modal: ModalBuilder,
+	label: LabelBuilder,
+	text_input: TextInputBuilder,
+	file_upload: FileUploadBuilder,
+	checkbox: CheckboxBuilder,
+	checkbox_group: CheckboxGroupBuilder,
+	checkbox_group_option: CheckboxGroupOptionBuilder,
+	radio_group: RadioGroupBuilder,
+	radio_group_option: RadioGroupOptionBuilder,
+	button: ButtonBuilder,
+	menu_string: StringSelectMenuBuilder,
+	menu_option_string: StringSelectMenuOptionBuilder,
+	menu_user: UserSelectMenuBuilder,
+	menu_channel: ChannelSelectMenuBuilder,
+	menu_mentionable: MentionableSelectMenuBuilder,
+	menu_role: RoleSelectMenuBuilder,
+	container: ContainerBuilder,
+	text_display: TextDisplayBuilder,
+	file: FileBuilder,
+	media: MediaGalleryBuilder,
+	section: SectionBuilder,
+	separator: SeparatorBuilder
+};
+/**
+* Available Discord.js action row classes for use with RowComponent for Select Menus and Buttons
+*
+* @internal
+*/
+const RowTypes = {
+	button: ActionRowBuilder,
+	menu_string: ActionRowBuilder,
+	menu_user: ActionRowBuilder,
+	menu_channel: ActionRowBuilder,
+	menu_mentionable: ActionRowBuilder,
+	menu_role: ActionRowBuilder
+};
+
+//#endregion
+//#region src/components/colors.ts
+const Colors = {
+	Aqua: 1752220,
+	Blue: 3447003,
+	Blurple: 5793266,
+	DarkAqua: 1146986,
+	DarkBlue: 2123412,
+	DarkButNotBlack: 2895667,
+	DarkerGrey: 8359053,
+	DarkGold: 12745742,
+	DarkGreen: 2067276,
+	DarkGrey: 9936031,
+	DarkNavy: 2899536,
+	DarkOrange: 11027200,
+	DarkPurple: 7419530,
+	DarkRed: 10038562,
+	DarkVividPink: 11342935,
+	Default: 0,
+	Fuchsia: 15418782,
+	Gold: 15844367,
+	Green: 5763719,
+	Grey: 9807270,
+	Greyple: 10070709,
+	LightGrey: 12370112,
+	LuminousVividPink: 15277667,
+	Navy: 3426654,
+	NotQuiteBlack: 2303786,
+	Orange: 15105570,
+	Purple: 10181046,
+	Red: 15548997,
+	White: 16777215,
+	Yellow: 16705372
+};
+
+//#endregion
+//#region src/components/resolveColor.ts
+const MAX_COLOR = 16777215;
+const RED_SHIFT = 16;
+const GREEN_SHIFT = 8;
+const palette = Colors;
+/**
+* Resolves a {@link BotColor} to the integer Discord expects.
+*
+* Ported from discord.js (Apache-2.0), `resolveColor` in src/util/Util.js.
+*/
+function resolveColor(color) {
+	let resolved;
+	if (typeof color === "string") {
+		if (color === "Random") return Math.floor(Math.random() * 16777216);
+		if (color === "Default") return 0;
+		if (/^#?[\da-f]{6}$/i.test(color)) return Number.parseInt(color.replace("#", ""), 16);
+		resolved = palette[color];
+	} else if (typeof color === "number") resolved = color;
+	else resolved = (color[0] << RED_SHIFT) + (color[1] << GREEN_SHIFT) + color[2];
+	if (resolved === void 0 || !Number.isSafeInteger(resolved)) throw new SeedcordTypeError(SeedcordErrorCode.ColorUnresolvable, [JSON.stringify(color)]);
+	if (resolved < 0 || resolved > MAX_COLOR) throw new SeedcordRangeError(SeedcordErrorCode.ColorOutOfRange, [resolved]);
+	return resolved;
+}
+
+//#endregion
+//#region src/components/Component.ts
+/** @internal */
+var BaseComponent = class {
+	_component;
+	constructor(ComponentClass) {
+		this._component = new ComponentClass();
+	}
+	/**
+	* The wrapped builder, for calling Discord.js methods like setTitle() and setDescription() inside a subclass.
+	*
+	* @example this.instance.setTitle('My Modal')
+	*/
+	get instance() {
+		return this._component;
+	}
+};
+/**
+* Base class for Discord.js builder components
+*
+* Wraps Discord.js builders (SlashCommandBuilder, EmbedBuilder, etc.) with
+* Seedcord-specific defaults and helper methods.
+*
+* @typeParam BuilderKey - The type of Discord.js builder being wrapped
+*/
+var BuilderComponent = class extends BaseComponent {
+	type;
+	colorApplied = false;
+	constructor(type) {
+		const ComponentClass = BuilderTypes[type];
+		super(ComponentClass);
+		this.type = type;
+		if (this.instance instanceof SlashCommandBuilder || this.instance instanceof ContextMenuCommandBuilder) this.instance.setContexts(InteractionContextType.Guild);
+	}
+	get component() {
+		this.applyBotColor();
+		return this.instance;
+	}
+	applyBotColor() {
+		if (this.colorApplied) return;
+		this.colorApplied = true;
+		const color = getBotColor();
+		if (this.instance instanceof EmbedBuilder) {
+			if (this.instance.data.color === void 0) this.instance.setColor(resolveColor(color));
+		} else if (this.instance instanceof ContainerBuilder) {
+			const accent = this.instance.data.accent_color;
+			if (accent === null || accent === void 0) this.instance.setAccentColor(color === "Default" ? void 0 : resolveColor(color));
+		}
+	}
+};
+const BUILDER_COMPONENT = Symbol.for("seedcord:core:builder-component");
+Object.defineProperty(BuilderComponent.prototype, BUILDER_COMPONENT, { value: true });
+/** @internal */
+function isBuilderComponentClass(value) {
+	if (typeof value !== "function") return false;
+	const proto = value.prototype;
+	return typeof proto === "object" && proto !== null && BUILDER_COMPONENT in proto;
+}
+/**
+* Base class for Discord action row components
+*
+* Wraps Discord.js action row builder with Seedcord-specific defaults and helper methods.
+*
+* @typeParam RowKey - The Discord.js action row type being wrapped
+*/
+var RowComponent = class extends BaseComponent {
+	type;
+	constructor(type) {
+		const ComponentClass = RowTypes[type];
+		super(ComponentClass);
+		this.type = type;
+	}
+	get component() {
+		return this.instance;
+	}
+};
+
+//#endregion
+//#region src/stops/NoticeCard.ts
+var NoticeCard = class extends BuilderComponent {
+	constructor(description, title = "Cannot Proceed") {
+		super("container");
+		this.instance.addTextDisplayComponents(new TextDisplayBuilder().setContent(`### ${title}\n${description}`));
+	}
+};
+
+//#endregion
+//#region src/commands/contextMenuLeaves.ts
+function contextMenuLeaves(commands) {
+	const user = /* @__PURE__ */ new Set();
+	const message = /* @__PURE__ */ new Set();
+	for (const command of commands) if (command.type === ApplicationCommandType.User) user.add(command.name);
+	else if (command.type === ApplicationCommandType.Message) message.add(command.name);
+	return {
+		user,
+		message
+	};
+}
+
+//#endregion
+//#region src/commands/scopes.ts
+const GLOBAL_ID = "global";
+const allOf$1 = new Intl.ListFormat("en", { type: "conjunction" });
+function commandsRoute(applicationId, scope) {
+	return scope === "global" ? Routes.applicationCommands(applicationId) : Routes.applicationGuildCommands(applicationId, scope);
+}
+function globalFirst(scopes) {
+	return [...scopes].toSorted(([a], [b]) => Number(b === GLOBAL_ID) - Number(a === GLOBAL_ID));
+}
+function scopeIdsOf(target) {
+	return target.scope === "global" ? [GLOBAL_ID] : target.guilds;
+}
+function skippedNote(skipped, guildLabel) {
+	const guilds = skipped.filter((scope) => scope !== GLOBAL_ID).map(guildLabel);
+	const parts = [...skipped.includes("global") ? ["the global commands"] : [], ...guilds.length > 0 ? [`the commands in ${allOf$1.format(guilds)}`] : []];
+	return `Skipped ${allOf$1.format(parts)} because they match the last deploy.`;
+}
+
+//#endregion
+//#region src/miscellaneous/guarded.ts
+function accessorStore() {
+	return Object.create(null);
+}
+function clearStore(store) {
+	for (const key of Object.keys(store)) Reflect.deleteProperty(store, key);
+}
+function guardedAccessor(accessor, storage) {
+	return new Proxy(storage, { get(target, key, receiver) {
+		if (typeof key !== "string" || Object.hasOwn(target, key)) return Reflect.get(target, key, receiver);
+		throw new SeedcordError(SeedcordErrorCode.CoreAccessorUnresolved, [accessor, key]);
+	} });
+}
+
+//#endregion
+//#region src/commands/linkCommands.ts
+const MULTI_GUILD = Symbol("seedcord:commands:multi-guild");
+function commandRefOf({ name, type }) {
+	return {
+		name,
+		type: type ?? ApplicationCommandType.ChatInput
+	};
+}
+function commandKey(command) {
+	const { type, name } = commandRefOf(command);
+	return `${type}:${name}`;
+}
+function indexById(commands) {
+	return new Map(commands.map((command) => [command.id, command]));
+}
+function isSlash(json) {
+	return commandRefOf(json).type === ApplicationCommandType.ChatInput;
+}
+function uniqueRefs(refs) {
+	return [...new Map(refs.map((ref) => [commandKey(ref), ref])).values()];
+}
+function deployedIds(deploy) {
+	const ids = /* @__PURE__ */ new Map();
+	for (const [scope, collection] of deploy) {
+		if (scope === "global") continue;
+		for (const command of collection.values()) {
+			const key = commandKey(command);
+			const existing = ids.get(key);
+			if (existing === void 0) ids.set(key, command.id);
+			else if (existing !== command.id) ids.set(key, MULTI_GUILD);
+		}
+	}
+	for (const command of deploy.get("global")?.values() ?? []) ids.set(commandKey(command), command.id);
+	return ids;
+}
+function allDeployed(deploy) {
+	return [...deploy.values()].flatMap((collection) => [...collection.values()]);
+}
+function mentionOf(route, id) {
+	const spaced = route.replaceAll("/", " ");
+	return id ? `</${spaced}:${id}>` : `/${spaced}`;
+}
+var CommandLinker = class {
+	deploy;
+	ids;
+	constructor(deploy) {
+		this.deploy = deploy;
+		this.ids = deployedIds(deploy);
+	}
+	link(all) {
+		const slash = all.filter(isSlash);
+		const leaves = contextMenuLeaves(all);
+		const inCode = uniqueRefs([
+			...slash.map(commandRefOf),
+			...[...leaves.user].map((name) => ({
+				name,
+				type: ApplicationCommandType.User
+			})),
+			...[...leaves.message].map((name) => ({
+				name,
+				type: ApplicationCommandType.Message
+			}))
+		]);
+		return {
+			commands: this.slashRoutes(slash),
+			contextMenus: {
+				user: this.menus(leaves.user, ApplicationCommandType.User),
+				message: this.menus(leaves.message, ApplicationCommandType.Message)
+			},
+			multiGuild: inCode.filter((ref) => this.ids.get(commandKey(ref)) === MULTI_GUILD),
+			notInCode: this.notInCode(inCode)
+		};
+	}
+	slashRoutes(slash) {
+		const commands = accessorStore();
+		for (const command of slash) {
+			const id = this.idOf(commandRefOf(command));
+			for (const { route, description } of routeLeavesOf(command)) commands[route] = {
+				mention: mentionOf(route, id),
+				...id && { id },
+				route,
+				description
+			};
+		}
+		return commands;
+	}
+	menus(names, kind) {
+		const menus = accessorStore();
+		for (const name of names) {
+			const id = this.idOf({
+				name,
+				type: kind
+			});
+			menus[name] = {
+				...id && { id },
+				name,
+				kind
+			};
+		}
+		return menus;
+	}
+	idOf(ref) {
+		const id = this.ids.get(commandKey(ref));
+		return id === MULTI_GUILD ? void 0 : id;
+	}
+	notInCode(inCode) {
+		const inCodeKeys = new Set(inCode.map(commandKey));
+		const extra = /* @__PURE__ */ new Map();
+		for (const command of allDeployed(this.deploy)) {
+			const key = commandKey(command);
+			if (!inCodeKeys.has(key)) extra.set(key, commandRefOf(command));
+		}
+		return [...extra.values()];
+	}
+};
+function linkCommands(deploy, all) {
+	return new CommandLinker(deploy).link(all);
+}
+
+//#endregion
+//#region src/commands/CommandInjector.ts
+const commandStorage = accessorStore();
+const userMenuStorage = accessorStore();
+const messageMenuStorage = accessorStore();
+/**
+* The bot's deployed slash commands, keyed by {@link SlashRegistry}. A server bot fills these after
+* each deploy. An edge bot fills them on its first request, from the ids `seedcord build` wrote into
+* the worker.
+*
+* @throws A **SeedcordError** when you read a command before the bot fills it.
+*
+* @example
+* ```ts
+* import { Commands } from '@seedcord/gateway';
+*
+* await this.reply(`Try ${Commands['config/set'].mention}`);
+*
+* // a help listing
+* const lines = Object.values(Commands).map((c) => `${c.mention} ${c.description}`);
+* ```
+*/
+const Commands = guardedAccessor("Commands", commandStorage);
+/**
+* The bot's deployed context-menu commands. A server bot fills these after each deploy. An edge bot
+* fills them on its first request, from the ids `seedcord build` wrote into the worker.
+*
+* @throws A **SeedcordError** when you read a command before the bot fills it.
+*
+* @example
+* ```ts
+* import { ContextMenus } from '@seedcord/gateway';
+*
+* const id = ContextMenus.user['View Profile'].id;
+* ```
+*/
+const ContextMenus = {
+	user: guardedAccessor("ContextMenus.user", userMenuStorage),
+	message: guardedAccessor("ContextMenus.message", messageMenuStorage)
+};
+function installLinks({ commands, contextMenus }) {
+	const pairs = [
+		[commandStorage, commands],
+		[userMenuStorage, contextMenus.user],
+		[messageMenuStorage, contextMenus.message]
+	];
+	for (const [store, values] of pairs) {
+		clearStore(store);
+		Object.assign(store, values);
+	}
+}
+const KIND_LABELS = {
+	[ApplicationCommandType.ChatInput]: "slash command",
+	[ApplicationCommandType.User]: "user menu",
+	[ApplicationCommandType.Message]: "message menu",
+	[ApplicationCommandType.PrimaryEntryPoint]: "entry point command"
+};
+function multiGuildWarning({ name, type }) {
+	const consequence = type === ApplicationCommandType.ChatInput ? "falling back to plain text (not clickable)" : "leaving its id unset";
+	return `${paint.sky.bold(name)} is deployed to multiple guilds, ${consequence}.`;
+}
+function warnLinks(logger, { multiGuild, notInCode }) {
+	for (const ref of multiGuild) logger.warn(multiGuildWarning(ref));
+	for (const { name, type } of notInCode) logger.warn(`The ${KIND_LABELS[type]} ${paint.sky.bold(name)} is deployed on Discord with no command for it in your code.`);
+}
+/** @internal */
+var CommandInjector = class {
+	logger = new Logger("Commands", { channel: "bot" });
+	inject(deploy, all) {
+		const linked = linkCommands(deploy, all.map((command) => command.toJSON()));
+		installLinks(linked);
+		warnLinks(this.logger, linked);
+		const routes = Object.values(linked.commands);
+		const clickable = routes.filter((command) => command.id !== void 0).length;
+		this.logger.utils.summary("Linked commands", {
+			clickable,
+			plain: routes.length - clickable,
+			"context menus": Object.keys(linked.contextMenus.user).length + Object.keys(linked.contextMenus.message).length
+		});
+	}
+};
+
+//#endregion
+//#region src/metadataKeys.ts
+/**
+* Every interaction kind seedcord routes.
+*/
+let InteractionKind = /* @__PURE__ */ function(InteractionKind) {
+	InteractionKind["Slash"] = "slash";
+	InteractionKind["Button"] = "button";
+	InteractionKind["Modal"] = "modal";
+	InteractionKind["StringMenu"] = "stringMenu";
+	InteractionKind["UserMenu"] = "userMenu";
+	InteractionKind["RoleMenu"] = "roleMenu";
+	InteractionKind["ChannelMenu"] = "channelMenu";
+	InteractionKind["MentionableMenu"] = "mentionableMenu";
+	InteractionKind["MessageContextMenu"] = "messageContextMenu";
+	InteractionKind["UserContextMenu"] = "userContextMenu";
+	InteractionKind["Autocomplete"] = "autocomplete";
+	return InteractionKind;
+}({});
+const CommandMetadataKey = Symbol.for("seedcord:command:metadata");
+const InteractionMetadataKey = Symbol.for("seedcord:interaction:metadata");
+const InteractionMiddlewareMetadataKey = Symbol.for("seedcord:middleware:interaction:metadata");
+const EventMiddlewareMetadataKey = Symbol.for("seedcord:middleware:event:metadata");
+const SubscribeMetadataKey = Symbol.for("seedcord:subscribe:metadata");
+const EventMetadataKey = Symbol.for("seedcord:event:metadata");
+const GatedMetadataKey = Symbol.for("seedcord:gated:metadata");
+const WebhookUrlMetadataKey = Symbol.for("seedcord:webhook-url:metadata");
+const InteractionRouteKeys = {
+	["slash"]: Symbol.for("seedcord:interaction:slash"),
+	["button"]: Symbol.for("seedcord:interaction:button"),
+	["modal"]: Symbol.for("seedcord:interaction:modal"),
+	["stringMenu"]: Symbol.for("seedcord:interaction:string-menu"),
+	["userMenu"]: Symbol.for("seedcord:interaction:user-menu"),
+	["roleMenu"]: Symbol.for("seedcord:interaction:role-menu"),
+	["channelMenu"]: Symbol.for("seedcord:interaction:channel-menu"),
+	["mentionableMenu"]: Symbol.for("seedcord:interaction:mentionable-menu"),
+	["messageContextMenu"]: Symbol.for("seedcord:interaction:message-context-menu"),
+	["userContextMenu"]: Symbol.for("seedcord:interaction:user-context-menu"),
+	["autocomplete"]: Symbol.for("seedcord:interaction:autocomplete")
+};
+
+//#endregion
+//#region src/decorators/Command.ts
+const ConfigGuilds = "config";
+function RegisterCommand(scope = "config", guilds = []) {
+	return (ctor) => {
+		const existingMeta = Reflect.getOwnMetadata(CommandMetadataKey, ctor);
+		if (existingMeta) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorCommandAlreadyRegistered, [
+			ctor.name,
+			decoratorCall(existingMeta.scope),
+			decoratorCall(scope)
+		]);
+		if (scope === "global" && guilds.length > 0) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorCommandGlobalWithGuilds, [ctor.name]);
+		if (scope === "guild" && (!Array.isArray(guilds) || guilds.length === 0)) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorCommandGuildWithoutGuilds, [ctor.name]);
+		const meta = scope === "guild" ? {
+			scope,
+			guilds
+		} : { scope };
+		Reflect.defineMetadata(CommandMetadataKey, meta, ctor);
+	};
+}
+function decoratorCall(scope) {
+	if (scope === "global") return "@RegisterCommand('global')";
+	if (scope === "guild") return "@RegisterCommand('guild', [...])";
+	return "@RegisterCommand()";
+}
+
+//#endregion
+//#region src/customId/routing.ts
+/**
+* route decorators store a handler's customId defs here, so the component base can decode
+* against them at runtime.
+*
+* @internal
+*/
+const ComponentDefsKey = Symbol.for("seedcord:custom-id:component-defs");
+/**
+* throws `CustomIdHandlerRouteMissing` when the class has no stored defs. a drifted or corrupt wire
+* throws `StaleCustomId` or `InvalidCustomId`.
+*
+* @internal
+*/
+function decodeComponentRoute(handlerClass, wire) {
+	const defs = Reflect.getMetadata(ComponentDefsKey, handlerClass);
+	if (!defs) throw new SeedcordTypeError(SeedcordErrorCode.CustomIdHandlerRouteMissing, [handlerClass.name]);
+	return decodeFor(defs, wire);
+}
+
+//#endregion
+//#region src/decorators/interactionRoutes.ts
+function interactionRoutesOf(constructor) {
+	const pairs = [];
+	for (const route of Object.values(InteractionKind)) {
+		const meta = Reflect.getMetadata(InteractionRouteKeys[route], constructor);
+		if (isStringArray(meta)) pairs.push([route, meta]);
+	}
+	return pairs;
+}
+function storeInteractionRoute(route, routes, constructor) {
+	const key = InteractionRouteKeys[route];
+	const saved = Reflect.getMetadata(key, constructor);
+	const existing = isStringArray(saved) ? saved : [];
+	const toStore = typeof routes === "string" ? [routes] : routes;
+	Reflect.defineMetadata(key, [...existing, ...toStore], constructor);
+	Reflect.defineMetadata(InteractionMetadataKey, true, constructor);
+}
+function storeComponentRoute(route, defs, constructor) {
+	storeInteractionRoute(route, defs.map((def) => def.prefix), constructor);
+	Reflect.defineMetadata(ComponentDefsKey, defs, constructor);
+}
+function contextMenuRouteOf(kind) {
+	return kind === ApplicationCommandType.User ? "userContextMenu" : "messageContextMenu";
+}
+
+//#endregion
+//#region src/decorators/middleware.ts
+/**
+* Registers an interaction middleware. It runs after the dispatcher builds the handler and before its
+* gates, over that handler's reply surface.
+*
+* @param options - The kinds this middleware runs on and its ordering.
+* @decorator
+*
+* @example
+* ```ts
+* \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button], priority: 10 })
+* class Audit extends InteractionMiddleware<InteractionKind.Button> {
+*     async execute() {
+*         this.logger.info(this.dispatch.routeId);
+*     }
+* }
+* ```
+*
+* @throws A **SeedcordTypeError** when `priority` is not a finite number.
+*/
+function RegisterInteractionMiddleware(options = {}) {
+	return function(ctor) {
+		const priority = Number(options.priority ?? 0);
+		if (!Number.isFinite(priority)) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorInvalidMiddlewarePriority, [ctor.name, String(options.priority)]);
+		if (options.kinds?.length === 0) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorEmptyMiddlewareFilter, [ctor.name, "kinds"]);
+		const metadata = {
+			priority,
+			...options.kinds && { kinds: options.kinds }
+		};
+		Reflect.defineMetadata(InteractionMiddlewareMetadataKey, metadata, ctor);
+	};
+}
+/** @internal */
+function interactionMiddlewareMetaOf(constructor) {
+	return Reflect.getMetadata(InteractionMiddlewareMetadataKey, constructor);
+}
+
+//#endregion
+//#region src/reply/ackLegality.ts
+const showModalReason = {
+	reason: "this interaction was already acknowledged",
+	alternative: "showModal() must be the initial response."
+};
+function deferReason(what) {
+	return {
+		reason: `this interaction was already acknowledged with ${what}`,
+		alternative: "A deferral can only be the initial response."
+	};
+}
+const ILLEGAL = {
+	reply: {
+		"deferred-reply": {
+			reason: "this interaction was already deferred",
+			alternative: "Use edit() to fill the deferred reply or followUp() for a new message."
+		},
+		"deferred-update": {
+			reason: "this interaction was already acknowledged with a deferred update",
+			alternative: "Use followUp() for a new message."
+		},
+		replied: {
+			reason: "this interaction was already replied to",
+			alternative: "Use followUp() for a new message or edit() to rewrite the reply."
+		}
+	},
+	defer: {
+		"deferred-reply": deferReason("a deferred reply"),
+		"deferred-update": deferReason("a deferred update"),
+		replied: deferReason("a reply")
+	},
+	deferUpdate: {
+		"deferred-reply": deferReason("a deferred reply"),
+		"deferred-update": deferReason("a deferred update"),
+		replied: deferReason("a reply")
+	},
+	update: {
+		"deferred-reply": {
+			reason: "this interaction was deferred as a reply",
+			alternative: "The placeholder is yours via edit(). update() rewrites a source message."
+		},
+		replied: {
+			reason: "this interaction was already replied to",
+			alternative: "update() rewrites a source message. Use edit() or followUp() instead."
+		}
+	},
+	followUp: { unacked: {
+		reason: "this interaction has not been acknowledged yet",
+		alternative: "Ack first with reply() or defer()."
+	} },
+	edit: { unacked: {
+		reason: "nothing has been sent yet",
+		alternative: "Send with reply() or defer() first, then edit() rewrites it."
+	} },
+	delete: { unacked: {
+		reason: "nothing has been sent yet",
+		alternative: "Acknowledge first with reply() or defer(), then delete() removes it."
+	} },
+	showModal: {
+		"deferred-reply": showModalReason,
+		"deferred-update": showModalReason,
+		replied: showModalReason
+	}
+};
+const SEND_TARGET = {
+	unacked: "reply",
+	"deferred-reply": "edit",
+	"deferred-update": "followUp",
+	replied: "followUp"
+};
+function checkAckLegality(method, state, routeId, ackedBy) {
+	if (method === "send") return;
+	const illegal = ILLEGAL[method][state];
+	if (!illegal) return;
+	throw new SeedcordError(SeedcordErrorCode.ReplyIllegalAckState, [
+		method,
+		illegal.reason,
+		illegal.alternative,
+		routeId
+	], { cause: ackedBy });
+}
+function sendTarget(state) {
+	return SEND_TARGET[state];
+}
+
+//#endregion
+//#region src/reply/AckTrace.ts
+var AckTrace = class extends Error {
+	constructor(method) {
+		super(`${method}() acknowledged this interaction`);
+		this.name = "AckTrace";
+	}
+};
+
+//#endregion
+//#region src/reply/responseReport.ts
+let replyLogger;
+function logger() {
+	replyLogger ??= new Logger("Reply", { channel: "interactions" });
+	return replyLogger;
+}
+/** @internal */
+function publishResponse(telemetry, report) {
+	const durationMs = performance.now() - report.startedAt;
+	const { routeId } = telemetry.dispatch;
+	const write = {
+		dispatchId: telemetry.dispatch.id,
+		routeId,
+		interactionId: telemetry.interactionId,
+		method: report.method,
+		durationMs
+	};
+	telemetry.bus[PublishDefault]("responseAttempted", report.outcome === "failed" ? {
+		...write,
+		outcome: "failed",
+		messageId: null,
+		error: report.error
+	} : {
+		...write,
+		outcome: "sent",
+		messageId: report.messageId
+	});
+	logger().trace(`${paint.sky.bold(routeId)} ${report.method} ${report.outcome} ${paint.mute("in")} ${Math.round(durationMs)}ms`);
+}
+async function reportedWrite(telemetry, method, write) {
+	const startedAt = performance.now();
+	const result = await attemptWrite(telemetry, method, startedAt, write);
+	publishResponse(telemetry, {
+		method,
+		startedAt,
+		outcome: "sent",
+		messageId: null
+	});
+	return result;
+}
+async function attemptWrite(telemetry, method, startedAt, write) {
+	try {
+		return await write();
+	} catch (caught) {
+		publishResponse(telemetry, {
+			method,
+			startedAt,
+			outcome: "failed",
+			error: asError(caught)
+		});
+		throw caught;
+	}
+}
+
+//#endregion
+//#region src/reply/translateSerialization.ts
+const allOf = new Intl.ListFormat("en", { type: "conjunction" });
+const MAX_DEPTH = 8;
+const OPERATOR_WORD = {
+	"<=": "at most",
+	">=": "at least",
+	"<": "fewer than",
+	">": "more than"
+};
+const KIND_WORD = {
+	string: "a string",
+	number: "a number",
+	boolean: "a boolean",
+	bigint: "a bigint",
+	array: "a list",
+	tuple: "a list",
+	date: "a date",
+	object: "an object"
+};
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : null;
+}
+function firstLine(message) {
+	if (typeof message !== "string") return "unknown validation failure";
+	return message.split("\n")[0] ?? message;
+}
+const GIVEN_PREVIEW_LIMIT = 40;
+function gotPhrase(given) {
+	if (given === void 0) return "nothing";
+	if (given === null) return "null";
+	if (typeof given === "string") {
+		if (given.length === 0) return "an empty string";
+		if (given.length > GIVEN_PREVIEW_LIMIT) return `${given.length} characters`;
+		return JSON.stringify(given);
+	}
+	if (Array.isArray(given)) return given.length === 0 ? "an empty list" : `${given.length} items`;
+	if (typeof given === "number" || typeof given === "bigint" || typeof given === "boolean") return String(given);
+	if (typeof given === "object") return given.constructor?.name ?? "an object";
+	return typeof given;
+}
+function needPhrase(expected, given) {
+	const bounds = [...expected.matchAll(/expected(\.length)?\s*(<=|>=|<|>)\s*(\d+)/g)];
+	if (bounds.length === 0) return null;
+	const phrases = bounds.map(([, lengthPart, operator, limit]) => {
+		const word = OPERATOR_WORD[operator ?? ""] ?? operator ?? "";
+		if (!lengthPart) return `${word} ${limit}`;
+		const unit = typeof given === "string" ? "character" : "item";
+		return `${word} ${limit} ${pluralize(Number(limit), unit)}`;
+	});
+	return allOf.format(phrases);
+}
+function instanceName(expected) {
+	if (typeof expected === "function" && expected.name) return expected.name;
+	return "specific class instance";
+}
+function describeLeaf(record) {
+	if (typeof record.constraint === "string") {
+		const need = typeof record.expected === "string" ? needPhrase(record.expected, record.given) : null;
+		if (need) return `need ${need}, got ${gotPhrase(record.given)}`;
+		return `${firstLine(record.message)}${"given" in record ? ` (got ${gotPhrase(record.given)})` : ""}`;
+	}
+	if (typeof record.expected === "function") return `need a ${instanceName(record.expected)}, got ${gotPhrase(record.given)}`;
+	if (typeof record.validator === "string") {
+		const kind = KIND_WORD[record.validator.replace(/^s\./, "").replace(/\(.*$/, "")];
+		if (kind) return `need ${kind}, got ${gotPhrase(record.given)}`;
+		return `${firstLine(record.message)}, got ${gotPhrase(record.given)}`;
+	}
+	return firstLine(record.message);
+}
+function describeUnion(branches, depth) {
+	const records = [];
+	for (const branch of branches) {
+		const record = asRecord(branch);
+		if (record) records.push(record);
+	}
+	const bounded = records.find((record) => typeof record.constraint === "string");
+	if (bounded) return describeLeaf(bounded);
+	const names = [];
+	let allInstances = records.length > 0;
+	for (const record of records) if (typeof record.expected === "function") names.push(instanceName(record.expected));
+	else allInstances = false;
+	if (allInstances) return `need a ${[...new Set(names)].join(" or ")}, got ${gotPhrase(records[0]?.given)}`;
+	return detailOf(branches[0], depth + 1);
+}
+function detailOf(value, depth) {
+	const record = asRecord(value);
+	if (!record || depth >= MAX_DEPTH) return firstLine(record?.message);
+	if (Array.isArray(record.errors) && record.errors.length > 0) {
+		const errors = record.errors;
+		const [first] = errors;
+		if (Array.isArray(first)) {
+			const [key, inner] = first;
+			return `${String(key)}: ${detailOf(inner, depth + 1)}`;
+		}
+		return describeUnion(errors, depth);
+	}
+	return describeLeaf(record);
+}
+function translateSerializationError(error, componentClass, index, routeId) {
+	const detail = detailOf(error, 0);
+	return new SeedcordError(SeedcordErrorCode.ReplyComponentSerialization, [
+		componentClass,
+		index,
+		detail,
+		routeId
+	], { cause: error });
+}
+
+//#endregion
+//#region src/reply/serializeReply.ts
+function serializeReply(response, routeId) {
+	if (typeof response === "string") try {
+		return { components: [new TextDisplayBuilder().setContent(response).toJSON()] };
+	} catch (error) {
+		throw translateSerializationError(error, "TextDisplayBuilder", 0, routeId);
+	}
+	return {
+		components: response.components.map((component, index) => {
+			try {
+				return component.toJSON();
+			} catch (error) {
+				const name = component.constructor?.name;
+				throw translateSerializationError(error, !name || name === "Object" ? "component" : name, index, routeId);
+			}
+		}),
+		...response.allowedMentions && { allowedMentions: response.allowedMentions },
+		...response.files && { files: response.files }
+	};
+}
+
+//#endregion
+//#region src/gates/Gate.ts
+/**
+* Builds a {@link Gate} from a check. The check refuses by throwing a Notice or a Silence and passes
+* by returning. The required context is inferred from `ctx`, so annotate it as narrowly as the fields
+* the check reads. No annotation defaults to {@link GateContextBase}, an agnostic gate that fits every
+* handler.
+*
+* @typeParam Name - The gate's name, captured as a literal for mismatch errors.
+* @typeParam Ctx - The context the check reads, inferred from the `ctx` annotation.
+*
+* @param name - The gate's name, used in mismatch errors.
+* @param fn - The check, which refuses by throwing a Notice or a Silence and passes by returning.
+*
+* @see {@link defineEffectGate}
+* @see the `@Gated` decorator from your transport package
+*
+* @example
+* ```ts
+* // a gate factory that takes its own option and closes over it
+* function MinRoles(min: number): Gate<GateContextBase, 'MinRoles'> {
+*     return defineGate('MinRoles', (ctx) => {
+*         if (ctx.memberRoleIds.length < min) throw new NotEnoughRoles(min);
+*     });
+* }
+* ```
+*
+* @example
+* ```ts
+* // agnostic gate (no ctx annotation): fits any handler
+* const Owner = defineGate('owner', (ctx) => {
+*     if (!ctx.userId) throw new NotOwner();
+* });
+* ```
+*/
+function defineGate(name, fn) {
+	return {
+		name,
+		check: async (ctx) => fn(ctx)
+	};
+}
+/**
+* Builds an {@link EffectGate} from a `check` and a `commit`. `check` peeks and refuses by throwing, and
+* `commit` applies the side effect, running only once the whole gate set passes so a later refusal never
+* commits. In an `or`, a refusing arm's queued commit is rolled back. This is how {@link Cooldown} peeks
+* in `check` and charges the slot in `commit`.
+*
+* @typeParam Name - The gate's literal name, used to name a mismatch error.
+* @typeParam Ctx - The context both `check` and `commit` read, inferred from the `ctx` annotation.
+*
+* @param name - The gate's name, used in mismatch errors.
+* @param check - Peeks and refuses by throwing, without applying the side effect.
+* @param commit - Applies the side effect, running only after the whole gate set passes.
+*
+* @see {@link defineGate}
+* @see the `@Gated` decorator from your transport package
+* @see {@link Cooldown}
+*
+* @example
+* ```ts
+* // an effect-gate factory that takes its own limit and closes over it
+* function UsesPerDay(max: number): EffectGate<GateContextBase, 'UsesPerDay'> {
+*     return defineEffectGate(
+*         'UsesPerDay',
+*         (ctx) => {
+*             // peek and refuse by throwing. do not mutate yet
+*             if (usedToday(ctx.userId) >= max) throw new OutOfUsesNotice(max);
+*         },
+*         (ctx) => {
+*             // runs only after the whole gate set passes
+*             recordUse(ctx.userId);
+*         }
+*     );
+* }
+* ```
+*/
+function defineEffectGate(name, check, commit) {
+	return {
+		name,
+		check: async (ctx) => check(ctx),
+		commit: async (ctx) => commit(ctx)
+	};
+}
+
+//#endregion
+//#region src/notices/index.ts
+var GateNotice = class extends Notice {
+	render() {
+		return { components: [new NoticeCard(this.message).component] };
+	}
+};
+var NotOwner = class extends GateNotice {
+	constructor(message = "Only the bot owner can use this.") {
+		super(message);
+		this.summary = "be the bot owner";
+	}
+};
+var NotInGuild = class extends GateNotice {
+	constructor(message = "This can only be used in a server.") {
+		super(message);
+		this.summary = "be in a server";
+	}
+};
+var NotInDm = class extends GateNotice {
+	constructor(message = "This can only be used in a direct message.") {
+		super(message);
+		this.summary = "be in a direct message";
+	}
+};
+function retryAt(resetAt) {
+	return `<t:${toEpochSeconds(resetAt)}:R>`;
+}
+var OnCooldown = class extends GateNotice {
+	resetAt;
+	constructor(resetAt, message) {
+		super(message ?? `You are doing that too fast. Try again ${retryAt(resetAt)}.`);
+		this.resetAt = resetAt;
+		this.summary = `try again ${retryAt(resetAt)}`;
+	}
+};
+var NotAllowed = class extends Notice {
+	constructor() {
+		super("not allowed");
+	}
+	render() {
+		return { components: [new NoticeCard("You are not allowed to use this command.").component] };
+	}
+};
+var NeedsAny = class extends Notice {
+	summaries;
+	constructor(summaries) {
+		super("not allowed");
+		this.summaries = [...new Set(summaries)];
+	}
+	render() {
+		const bullets = this.summaries.map((summary) => `• ${summary}`).join("\n");
+		return { components: [new NoticeCard(`You need to meet at least one of these:\n${bullets}`).component] };
+	}
+};
+var MissingRole = class extends GateNotice {
+	constructor(message, roleId) {
+		super(message ?? (roleId ? `You need the <@&${roleId}> role to use this.` : "You do not have the required role."));
+		this.summary = roleId ? `hold the <@&${roleId}> role` : "hold the required role";
+	}
+};
+var MissingPermissions = class extends Notice {
+	subject;
+	missingPerms;
+	customLead;
+	constructor(message, subject, missingPerms) {
+		super(message ?? "A required permission is missing.");
+		this.subject = subject;
+		this.missingPerms = missingPerms;
+		this.customLead = message;
+		const names = missingPerms.join(", ");
+		this.summary = subject === null ? `hold ${names}` : `${subject} needs ${names}`;
+	}
+	render() {
+		const bullets = this.missingPerms.map((perm) => `• ${perm}`).join("\n");
+		const lead = this.customLead ?? `${this.subject === null ? "You are" : `${this.subject} is`} missing the following permission entries:`;
+		return { components: [new NoticeCard(`${lead}\n${bullets}`).component] };
+	}
+};
+var HasDangerousPermissions = class extends Notice {
+	subject;
+	dangerousPerms;
+	customLead;
+	constructor(message, subject, dangerousPerms) {
+		super(message ?? "A dangerous permission is enabled.");
+		this.subject = subject;
+		this.dangerousPerms = dangerousPerms;
+		this.customLead = message;
+		this.summary = `${subject} must not hold ${dangerousPerms.join(", ")}`;
+	}
+	render() {
+		const bullets = this.dangerousPerms.map((perm) => `• ${perm}`).join("\n");
+		const lead = this.customLead ?? `${this.subject} has the following permission entries that must not be enabled:`;
+		return { components: [new NoticeCard(`${lead}\n${bullets}`).component] };
+	}
+};
+
+//#endregion
+//#region src/gates/effects.ts
+const commitQueues = /* @__PURE__ */ new WeakMap();
+function isEffectGate(gate) {
+	return typeof gate.commit === "function";
+}
+async function runCheck(gate, ctx) {
+	await gate.check(ctx);
+	if (!isEffectGate(gate)) return;
+	let queue = commitQueues.get(ctx);
+	if (!queue) {
+		queue = [];
+		commitQueues.set(ctx, queue);
+	}
+	queue.push(() => gate.commit(ctx));
+}
+async function runCommits(ctx) {
+	const queue = commitQueues.get(ctx);
+	if (!queue) return;
+	for (const commit of queue) await commit();
+}
+function discardCommits(ctx) {
+	commitQueues.delete(ctx);
+}
+function markCommits(ctx) {
+	return commitQueues.get(ctx)?.length ?? 0;
+}
+function rollbackCommits(ctx, mark) {
+	const queue = commitQueues.get(ctx);
+	if (queue && queue.length > mark) queue.length = mark;
+}
+
+//#endregion
+//#region src/gates/catalog/options.ts
+function pickNotice(options, makeDefault) {
+	return options?.notice ?? makeDefault(options?.message);
+}
+
+//#endregion
+//#region src/permissions/bits.ts
+const PermissionNames = new Map(Object.entries(PermissionFlagsBits).map(([key, bit]) => [bit, prettify(key)]));
+const ADMINISTRATOR = PermissionFlagsBits.Administrator;
+function nameOf$1(bit) {
+	return PermissionNames.get(bit) ?? String(bit);
+}
+function holds(held, bit) {
+	return (held & ADMINISTRATOR) === ADMINISTRATOR || (held & bit) === bit;
+}
+/** @internal */
+function hasAll(held, scope) {
+	return scope.every((bit) => holds(held, bit));
+}
+/** @internal only reached once hasAll failed, so the administrator bit is absent */
+function missingNames(held, scope) {
+	return scope.reduce((names, bit) => {
+		if ((held & bit) !== bit) names.push(nameOf$1(bit));
+		return names;
+	}, []);
+}
+/** @internal */
+function presentNames(held, scope) {
+	return scope.reduce((names, bit) => {
+		if (holds(held, bit)) names.push(nameOf$1(bit));
+		return names;
+	}, []);
+}
+
+//#endregion
+//#region src/gates/catalog/permissions.ts
+const MEMBER_CHECK = {
+	unresolved: "Your server member data could not be resolved. Try again.",
+	subject: null
+};
+const BOT_CHECK = {
+	unresolved: "The bot's permissions could not be resolved. Try again.",
+	subject: "The bot"
+};
+function refusePermissions(held, scope, options, guildId, kind) {
+	if (held === null) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message ?? (guildId ? kind.unresolved : void 0)));
+	if (hasAll(held, scope)) return;
+	throw pickNotice(options?.missing, (message) => new MissingPermissions(message, kind.subject, missingNames(held, scope)));
+}
+function RequirePermissions(scope, options) {
+	if (options?.in === "guild") return defineGate("RequirePermissions", (ctx) => {
+		refusePermissions(ctx.memberGuildPermissions, scope, options, ctx.guildId, MEMBER_CHECK);
+	});
+	return defineGate("RequirePermissions", (ctx) => {
+		refusePermissions(ctx.memberPermissions, scope, options, ctx.guildId, MEMBER_CHECK);
+	});
+}
+function RequireBotPermissions(scope, options) {
+	if (options?.in === "guild") return defineGate("RequireBotPermissions", (ctx) => {
+		refusePermissions(ctx.appGuildPermissions, scope, options, ctx.guildId, BOT_CHECK);
+	});
+	return defineGate("RequireBotPermissions", (ctx) => {
+		refusePermissions(ctx.appPermissions, scope, options, ctx.guildId, BOT_CHECK);
+	});
+}
+/**
+* Requires the caller to hold `roleId`, read from the member's role ids. Refuses outside a guild first,
+* then when the role is missing. Roles are guild-global, so there is no scope dimension.
+*
+* @param roleId - The role snowflake the caller must hold.
+* @param options - Override each refusal, the outside-guild one with `notInGuild` and the missing-role one with `missingRole`.
+*
+* @see the `@Gated` decorator from your transport package
+*
+* @example
+* ```ts
+* \@Gated(RequireRole('123456789012345678'))
+* \@SlashRoute('vip')
+* class VipHandler extends SlashHandler<'vip'> {
+*     async execute() {
+*         // ...
+*     }
+* }
+* ```
+*/
+function RequireRole(roleId, options) {
+	return defineGate("RequireRole", (ctx) => {
+		if (!ctx.guildId) throw pickNotice(options?.notInGuild, (message) => new NotInGuild(message));
+		if (ctx.memberRoleIds.includes(roleId)) return;
+		throw pickNotice(options?.missingRole, (message) => new MissingRole(message, roleId));
+	});
+}
+
+//#endregion
+//#region src/stops/Silence.ts
+/**
+* Throw to stop a handler with no reply and no report.
+*
+* The framework boundary catches `Silence` before {@link Notice}, makes zero Discord calls, and stops.
+* Ideally you'd only throw this in `EventHandlers` (or `Gates` for those), because it doesn't make sense to
+* leave the user with no reply for an interaction.
+*
+* @example
+* ```ts
+* import { Silence } from '@seedcord/gateway';
+*
+* // a helper under a guildMemberAdd handler, stopping when this guild configured nothing to send
+* const template = await settings.welcome(member.guild.id);
+* if (!template) throw new Silence('no welcome message set');
+* ```
+*/
+var Silence = class extends Error {
+	reason;
+	/**
+	* @param reason - Optional note written only to a debug log, never shown to the user or reported.
+	*/
+	constructor(reason) {
+		super(reason ?? "Silence");
+		this.reason = reason;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region src/miscellaneous/ResolvedEmoji.ts
+/**
+* A resolved custom emoji. Renders as `<:name:id>` in message content, or `<a:name:id>` when animated,
+* and passes straight to a builder's `setEmoji`.
+*/
+var ResolvedEmoji = class {
+	name;
+	id;
+	animated;
+	constructor(name, id, animated = false) {
+		this.name = name;
+		this.id = id;
+		this.animated = animated;
+	}
+	toString() {
+		return `<${this.animated ? "a" : ""}:${this.name}:${this.id}>`;
+	}
+};
+
+//#endregion
+//#region src/pagination/cursor.ts
+const PAGE_MAX = 1e6;
+const SLOT_MAX = 4;
+/** Build the page cursor for a paginator. */
+function pageCursor(prefix) {
+	return new CustomId(prefix).int("page", 0, PAGE_MAX).int("slot", 0, SLOT_MAX);
+}
+
+//#endregion
+//#region src/reply/flags.ts
+function sendFlags(opts) {
+	let flags = MessageFlags.IsComponentsV2;
+	if (opts?.ephemeral ?? true) flags |= MessageFlags.Ephemeral;
+	if (opts?.silent) flags |= MessageFlags.SuppressNotifications;
+	return flags;
+}
+function deferFlags(opts) {
+	return opts?.ephemeral ?? true ? MessageFlags.Ephemeral : 0;
+}
+
+//#endregion
+//#region src/subscribers/ReportThrottle.ts
+var ReportThrottle = class ReportThrottle {
+	windowMs;
+	now;
+	static perCore = /* @__PURE__ */ new WeakMap();
+	static for(core) {
+		let throttle = ReportThrottle.perCore.get(core);
+		if (!throttle) {
+			throttle = new ReportThrottle();
+			ReportThrottle.perCore.set(core, throttle);
+		}
+		return throttle;
+	}
+	windows = /* @__PURE__ */ new Map();
+	constructor(windowMs = 6e4, now = () => Date.now()) {
+		this.windowMs = windowMs;
+		this.now = now;
+	}
+	take(key) {
+		const window = this.windows.get(key);
+		if (window && this.now() - window.lastSentAt < this.windowMs) {
+			window.suppressedSinceSend += 1;
+			return null;
+		}
+		const suppressed = window?.suppressedSinceSend ?? 0;
+		this.windows.set(key, {
+			lastSentAt: this.now(),
+			suppressedSinceSend: 0
+		});
+		return suppressed;
+	}
+	restore(key, suppressed) {
+		const window = this.windows.get(key);
+		if (window) window.suppressedSinceSend += suppressed + 1;
+	}
+};
+
+//#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
+* @typeParam TCore - The transport's Core
+*/
+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, { channel: "subscribers" });
+	}
+};
+
+//#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$-]+$`);
+function isDiscordWebhookUrl(value) {
+	return URL.canParse(value) && DISCORD_WEBHOOK_REGEX.test(value);
+}
+function jsonAttachment(name, description, data) {
+	const content = filterCirculars(data);
+	return {
+		name,
+		description,
+		data: new TextEncoder().encode(JSON.stringify(content, void 0, 2))
+	};
+}
+function breakBackticks(text) {
+	return text.replaceAll("```", "`​`​`");
+}
+const REPORT_BUDGET = 1800;
+function body(value) {
+	const raw = Error.isError(value) ? value.stack ?? `${value.name}: ${value.message}` : String(value);
+	return breakBackticks(stripAnsi(raw));
+}
+function clamp(text, budget) {
+	if (text.length <= budget) return text;
+	return budget > 0 ? `${text.slice(0, budget - 1)}…` : "";
+}
+function omittedLine(count) {
+	return `\n\nand ${count} more ${pluralize(count, "failure")}`;
+}
+function memberReport(members, budget) {
+	const room = Math.max(budget - omittedLine(members.length).length, 0);
+	const share = Math.floor(room / members.length);
+	let report = "";
+	let shown = 0;
+	for (const [index, member] of members.entries()) {
+		const heading = `\n\nFailure ${index + 1} of ${members.length}:\n`;
+		const entry = heading + clamp(body(member), Math.max(share - heading.length, 0));
+		if (report.length + entry.length > room) break;
+		report += entry;
+		shown++;
+	}
+	const hidden = members.length - shown;
+	return hidden > 0 ? report + omittedLine(hidden) : report;
+}
+function errorReport(error) {
+	let head = body(error);
+	if (Error.isError(error.cause)) head += `\n\nCaused by:\n${body(error.cause)}`;
+	const members = error instanceof AggregateError ? error.errors : [];
+	if (members.length === 0) return clamp(head, REPORT_BUDGET);
+	const report = clamp(head, REPORT_BUDGET - omittedLine(members.length).length);
+	return report + memberReport(members, REPORT_BUDGET - report.length);
+}
+var WebhookSeparator = class extends BuilderComponent {
+	constructor() {
+		super("separator");
+		this.instance.setSpacing(SeparatorSpacingSize.Small).setDivider(true);
+	}
+};
+
+//#endregion
+//#region src/subscribers/bases/WebhookSender.ts
+const HTTP_NOT_FOUND = 404;
+const HTTP_UNAUTHORIZED = 401;
+var WebhookSender = class {
+	rest = new REST();
+	route;
+	constructor(url) {
+		const match = /\/webhooks\/(\d+)\/([\w$-]+)$/.exec(url);
+		if (!match?.[1] || !match[2]) throw new SeedcordTypeError(SeedcordErrorCode.CoreWebhookUrlInvalid, [new.target.name]);
+		this.route = Routes.webhook(match[1], match[2]);
+	}
+	async verify() {
+		try {
+			await this.rest.get(this.route, { auth: false });
+			return "ok";
+		} catch (error) {
+			return error instanceof DiscordAPIError && (error.status === HTTP_NOT_FOUND || error.status === HTTP_UNAUTHORIZED) ? "missing" : "unreachable";
+		}
+	}
+	async send(options) {
+		const { flags, username, avatarUrl, components, files } = options;
+		await this.rest.post(this.route, {
+			auth: false,
+			query: new URLSearchParams({
+				with_components: "true",
+				wait: "true"
+			}),
+			body: {
+				flags,
+				username,
+				...avatarUrl && { avatar_url: avatarUrl },
+				components: components.map((component) => component.toJSON()),
+				...files?.length && { attachments: files.map((file, id) => ({
+					id,
+					filename: file.name,
+					description: file.description
+				})) }
+			},
+			...files?.length && { files: files.map((file) => ({
+				name: file.name,
+				data: file.data
+			})) }
+		});
+	}
+};
+
+//#endregion
+//#region src/subscribers/bases/WebhookLog.ts
+/**
+* Base class for subscribers that deliver their event to a Discord webhook.
+*
+* Declare the url's environment variable with `@WebhookUrl` and implement {@link report}. The base
+* resolves the url, validates it, reuses one sender per url, and sends. Registration skips a reporter
+* whose variable is unset and warns at boot.
+*
+* @typeParam KeyOfSubscribers - The subscription key this reporter receives
+* @typeParam TCore - The transport's Core
+*/
+var WebhookLog = class WebhookLog extends Subscriber {
+	static senders = /* @__PURE__ */ new Map();
+	/**
+	* Events sharing this key collapse into one card per minute. Return `null` to send every event.
+	*/
+	throttleKey() {
+		return null;
+	}
+	async execute() {
+		const envKey = WebhookLog.envKeyOf(this.constructor);
+		const url = WebhookLog.urlOf(envKey);
+		if (url === null) throw new SeedcordError(SeedcordErrorCode.ConfigMissingEnv, [envKey]);
+		const key = this.throttleKey();
+		const throttle = ReportThrottle.for(this.core);
+		const suppressed = key === null ? 0 : throttle.take(key);
+		if (suppressed === null) {
+			this.logger.debug(`counted a repeat into the next ${paint.sky.bold(this.constructor.name)} card`);
+			return;
+		}
+		try {
+			const { username, avatarUrl, components, files } = await this.report(suppressed);
+			await WebhookLog.senderFor(url).send({
+				flags: sendFlags({ ephemeral: false }),
+				username: username ?? this.constructor.name,
+				avatarUrl,
+				components,
+				files
+			});
+		} catch (error) {
+			if (key !== null) throttle.restore(key, suppressed);
+			this.logger.error("Webhook report failed", error);
+		}
+	}
+	/** @internal */
+	static senderFor(url) {
+		let sender = WebhookLog.senders.get(url);
+		if (!sender) {
+			sender = new WebhookSender(url);
+			WebhookLog.senders.set(url, sender);
+		}
+		return sender;
+	}
+	/** @internal */
+	static envKeyOf(ctor) {
+		const envKey = Reflect.getMetadata(WebhookUrlMetadataKey, ctor);
+		if (!envKey) throw new SeedcordTypeError(SeedcordErrorCode.DecoratorWebhookUrlMissing, [ctor.name]);
+		return envKey;
+	}
+	/** @internal Returns null when the env var is unset, throws when set but malformed. */
+	static urlOf(envKey) {
+		const raw = Envapter.get(envKey)?.trim();
+		if (!raw) return null;
+		if (!isDiscordWebhookUrl(raw)) throw new SeedcordError(SeedcordErrorCode.ConfigInvalidEnv, [envKey, "the webhook URL from the channel's Integrations settings"]);
+		return raw;
+	}
+};
+
+//#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() {
+*   }
+* }
+* ```
+* @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/decorators/WebhookUrl.ts
+/**
+* Declares the environment variable a {@link WebhookLog} reporter reads its webhook url from.
+*
+* An unset variable disables the reporter with a boot warning. A set but malformed value throws
+* at boot.
+*
+* @param envKey - The environment variable name holding the webhook url
+* @decorator
+* @example
+* ```ts
+* \@Subscribe('memberBanned')
+* \@WebhookUrl('BAN_LOG_WEBHOOK_URL')
+* class BanLog extends WebhookLog<'memberBanned'> {
+*   report() {
+*     return { components: [new BanCard(this.data).component] };
+*   }
+* }
+* ```
+*/
+function WebhookUrl(envKey) {
+	return function(constructor) {
+		Reflect.defineMetadata(WebhookUrlMetadataKey, envKey, constructor);
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.152.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/subscribers/default/HandledException.ts
+let HandledException = class HandledException extends WebhookLog {
+	throttleKey() {
+		return `handledException:${this.data.origin}:${this.data.denial.name}`;
+	}
+	report(suppressed) {
+		return {
+			username: "Handled Exception",
+			components: [new HandledExceptionContainer(this.data, suppressed).component],
+			files: [jsonAttachment("source.json", "The raw source the fault came from", this.data.source.raw)]
+		};
+	}
+};
+HandledException = __decorate([Subscribe("handledException"), WebhookUrl("HANDLED_EXCEPTION_WEBHOOK_URL")], HandledException);
+var HandledExceptionContainer = class extends BuilderComponent {
+	constructor(data, suppressed) {
+		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\`\`\`${breakBackticks(causeStack(denial))}\`\`\``)).addSeparatorComponents(new WebhookSeparator().component).addTextDisplayComponents((text) => text.setContent("### Source")).addFileComponents((file) => file.setURL("attachment://source.json"));
+		this.addSuppressedCount(suppressed);
+	}
+	addSuppressedCount(suppressed) {
+		if (suppressed === 0) return;
+		this.instance.addTextDisplayComponents((text) => text.setContent(`-# ${suppressed} more of these since the last report`));
+	}
+};
+function faultSummary(denial, source) {
+	const head = stripAnsi(`### 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}\``;
+}
+function causeStack(denial) {
+	const { cause } = denial;
+	if (Error.isError(cause)) return stripAnsi(cause.stack ?? cause.message);
+	if (typeof cause === "string") return stripAnsi(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 stripAnsi(denial.stack ?? "No cause recorded.");
+}
+
+//#endregion
+//#region src/subscribers/default/UnknownException.ts
+let UnknownException = class UnknownException extends WebhookLog {
+	throttleKey() {
+		return `unknownException:${this.data.origin}:${nameOf(this.data.error)}`;
+	}
+	report(suppressed) {
+		const { metadata } = this.data;
+		return {
+			username: "Unknown Exception",
+			components: [new UnhandledErrorContainer(this.data, suppressed).component],
+			files: metadata ? [jsonAttachment("metadata.json", "Metadata associated with the error", metadata)] : void 0
+		};
+	}
+};
+UnknownException = __decorate([Subscribe("unknownException"), WebhookUrl("UNKNOWN_EXCEPTION_WEBHOOK_URL")], UnknownException);
+function nameOf(error) {
+	return error.name === "Error" ? error.constructor.name : error.name;
+}
+var UnhandledErrorContainer = class extends BuilderComponent {
+	constructor(data, suppressed) {
+		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\`\`\`${errorReport(error)}\`\`\``));
+		this.addTimestampsIfAvailable(error);
+		this.addMetadataIfAvailable(metadata);
+		this.addSuppressedCount(suppressed);
+	}
+	addSuppressedCount(suppressed) {
+		if (suppressed === 0) return;
+		this.instance.addTextDisplayComponents((text) => text.setContent(`-# ${suppressed} more of these since the last report`));
+	}
+	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 = timestampFromSnowflake(snowflake);
+		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/slots.ts
+const RegisterDefaults = Symbol("seedcord:bus:register-defaults");
+const VerifyWebhooks = Symbol("seedcord:bus:verify-webhooks");
+const RegisteredCount = Symbol("seedcord:bus:registered-count");
+const RegisterSubscriber = Symbol("seedcord:bus:register");
+const UnregisterSubscriber = Symbol("seedcord:bus:unregister");
+
+//#endregion
+//#region src/subscribers/Bus.ts
+const loggerSlot = Symbol("seedcord:bus:logger");
+/**
+* Registers and dispatches subscribers. Subscribers run on a programmatic or framework publish.
+* Accessed via `core.bus`. Do not construct it directly.
+*/
+var Bus = class extends TypedEventEmitter {
+	core;
+	logger = new Logger("Subscribers", { channel: "subscribers" });
+	/** @internal */
+	[loggerSlot] = this.logger;
+	subscribersMap = /* @__PURE__ */ new Map();
+	executedOnce = /* @__PURE__ */ new Set();
+	webhookProbes = /* @__PURE__ */ new Map();
+	constructor(core) {
+		super();
+		this.core = core;
+	}
+	/** @internal keep this inside start(). a bad webhook url thrown outside it never resets the singleton guard */
+	[RegisterDefaults]() {
+		this[RegisterSubscriber](registrationFor(UnknownException));
+		this[RegisterSubscriber](registrationFor(HandledException));
+	}
+	/** @internal */
+	[RegisterSubscriber](registration) {
+		if (!this.probeWebhook(registration.ctor)) return;
+		for (const key of registration.keys) {
+			let registrations = this.subscribersMap.get(key);
+			if (!registrations) {
+				registrations = [];
+				this.subscribersMap.set(key, registrations);
+			}
+			registrations.push(registration);
+		}
+	}
+	/** @internal */
+	[UnregisterSubscriber](ctor, keys) {
+		for (const key of keys ?? [...this.subscribersMap.keys()]) {
+			const registrations = this.subscribersMap.get(key);
+			if (!registrations) continue;
+			const index = registrations.findIndex((entry) => entry.ctor === ctor);
+			if (index !== -1) registrations.splice(index, 1);
+		}
+	}
+	/** @internal */
+	get [RegisteredCount]() {
+		return [...this.subscribersMap.values()].reduce((total, entries) => total + entries.length, 0);
+	}
+	/** @internal registration already dropped every reporter with no url set */
+	async [VerifyWebhooks]() {
+		const missing = [];
+		await Promise.all([...this.webhookProbes].map(async ([url, envKeys]) => {
+			const result = await WebhookLog.senderFor(url).verify();
+			if (result === "missing") missing.push(...envKeys);
+			else if (result === "unreachable") this.logger.warn(`could not verify webhook at ${envKeys.map((key) => paint.amber.bold(key)).join(", ")}`);
+		}));
+		if (missing.length > 0) throw new SeedcordError(SeedcordErrorCode.ConfigWebhookNotFound, [missing.join(", ")]);
+	}
+	probeWebhook(ctor) {
+		if (!(ctor.prototype instanceof WebhookLog)) return true;
+		const envKey = WebhookLog.envKeyOf(ctor);
+		const url = WebhookLog.urlOf(envKey);
+		if (url === null) {
+			this.logger.warn(`${paint.sky.bold(ctor.name)} disabled, ${paint.amber.bold(envKey)} is not set`);
+			return false;
+		}
+		const envKeys = this.webhookProbes.get(url) ?? [];
+		if (!envKeys.includes(envKey)) envKeys.push(envKey);
+		this.webhookProbes.set(url, envKeys);
+		return true;
+	}
+	/**
+	* Publishes an event to its subscribers and native listeners.
+	*
+	* Fire-and-forget. Subscriber handlers run asynchronously and this returns before they finish.
+	* Errors thrown by a subscriber or by an `on()` listener are caught and logged, never surfaced
+	* here. One throwing listener does not stop the others. Subscribers on one key run concurrently
+	* and carry no ordering guarantee. A `'once'` subscriber is marked as executed when it starts,
+	* even if it throws. It never runs twice.
+	*
+	* The framework's own keys are excluded. Subscribe to those and listen with `on`. The framework
+	* is their only publisher.
+	*
+	* @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) {
+		return this.dispatchKey(event, data);
+	}
+	/**
+	* @deprecated Call {@link Bus.publish} to reach subscribers and listeners together.
+	* @throws A **SeedcordTypeError** every time, with `CoreBusEmitUnavailable`. `emit` reaches only the `on()` listeners.
+	*/
+	emit(event, ..._args) {
+		throw new SeedcordTypeError(SeedcordErrorCode.CoreBusEmitUnavailable, [String(event)]);
+	}
+	/** @internal the framework's own publish path, keyed by a symbol no public entry exports */
+	[PublishDefault](event, data) {
+		return this.dispatchKey(event, data);
+	}
+	dispatchKey(event, data) {
+		this.processSubscriber(event, data);
+		return this.emitSafe(event, ...[data]);
+	}
+	onListenerError(error, event) {
+		this.logger.error(`listener for ${String(event)} threw`, error);
+	}
+	async processSubscriber(subscriberName, data) {
+		const registrations = this.subscribersMap.get(subscriberName);
+		if (!registrations) return;
+		const pending = registrations.reduce((acc, entry) => {
+			if (entry.frequency === "once") {
+				if (this.executedOnce.has(entry)) return acc;
+				this.executedOnce.add(entry);
+			}
+			acc.push(this.runSubscriber(entry, subscriberName, data));
+			return acc;
+		}, []);
+		await Promise.allSettled(pending);
+	}
+	async runSubscriber(entry, subscriberName, data) {
+		let name = "<unresolved>";
+		try {
+			const Ctor = entry.ctor;
+			name = Ctor.name;
+			await new Ctor(data, this.core).execute();
+		} catch (err) {
+			this.logger.error(`Error in subscriber ${paint.mute(String(subscriberName))} handler ${paint.sky.bold(name)}:`, err);
+		}
+	}
+};
+/** @internal */
+function registrationFor(ctor) {
+	const meta = Reflect.getMetadata(SubscribeMetadataKey, ctor);
+	return {
+		keys: [meta.subscriber],
+		frequency: meta.frequency ?? "on",
+		ctor
+	};
+}
+/** @internal */
+function busLoggerOf(bus) {
+	return bus[loggerSlot];
+}
+
+//#endregion
+export { RegisterInteractionMiddleware as $, rollbackCommits as A, guardedAccessor as At, NotInGuild as B, isBuilderComponentClass as Bt, PermissionNames as C, warnLinks as Ct, pickNotice as D, linkCommands as Dt, presentNames as E, indexById as Et, MissingPermissions as F, skippedNote as Ft, serializeReply as G, OnCooldown as H, Notice as Ht, MissingRole as I, contextMenuLeaves as It, publishResponse as J, translateSerializationError as K, NeedsAny as L, NoticeCard as Lt, runCommits as M, commandsRoute as Mt, GateNotice as N, globalFirst as Nt, discardCommits as O, accessorStore as Ot, HasDangerousPermissions as P, scopeIdsOf as Pt, sendTarget as Q, NotAllowed as R, BuilderComponent as Rt, RequireRole as S, installLinks as St, missingNames as T, commandRefOf as Tt, defineEffectGate as U, NotOwner as V, bindBotColor as Vt, defineGate as W, AckTrace as X, reportedWrite as Y, checkAckLegality as Z, pageCursor as _, SubscribeMetadataKey as _t, RegisterSubscriber as a, ComponentDefsKey as at, RequireBotPermissions as b, Commands as bt, VerifyWebhooks as c, RegisterCommand as ct, WebhookLog as d, EventMiddlewareMetadataKey as dt, interactionMiddlewareMetaOf as et, Subscriber as f, GatedMetadataKey as ft, PAGE_MAX as g, InteractionRouteKeys as gt, sendFlags as h, InteractionMiddlewareMetadataKey as ht, RegisterDefaults as i, storeInteractionRoute as it, runCheck as j, GLOBAL_ID as jt, markCommits as k, clearStore as kt, WebhookUrl as l, CommandMetadataKey as lt, deferFlags as m, InteractionMetadataKey as mt, busLoggerOf as n, interactionRoutesOf as nt, RegisteredCount as o, decodeComponentRoute as ot, ReportThrottle as p, InteractionKind as pt, attemptWrite as q, registrationFor as r, storeComponentRoute as rt, UnregisterSubscriber as s, ConfigGuilds as st, Bus as t, contextMenuRouteOf as tt, Subscribe as u, EventMetadataKey as ut, ResolvedEmoji as v, WebhookUrlMetadataKey as vt, hasAll as w, commandKey as wt, RequirePermissions as x, ContextMenus as xt, Silence as y, CommandInjector as yt, NotInDm as z, RowComponent as zt };
+//# sourceMappingURL=subscribers-Ce3SWy23.mjs.map