@seedcord/http 0.10.2 → 0.11.0-next.0

package/dist/{edge.index-DCP1BD6f.mjs → username-3UsqzTSd.mjs}

@@ -1,18 +1,242 @@
 import "reflect-metadata";
-import { GatedMetadataKey, MiddlewareRegistry, PublishDefault, RegisterDefaults, RegisterSubscriber, SubscribeMetadataKey, accessorStore, asError, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, interactionMiddleware, interactionRoutesOf, isEmojiTuple, outcomeFor, queuedMsFor, registrationFor, reportDispatch, reportedWrite, resultFor, runAfter, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
-import { SeedcordError, SeedcordTypeError, applicationIdFromToken, validateDiscordToken } from "@seedcord/errors/internal";
-import { Logger } from "@seedcord/logger";
-import { Converters, Envapter } from "envapt";
-import { DiscordAPIError, REST } from "@discordjs/rest";
-import { ArraySourceBase, BaseHandler, BaseReplySender, Bus, CursorSourceBase, DispatchContext, Fault, InteractionKind, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, Subscriber, WebhookLog } from "@seedcord/core";
+import { COMMAND_DEPLOY_TIMEOUT_MS, CommandRegistry, FixedScope, GatedMetadataKey, InteractionMetadataKey, InteractionMiddlewareMetadataKey, MiddlewareRegistry, PublishDefault, SubscriberLoader, accessorStore, attachmentsOf, clearStore, currentApplication, decodeComponentRoute, deferFlags, guardedAccessor, interactionMiddleware, interactionRoutesOf, logUnknownFault, outcomeFor, queuedMsFor, readBotToken, reportDispatch, reportedWrite, resolveEmojis, resultFor, runAfter, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { Plugin } from "@seedcord/core/plugin";
 import { SeedcordErrorCode, paint } from "@seedcord/errors";
-import { MemoryRateLimiter } from "@seedcord/rate-limiter";
+import { SeedcordError, SeedcordTypeError } from "@seedcord/errors/internal";
 import { ApplicationCommandOptionType, ApplicationCommandType, ChannelType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
+import { Collection } from "@discordjs/collection";
+import { ArraySourceBase, BaseHandler, BaseReplySender, Bus, CursorSourceBase, DispatchContext, Fault, InteractionKind, Notice, PaginatorBase, RepliableHandler, ResolvedEmoji, Silence, StartupPhase, Subscriber, WebhookLog } from "@seedcord/core";
+import { Logger } from "@seedcord/logger";
+import { HmrModuleHandler, HmrModuleHandler as HmrModuleHandler$1 } from "@seedcord/core/hmr";
+import { MemoryRateLimiter } from "@seedcord/rate-limiter";
+import { formatFilePath, importFiles } from "@seedcord/utils";
 import { API } from "@discordjs/core/http-only";
-import { buildSlashRoute } from "@seedcord/utils/internal";
+import { asError, buildSlashRoute } from "@seedcord/utils/internal";
+import { Envapter } from "envapt";
+import { DiscordAPIError, REST } from "@discordjs/rest";
 import { prefixOf } from "@seedcord/custom-id";
-import { Collection } from "@discordjs/collection";
 
+//#region src/Plugin.ts
+const HTTP_SCOPE = { transport: "http" };
+/**
+* Base class for an HTTP plugin, binding `this.core` to the HTTP {@link Core}.
+*
+* A plugin that runs on either transport extends the base from `@seedcord/core/plugin`, whose
+* `this.core` is typed to the shared members only.
+*
+* @typeParam Opts - The transport and runtime the plugin declares.
+*/
+var Plugin$1 = class extends Plugin {
+	/** @internal */
+	static [FixedScope] = HTTP_SCOPE;
+};
+
+//#endregion
+//#region src/inputs/pick.ts
+function pick(ids, bucket) {
+	const found = new Collection();
+	if (!ids || !bucket) return found;
+	for (const id of ids) if (Object.hasOwn(bucket, id)) found.set(id, bucket[id]);
+	return found;
+}
+
+//#endregion
+//#region src/inputs/ModalFields.ts
+const FIELD_KINDS = {
+	[ComponentType.TextInput]: {
+		label: "a text input",
+		getter: "getTextInputValue"
+	},
+	[ComponentType.StringSelect]: {
+		label: "a string select",
+		getter: "getStringSelectValues"
+	},
+	[ComponentType.UserSelect]: {
+		label: "a user select",
+		getter: "getSelectedUsers"
+	},
+	[ComponentType.RoleSelect]: {
+		label: "a role select",
+		getter: "getSelectedRoles"
+	},
+	[ComponentType.MentionableSelect]: {
+		label: "a mentionable select",
+		getter: "getSelectedMentionables"
+	},
+	[ComponentType.ChannelSelect]: {
+		label: "a channel select",
+		getter: "getSelectedChannels"
+	},
+	[ComponentType.FileUpload]: {
+		label: "a file upload",
+		getter: "getUploadedFiles"
+	},
+	[ComponentType.RadioGroup]: {
+		label: "a radio group",
+		getter: "getRadioGroup"
+	},
+	[ComponentType.CheckboxGroup]: {
+		label: "a checkbox group",
+		getter: "getCheckboxGroup"
+	},
+	[ComponentType.Checkbox]: {
+		label: "a checkbox",
+		getter: "getCheckbox"
+	}
+};
+function nameOfChannelType(type) {
+	return ChannelType[type] ?? String(type);
+}
+function listOf(values) {
+	return values ?? [];
+}
+function isKind(entry, kinds) {
+	return kinds.includes(entry.type);
+}
+/**
+* The fields a modal carries, read by custom id.
+*
+* A select getter resolves the ids its field picked against the interaction's `resolved` data and returns a
+* `Collection` keyed by id. A field that picked nothing returns null.
+*
+* @throws A **SeedcordTypeError** from every getter when no field in the modal has that custom id.
+* @throws A **SeedcordTypeError** from every getter when the field holds a kind that getter does not read. The message gives the getter that does.
+* @throws A **SeedcordTypeError** from a select getter called with `required` when its field picked nothing.
+*/
+var ModalFields = class {
+	entries = /* @__PURE__ */ new Map();
+	resolved;
+	constructor(data) {
+		this.resolved = data.resolved;
+		for (const component of data.components ?? []) {
+			if ("components" in component) for (const child of component.components) this.entries.set(child.custom_id, child);
+			if ("component" in component) this.entries.set(component.component.custom_id, component.component);
+		}
+	}
+	entry(customId) {
+		const found = this.entries.get(customId);
+		if (!found) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldNotFound, [customId]);
+		return found;
+	}
+	field(customId, kinds) {
+		const entry = this.entry(customId);
+		if (!isKind(entry, kinds)) {
+			const known = FIELD_KINDS[entry.type];
+			const args = known ? [
+				customId,
+				known.label,
+				known.getter
+			] : [customId, `component type ${entry.type}`];
+			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldWrongKind, [...args]);
+		}
+		return entry;
+	}
+	selected(customId, kinds, bucket, required) {
+		const { values } = this.field(customId, kinds);
+		const found = pick(values, bucket);
+		if (found.size > 0) return found;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getField(customId, kind) {
+		return kind === void 0 ? this.entry(customId) : this.field(customId, [kind]);
+	}
+	getTextInputValue(customId) {
+		return this.field(customId, [ComponentType.TextInput]).value;
+	}
+	getStringSelectValues(customId) {
+		return listOf(this.field(customId, [ComponentType.StringSelect]).values);
+	}
+	getSelectedUsers(customId, required = false) {
+		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.users, required);
+	}
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	getSelectedMembers(customId) {
+		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.members, false);
+	}
+	getSelectedRoles(customId, required = false) {
+		const kinds = [ComponentType.RoleSelect, ComponentType.MentionableSelect];
+		return this.selected(customId, kinds, this.resolved?.roles, required);
+	}
+	getSelectedChannels(customId, required = false, channelTypes = []) {
+		const kinds = [ComponentType.ChannelSelect];
+		const picked = this.selected(customId, kinds, this.resolved?.channels, required);
+		if (!picked || channelTypes.length === 0) return picked;
+		for (const found of picked.values()) {
+			if (channelTypes.includes(found.type)) continue;
+			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldChannelType, [
+				customId,
+				nameOfChannelType(found.type),
+				channelTypes.map(nameOfChannelType)
+			]);
+		}
+		return picked;
+	}
+	getSelectedMentionables(customId, required = false) {
+		const { values } = this.field(customId, [ComponentType.MentionableSelect]);
+		const resolved = this.resolved;
+		const picked = {
+			users: pick(values, resolved?.users),
+			members: pick(values, resolved?.members),
+			roles: pick(values, resolved?.roles)
+		};
+		if (picked.users.size + picked.members.size + picked.roles.size > 0) return picked;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getUploadedFiles(customId, required = false) {
+		const kinds = [ComponentType.FileUpload];
+		return this.selected(customId, kinds, this.resolved?.attachments, required);
+	}
+	getRadioGroup(customId, required = false) {
+		const value = this.field(customId, [ComponentType.RadioGroup]).value ?? null;
+		if (value !== null) return value;
+		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+		return null;
+	}
+	getCheckboxGroup(customId) {
+		return listOf(this.field(customId, [ComponentType.CheckboxGroup]).values);
+	}
+	getCheckbox(customId) {
+		return this.field(customId, [ComponentType.Checkbox]).value;
+	}
+};
+
+//#endregion
+//#region src/emojis/EmojiInjector.ts
+const emojiStorage = accessorStore();
+/**
+* The bot's resolved emojis, keyed by {@link EmojiMap}. A node bot fills these during startup. 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 key that was not filled.
+*/
+const Emojis = guardedAccessor("Emojis", emojiStorage);
+function installEmojis(emojis) {
+	clearStore(emojiStorage);
+	for (const [key, { name, id, animated }] of Object.entries(emojis)) emojiStorage[key] = new ResolvedEmoji(name, id, animated);
+}
+var EmojiInjector = class {
+	core;
+	logger = new Logger("Emojis", { channel: "bot" });
+	constructor(core) {
+		this.core = core;
+	}
+	async init() {
+		const configured = this.core.config.bot.emojis;
+		if (!configured || Object.keys(configured).length === 0) {
+			installEmojis({});
+			this.logger.debug("No emojis configured, skipping emoji injection.");
+			return;
+		}
+		installEmojis(await resolveEmojis(this.core.rest, this.core.applicationId, configured));
+		this.logger.utils.summary("Loaded emojis", { emojis: Object.keys(emojiStorage).length });
+	}
+};
+
+//#endregion
 //#region src/reply/ReplySender.ts
 function wireAllowedMentions(mentions) {
 	const { repliedUser, ...wire } = mentions;
@@ -170,484 +394,359 @@ var RepliableHandler$1 = class extends RepliableHandler {
 };
 
 //#endregion
-//#region src/gates/context.ts
-function interactionGateContext(payload, core, dispatch) {
-	const member = payload.member ?? null;
-	const resolved = member?.user ?? payload.user;
-	return {
-		kind: "interaction",
-		core,
-		dispatch,
-		interaction: payload,
-		user: resolved,
-		member,
-		userId: resolved?.id ?? null,
-		guildId: payload.guild_id ?? null,
-		channelId: payload.channel?.id ?? null,
-		memberRoleIds: member?.roles ?? [],
-		memberPermissions: member ? BigInt(member.permissions) : null,
-		appPermissions: BigInt(payload.app_permissions),
-		declaredRoute: null
-	};
-}
+//#region src/handlers/interaction/InteractionHandler.ts
+/**
+* Shared base the repliable interaction handlers extend.
+*
+* Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
+* {@link ModalHandler}, or one of the select menu bases instead. This class adds `showModal` on top
+* of the reply members.
+*
+* @typeParam Event - The repliable interaction type this handler processes
+*/
+var InteractionHandler = class extends RepliableHandler$1 {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch);
+	}
+	/**
+	* Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
+	* compile time (Discord forbids a modal in response to a modal).
+	*/
+	showModal(modal) {
+		return this.sender.showModal(modal);
+	}
+};
 
 //#endregion
-//#region src/dispatch/slashRouteOf.ts
-function slashRouteOf(data) {
-	const first = data.options?.[0];
-	if (first?.type === ApplicationCommandOptionType.SubcommandGroup) return buildSlashRoute(data.name, first.options[0]?.name, first.name);
-	if (first?.type === ApplicationCommandOptionType.Subcommand) return buildSlashRoute(data.name, first.name);
-	return data.name;
-}
+//#region src/handlers/interaction/InteractionMiddleware.ts
+/**
+* Base class for interaction middleware on the HTTP transport.
+*
+* Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+* reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+* `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable
+* kind.
+*
+* @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+*
+* @example
+* ```ts
+* \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+* class Audit extends InteractionMiddleware<InteractionKind.Button> {
+*     async execute() {
+*         this.logger.info(this.event.data.custom_id);
+*     }
+* }
+* ```
+*/
+var InteractionMiddleware = class extends RepliableHandler$1 {
+	constructor(event, core, dispatch, sender) {
+		super(event, core, dispatch, sender);
+	}
+};
 
 //#endregion
-//#region src/dispatch/reportFault.ts
-function reportFault(error, uuid, dispatch, payload, core) {
-	const source = interactionSource(payload);
-	const from = {
-		uuid,
-		dispatchId: dispatch.id,
-		origin: dispatch.routeId
-	};
-	if (error instanceof Notice && source) core.bus[PublishDefault]("handledException", {
-		denial: error,
-		...from,
-		source
-	});
-	else core.bus[PublishDefault]("unknownException", {
-		...from,
-		error,
-		...actors(payload),
-		metadata: payload
-	});
-}
-function actors(payload) {
-	const user = payload.member?.user ?? payload.user;
-	return {
-		guild: void 0,
-		user: user ? {
-			id: user.id,
-			username: user.username
-		} : void 0
-	};
-}
-function interactionSource(payload) {
-	const user = payload.member?.user ?? payload.user;
-	if (!user) return null;
-	const common = {
-		kind: "interaction",
-		userId: user.id,
-		guildId: payload.guild_id ?? null,
-		channelId: payload.channel?.id ?? null,
-		interactionId: payload.id,
-		raw: payload
-	};
-	if (payload.type === InteractionType.ApplicationCommand) {
-		const { data } = payload;
-		const isSlash = data.type === ApplicationCommandType.ChatInput;
-		return {
-			...common,
-			interactionKind: isSlash ? "slash" : "context-menu",
-			command: isSlash ? slashRouteOf(data) : data.name,
-			customId: null
-		};
+//#region src/inputs/HttpSlashOptions.ts
+var HttpSlashOptions = class {
+	leaves = /* @__PURE__ */ new Map();
+	resolved;
+	constructor(data) {
+		this.resolved = data.resolved;
+		let options = data.options ?? [];
+		const first = options[0];
+		if (first?.type === ApplicationCommandOptionType.SubcommandGroup) options = first.options;
+		const second = options[0];
+		if (second?.type === ApplicationCommandOptionType.Subcommand) options = second.options ?? [];
+		for (const option of options) if (option.type !== ApplicationCommandOptionType.Subcommand && option.type !== ApplicationCommandOptionType.SubcommandGroup) this.leaves.set(option.name, option);
 	}
-	if (payload.type === InteractionType.ModalSubmit) return {
-		...common,
-		interactionKind: "modal",
-		command: null,
-		customId: payload.data.custom_id
-	};
-	if (payload.type === InteractionType.MessageComponent) {
-		const isButton = payload.data.component_type === ComponentType.Button;
-		return {
-			...common,
-			interactionKind: isButton ? "button" : "select",
-			command: null,
-			customId: payload.data.custom_id
-		};
+	getString(name) {
+		const leaf = this.leaves.get(name);
+		return leaf?.type === ApplicationCommandOptionType.String ? leaf.value : null;
 	}
-	return null;
-}
-
-//#endregion
-//#region src/dispatch/dispatchInteraction.ts
-let dispatchLogger;
-function logger() {
-	dispatchLogger ??= new Logger("Dispatcher", { channel: "interactions" });
-	return dispatchLogger;
-}
-function noLifecycle(accessor) {
-	throw new SeedcordError(SeedcordErrorCode.CoreLifecycleUnavailable, [accessor]);
-}
-const edgeShutdown = { addTask: () => noLifecycle("shutdown") };
-const edgeStartup = { addTask: () => noLifecycle("startup") };
-const EDGE_SWEEPERS = {
-	hashSweepInterval: 0,
-	handlerSweepInterval: 0
-};
-function edgeRestOptions(given = {}) {
-	for (const key of Object.keys(EDGE_SWEEPERS)) if (given[key] !== void 0) throw new SeedcordError(SeedcordErrorCode.ConfigEdgeRestSweeper, [key]);
-	return {
-		...given,
-		...EDGE_SWEEPERS
-	};
-}
-function createCore(config, token) {
-	const draft = {
-		config,
-		rateLimiter: config.store ?? new MemoryRateLimiter(),
-		rest: new REST(edgeRestOptions(config.bot.restOptions)).setToken(token),
-		shutdown: edgeShutdown,
-		startup: edgeStartup,
-		get applicationId() {
-			return applicationIdFromToken(token);
-		}
-	};
-	draft.bus = new Bus(draft);
-	return draft;
-}
-const HARMLESS_API_CODES = /* @__PURE__ */ new Set([
-	RESTJSONErrorCodes.UnknownInteraction,
-	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
-	RESTJSONErrorCodes.UnknownMessage
-]);
-async function sendGuarded(routeId, send) {
-	try {
-		await send();
-	} catch (error) {
-		if (error instanceof DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
-			logger().debug(`boundary send hit harmless code ${paint.amber(String(error.code))}`);
-			return;
-		}
-		logger().error(`boundary send failed for route ${paint.sky.bold(routeId)}`, error);
+	getInteger(name) {
+		const leaf = this.leaves.get(name);
+		return leaf?.type === ApplicationCommandOptionType.Integer ? numeric(leaf.value) : null;
 	}
-}
-async function respondEmptyChoices(scope) {
-	const telemetry = {
-		bus: scope.core.bus,
-		dispatch: scope.dispatch,
-		interactionId: scope.payload.id
-	};
-	await reportedWrite(telemetry, "respond", () => scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
-		type: InteractionResponseType.ApplicationCommandAutocompleteResult,
-		data: { choices: [] }
-	} }));
-}
-function renderContext(scope, uuid) {
-	const { dispatch } = scope;
-	const developerUsername = scope.core.config.notifications?.developerUsername;
-	return developerUsername === void 0 ? {
-		uuid,
-		dispatch
-	} : {
-		uuid,
-		developerUsername,
-		dispatch
-	};
-}
-async function handleNotice(notice, uuid, scope) {
-	if (notice.report) {
-		logger().error(`${notice.name}: ${paint.mute(uuid)}`, notice);
-		reportFault(notice, uuid, scope.dispatch, scope.payload, scope.core);
+	getNumber(name) {
+		const leaf = this.leaves.get(name);
+		return leaf?.type === ApplicationCommandOptionType.Number ? numeric(leaf.value) : null;
 	}
-	const { sender } = scope;
-	if (!sender) {
-		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
-		return;
+	getBoolean(name) {
+		const leaf = this.leaves.get(name);
+		return leaf?.type === ApplicationCommandOptionType.Boolean ? leaf.value : null;
 	}
-	const response = notice.render(renderContext(scope, uuid));
-	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: notice.ephemeral }));
-}
-async function handleRawFault(error, uuid, scope) {
-	const { core, sender } = scope;
-	if (core.config.errors?.errorStack ?? false) logger().error(paint.mute(uuid), error);
-	else logger().error(`${paint.mute(uuid)} | ${error.message}`);
-	reportFault(error, uuid, scope.dispatch, scope.payload, core);
-	if (!sender) {
-		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
-		return;
+	getUser(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
+		return this.resolved?.users?.[leaf.value] ?? null;
 	}
-	const Override = core.config.errors?.defaultError;
-	const response = (Override ? new Override(uuid) : new Fault()).render(renderContext(scope, uuid));
-	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
-}
-async function handleFault(caught, scope) {
-	if (caught instanceof Silence) {
-		if (caught.reason !== void 0 && (scope.core.config.errors?.logSilences ?? true)) logger().debug(`Silence: ${caught.reason}`);
-		return;
+	getMember(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
+		return this.resolved?.members?.[leaf.value] ?? null;
 	}
-	const uuid = crypto.randomUUID();
-	if (caught instanceof Notice) {
-		await handleNotice(caught, uuid, scope);
-		return;
+	getChannel(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.Channel) return null;
+		return this.resolved?.channels?.[leaf.value] ?? null;
 	}
-	const error = asError(caught);
-	const ignore = new Set(scope.core.config.errors?.ignoreApiCodes ?? []);
-	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
-		logger().debug(`swallowed api code ${paint.amber(String(error.code))}`);
-		return;
-	}
-	await handleRawFault(error, uuid, scope);
-}
-function unhandledRouteId(match) {
-	if (match.routeId) return match.routeId;
-	const key = match.attemptedKey ?? "";
-	return `${match.kind}:${key.length > 0 ? key : "unrouted"}`;
-}
-function freshScope(match, payload, core, dispatch) {
-	const ref = {
-		application_id: payload.application_id,
-		id: payload.id,
-		token: payload.token
-	};
-	return {
-		core,
-		payload,
-		routeId: unhandledRouteId(match),
-		dispatch,
-		sender: match.kind === InteractionKind.Autocomplete ? null : new ReplySender(ref, core.rest, dispatch, core.bus)
-	};
-}
-function dispatchReporter(match, payload, core, dispatchId) {
-	const startedAt = performance.now();
-	const queuedMs = queuedMsFor(payload.id);
-	return (outcome) => {
-		reportDispatch(core.bus, {
-			dispatchId,
-			routeId: unhandledRouteId(match),
-			interactionId: payload.id,
-			kind: match.kind,
-			outcome,
-			fallback: match.routeId === null,
-			userId: (payload.member?.user ?? payload.user)?.id ?? null,
-			guildId: payload.guild_id ?? null,
-			startedAt,
-			queuedMs
-		});
-	};
-}
-async function answer(caught, scope, report, outcome = outcomeFor(caught)) {
-	try {
-		await handleFault(caught, scope);
-	} finally {
-		report(outcome);
-	}
-}
-async function runMiddlewares(step, kind, sender) {
-	const { args, dispatch, ran } = step;
-	for (const Middleware of args.middlewares.chainFor(kind)) {
-		const event = args.payload;
-		const instance = new Middleware(event, args.core, dispatch, sender);
-		ran.push(instance);
-		await instance.execute();
-	}
-}
-async function refusalBeforeHandler(step) {
-	const { args, scope } = step;
-	const { kind } = args.match;
-	if (kind !== InteractionKind.Autocomplete && scope.sender) try {
-		await runMiddlewares(step, kind, scope.sender);
-	} catch (caught) {
-		return { caught };
-	}
-	return gateRefusal(step);
-}
-async function dispatchInteraction(args) {
-	const { match, payload, core } = args;
-	const routeId = unhandledRouteId(match);
-	const dispatch = new DispatchContext(routeId);
-	const report = dispatchReporter(match, payload, core, dispatch.id);
-	const Handler = match.ctor;
-	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(Handler.name)}`);
-	let handler;
-	try {
-		handler = new Handler(payload, core, dispatch);
-	} catch (caught) {
-		await answer(caught, freshScope(match, payload, core, dispatch), report);
-		return null;
-	}
-	const scope = {
-		core,
-		payload,
-		routeId,
-		dispatch,
-		sender: handler instanceof RepliableHandler$1 ? handler.sender : null
-	};
-	const ran = [];
-	const refusal = await refusalBeforeHandler({
-		args,
-		Handler,
-		dispatch,
-		scope,
-		ran
-	});
-	if (refusal) {
-		try {
-			await answer(refusal.caught, scope, report);
-		} finally {
-			await runAfter(ran, resultFor(refusal.caught), logger());
-		}
-		return null;
-	}
-	return async () => {
-		let result = { outcome: "handled" };
-		try {
-			await handler.execute();
-			report("handled");
-		} catch (caught) {
-			result = resultFor(caught);
-			await answer(caught, scope, report);
-		} finally {
-			await runAfter(ran, result, logger());
-		}
-	};
-}
-async function gateRefusal(step) {
-	const { Handler, dispatch } = step;
-	const { match, payload, core } = step.args;
-	if (match.kind === InteractionKind.Autocomplete || payload.type === InteractionType.ApplicationCommandAutocomplete) return null;
-	const monitor = slowGateMonitor();
-	try {
-		await runHandlerGates(Handler, interactionGateContext(payload, core, dispatch), match.routeId ?? void 0, monitor?.observe);
-		return null;
-	} catch (caught) {
-		return { caught };
-	} finally {
-		monitor?.report(match.routeId);
+	getRole(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.Role) return null;
+		return this.resolved?.roles?.[leaf.value] ?? null;
 	}
+	getAttachment(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.Attachment) return null;
+		return this.resolved?.attachments?.[leaf.value] ?? null;
+	}
+	getMentionable(name) {
+		const leaf = this.leaves.get(name);
+		if (leaf?.type !== ApplicationCommandOptionType.Mentionable) return null;
+		const resolved = this.resolved;
+		return resolved?.members?.[leaf.value] ?? resolved?.users?.[leaf.value] ?? resolved?.roles?.[leaf.value] ?? null;
+	}
+	getFocused() {
+		for (const leaf of this.leaves.values()) if ("focused" in leaf && leaf.focused === true) return {
+			name: leaf.name,
+			value: String(leaf.value)
+		};
+		return null;
+	}
+};
+function numeric(value) {
+	if (typeof value === "number") return value;
+	if (value.trim() === "") return null;
+	const parsed = Number(value);
+	return Number.isNaN(parsed) ? null : parsed;
 }
 
 //#endregion
-//#region src/inputs/HttpSlashOptions.ts
-var HttpSlashOptions = class {
-	leaves = /* @__PURE__ */ new Map();
-	resolved;
-	constructor(data) {
-		this.resolved = data.resolved;
-		let options = data.options ?? [];
-		const first = options[0];
-		if (first?.type === ApplicationCommandOptionType.SubcommandGroup) options = first.options;
-		const second = options[0];
-		if (second?.type === ApplicationCommandOptionType.Subcommand) options = second.options ?? [];
-		for (const option of options) if (option.type !== ApplicationCommandOptionType.Subcommand && option.type !== ApplicationCommandOptionType.SubcommandGroup) this.leaves.set(option.name, option);
-	}
-	getString(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.String ? leaf.value : null;
-	}
-	getInteger(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Integer ? numeric(leaf.value) : null;
-	}
-	getNumber(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Number ? numeric(leaf.value) : null;
-	}
-	getBoolean(name) {
-		const leaf = this.leaves.get(name);
-		return leaf?.type === ApplicationCommandOptionType.Boolean ? leaf.value : null;
-	}
-	getUser(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
-		return this.resolved?.users?.[leaf.value] ?? null;
-	}
-	getMember(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.User) return null;
-		return this.resolved?.members?.[leaf.value] ?? null;
-	}
-	getChannel(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Channel) return null;
-		return this.resolved?.channels?.[leaf.value] ?? null;
-	}
-	getRole(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Role) return null;
-		return this.resolved?.roles?.[leaf.value] ?? null;
-	}
-	getAttachment(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Attachment) return null;
-		return this.resolved?.attachments?.[leaf.value] ?? null;
-	}
-	getMentionable(name) {
-		const leaf = this.leaves.get(name);
-		if (leaf?.type !== ApplicationCommandOptionType.Mentionable) return null;
-		const resolved = this.resolved;
-		return resolved?.members?.[leaf.value] ?? resolved?.users?.[leaf.value] ?? resolved?.roles?.[leaf.value] ?? null;
-	}
-	getFocused() {
-		for (const leaf of this.leaves.values()) if ("focused" in leaf && leaf.focused === true) return {
-			name: leaf.name,
-			value: String(leaf.value)
-		};
-		return null;
-	}
-};
-function numeric(value) {
-	if (typeof value === "number") return value;
-	if (value.trim() === "") return null;
-	const parsed = Number(value);
-	return Number.isNaN(parsed) ? null : parsed;
+//#region src/dispatch/slashRouteOf.ts
+function slashRouteOf(data) {
+	const first = data.options?.[0];
+	if (first?.type === ApplicationCommandOptionType.SubcommandGroup) return buildSlashRoute(data.name, first.options[0]?.name, first.name);
+	if (first?.type === ApplicationCommandOptionType.Subcommand) return buildSlashRoute(data.name, first.name);
+	return data.name;
 }
 
 //#endregion
-//#region src/handlers/interaction/AutocompleteHandler.ts
+//#region src/handlers/interaction/SlashHandler.ts
 /**
-* Base class for an autocomplete handler on the HTTP transport.
+* Base class for a chat-input (slash) command handler on the HTTP transport.
 *
-* Pass the command route(s) from the generated registry as the generic. Branch on the focused field with
-* `this.match`, read already-entered sibling options with `this.options`, and find which command fired
-* with `this.route`.
+* Pass the route from the generated registry as the generic, 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 SlashRegistry}, e.g. `'search'`.
+* @typeParam Route - One or more route keys from {@link SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
 */
-var AutocompleteHandler = class extends BaseHandler {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch, "interactions");
-	}
+var SlashHandler = class extends InteractionHandler {
+	resolver;
 	/**
-	* Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+	* The typed options for this command's route. Only the getters for kinds this command declares appear.
+	* Each getter's name argument is restricted to that command's options of its kind.
+	*
+	* - A required option drops the null.
+	*
+	* - Choices narrow to their literal union.
+	*
+	* - A channel option declared with `addChannelTypes` narrows to those types.
+	*
+	* Rich kinds resolve from the interaction's `resolved` data.
 	*/
-	get api() {
-		return apiFor(this.core.rest);
-	}
-	resolver;
-	get reader() {
+	get options() {
 		this.resolver ??= new HttpSlashOptions(this.event.data);
 		return this.resolver;
 	}
 	/**
-	* 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.
-	*/
-	get focused() {
-		const focused = this.reader.getFocused();
-		if (!focused) throw new SeedcordError(SeedcordErrorCode.AutocompleteNoFocusedOption);
-		return focused;
-	}
-	/**
-	* Run the arm for the focused field. An autocomplete always dispatches by which field is focused.
-	* Match is how you read it.
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* routes.
 	*
-	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
-	* arm receives the focused partial value and a `respond` typed to that field's choice value. 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.
+	* 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 autocompletable field, keyed by field name.
+	* @param arms - One handler per registered route, keyed by route string.
 	* @returns The result of the arm that ran.
 	*/
 	async match(arms) {
-		const { name, value } = this.focused;
-		const respond = (choices) => this.respond(choices);
-		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.AutocompleteMatchArmMissing, [name]);
-		return await arm(value, respond);
-	}
+		const route = slashRouteOf(this.event.data);
+		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
+			this.constructor.name,
+			"command route",
+			route
+		]);
+		return await arm(this.options);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.ts
+function armFor(handler, arms, name) {
+	const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
+	if (typeof arm !== "function") throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
+		handler.constructor.name,
+		"context menu command",
+		name
+	]);
+	return arm;
+}
+/**
+* Base class for a user context-menu command handler on the HTTP transport (right-click a user).
+*
+* Pass the command name(s) as the generic, the same as `@UserContextMenuRoute`. Read the right-clicked user
+* from `this.target` and that same user's guild member from `this.targetMember`.
+*
+* @typeParam Names - One or more command names from the generated user registry.
+*/
+var UserContextMenuHandler = class extends InteractionHandler {
+	get target() {
+		const { target_id: targetId, resolved } = this.event.data;
+		return resolved.users[targetId];
+	}
+	/** The right-clicked user's guild member, null outside a guild. */
+	get targetMember() {
+		const { target_id: targetId, resolved } = this.event.data;
+		return resolved.members?.[targetId] ?? null;
+	}
+	/** Which of the registered commands fired. */
+	get commandName() {
+		return this.event.data.name;
+	}
+	/**
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* names.
+	*
+	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+	* arm receives the clicked user and that user's guild member. The arms must cover every name in the
+	* generic. A missing name or an unknown key is a compile error.
+	*
+	* @param arms - One handler per registered command name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@UserContextMenuRoute('View Profile', 'Warn')
+	* class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
+	*     async execute() {
+	*         await this.match({
+	*             'View Profile': (user) => this.reply(`Profile for ${user.username}.`),
+	*             Warn: (user, member) => this.reply(`Warned ${member?.nick ?? user.username}.`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		return await armFor(this, arms, this.event.data.name)(this.target, this.targetMember);
+	}
+};
+/**
+* Base class for a message context-menu command handler on the HTTP transport (right-click a message).
+*
+* Pass the command name(s) as the generic, the same as `@MessageContextMenuRoute`. Read the right-clicked
+* message from `this.target`.
+*
+* @typeParam Names - One or more command names from the generated message registry.
+*/
+var MessageContextMenuHandler = class extends InteractionHandler {
+	get target() {
+		const { target_id: targetId, resolved } = this.event.data;
+		return resolved.messages[targetId];
+	}
+	/** Which of the registered commands fired. */
+	get commandName() {
+		return this.event.data.name;
+	}
+	/**
+	* Run the arm for whichever command fired. Use this only when the handler is registered for several
+	* names.
+	*
+	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
+	* arm receives the clicked message. The arms must cover every name in the generic. A missing name or
+	* an unknown key is a compile error.
+	*
+	* @param arms - One handler per registered command name.
+	* @returns The result of the arm that ran.
+	*
+	* @example
+	* ```ts
+	* \@MessageContextMenuRoute('Report Message', 'Quote Message')
+	* class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Quote Message'> {
+	*     async execute() {
+	*         await this.match({
+	*             'Report Message': (message) => this.report(message),
+	*             'Quote Message': (message) => this.reply(`> ${message.content}`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		return await armFor(this, arms, this.event.data.name)(this.target);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/AutocompleteHandler.ts
+/**
+* Base class for an autocomplete handler on the HTTP transport.
+*
+* Pass the command route(s) from the generated registry as the generic. 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 SlashRegistry}, e.g. `'search'`.
+*/
+var AutocompleteHandler = class extends BaseHandler {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch, "interactions");
+	}
+	/**
+	* Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
+	*/
+	get api() {
+		return apiFor(this.core.rest);
+	}
+	resolver;
+	get reader() {
+		this.resolver ??= new HttpSlashOptions(this.event.data);
+		return this.resolver;
+	}
+	/**
+	* 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.
+	*/
+	get focused() {
+		const focused = this.reader.getFocused();
+		if (!focused) throw new SeedcordError(SeedcordErrorCode.AutocompleteNoFocusedOption);
+		return focused;
+	}
+	/**
+	* Run the arm for the focused field. An autocomplete always dispatches by which field is focused.
+	* Match is how you read it.
+	*
+	* Provide one arm per autocompletable field across the registered commands, keyed by field name. Each
+	* arm receives the focused partial value and a `respond` typed to that field's choice value. The
+	* arms must cover every autocompletable field. A missing field or an unknown key is a compile error.
+	*
+	* @param arms - One handler per autocompletable field, keyed by field name.
+	* @returns The result of the arm that ran.
+	* @throws A **SeedcordTypeError** with `MatchArmMissing` when the focused field has no arm. Only a stale-deployed command can send one.
+	*/
+	async match(arms) {
+		const { name, value } = this.focused;
+		const respond = (choices) => this.respond(choices);
+		const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
+			this.constructor.name,
+			"focused field",
+			name
+		]);
+		return await arm(value, respond);
+	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
 	async respond(choices) {
 		await reportedWrite({
@@ -674,158 +773,558 @@ var AutocompleteHandler = class extends BaseHandler {
 };
 
 //#endregion
-//#region src/handlers/interaction/InteractionHandler.ts
+//#region src/handlers/interaction/components/ComponentHandler.ts
 /**
-* Shared base the repliable interaction handlers extend.
+* Shared base the customId-routed component handlers extend on the HTTP transport.
 *
-* Not a public entry point. Extend {@link SlashHandler}, {@link ContextMenuHandler}, {@link ButtonHandler},
-* {@link ModalHandler}, or one of the select menu bases instead. This class adds `showModal` on top
-* of the reply members.
+* Not a public entry point. Extend {@link ButtonHandler}, {@link ModalHandler}, or one of the select menu
+* bases instead. This class defines the customId decode, the route matching, and the source-message
+* verbs `update` and `deferUpdate`.
 *
-* @typeParam Event - The repliable interaction type this handler processes
+* @typeParam Event - The component or modal interaction type this handler processes
+* @typeParam Defs - The customId route definitions registered on the concrete handler
 */
-var InteractionHandler = class extends RepliableHandler$1 {
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch);
+var ComponentHandler = class extends InteractionHandler {
+	/** Rewrite the source message this component interaction came from. */
+	update(response) {
+		return this.sender.update(response);
+	}
+	/** Acknowledge the component without changing the source message. */
+	deferUpdate() {
+		return this.sender.deferUpdate();
+	}
+	decoded;
+	get route() {
+		this.decoded ??= decodeComponentRoute(this.constructor, this.event.data.custom_id);
+		return this.decoded;
 	}
 	/**
-	* Open a modal. Must be the initial response to this interaction. The modal kind rejects this call at
-	* compile time (Discord forbids a modal in response to a modal).
+	* The decoded params of the single route this handler is registered for.
+	*
+	* Reading this decodes `this.event.data.custom_id` once and caches the result. On a handler
+	* registered for several routes this is `never`. Use {@link match} instead.
+	*
+	* @throws A **StaleCustomId** when the wire was encoded under an older shape. The dispatcher boundary turns it into a reply.
+	* @throws An **InvalidCustomId** when the wire is corrupt. The dispatcher boundary turns it into a reply.
 	*/
-	showModal(modal) {
-		return this.sender.showModal(modal);
+	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 compiler checks that the arms cover every registered route prefix. `match`
+	* decodes the wire before it runs an arm.
+	*
+	* @param arms - One callback per registered route, keyed by prefix.
+	* @returns The result of the arm that ran.
+	* @throws A **SeedcordTypeError** with `MatchArmMissing` when the wire's prefix has no arm.
+	* @throws A **StaleCustomId** when the wire was encoded under an older shape.
+	* @throws An **InvalidCustomId** when the wire is corrupt.
+	*
+	* @example
+	* ```ts
+	* \@ButtonRoute(Approve, Reject)
+	* class ReviewButtons extends ButtonHandler<[typeof Approve, typeof Reject]> {
+	*     async execute() {
+	*         await this.match({
+	*             approve: ({ userId }) => this.reply(`approved <@${userId}>`),
+	*             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
+	*         });
+	*     }
+	* }
+	* ```
+	*/
+	async match(arms) {
+		const { prefix, params } = this.route;
+		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
+		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.MatchArmMissing, [
+			this.constructor.name,
+			"component route",
+			prefix
+		]);
+		return await arm(params);
 	}
 };
 
 //#endregion
-//#region src/handlers/interaction/InteractionMiddleware.ts
+//#region src/handlers/interaction/components/ButtonHandler.ts
 /**
-* Base class for interaction middleware on the HTTP transport.
+* Base class for a button interaction handler on the HTTP transport.
 *
-* Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
-* reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
-* `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable
-* kind.
+* 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. Reply through the
+* handler members, or rewrite the source message with `this.update`. Passing different definitions to the
+* decorator and the generic is a compile error.
 *
-* @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ApproveId]`.
+*/
+var ButtonHandler = class extends ComponentHandler {};
+
+//#endregion
+//#region src/handlers/interaction/components/ModalHandler.ts
+/**
+* Base class for a modal submit handler on the HTTP transport.
+*
+* Register the customId definitions this handler decodes with `@ModalRoute` and list the same ones in the
+* generic. Read the submitted inputs from `this.fields`. Reply through the handler members. `showModal`
+* fails compilation on this kind, because Discord forbids opening a modal in response to a modal.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
 *
 * @example
 * ```ts
-* \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
-* class Audit extends InteractionMiddleware<InteractionKind.Button> {
+* \@ModalRoute(ConfigId)
+* class ConfigModal extends ModalHandler<[typeof ConfigId]> {
 *     async execute() {
-*         this.logger.info(this.event.data.custom_id);
-*     }
+*         const { guildId } = this.params;
+*         const name = this.fields.getTextInputValue('name');
+*         await this.reply(`saved ${name} for ${guildId}`);
+*     }
 * }
 * ```
 */
-var InteractionMiddleware = class extends RepliableHandler$1 {
-	constructor(event, core, dispatch, sender) {
-		super(event, core, dispatch, sender);
+var ModalHandler = class extends ComponentHandler {
+	reader;
+	/** The fields this modal submitted, read by custom id. */
+	get fields() {
+		this.reader ??= new ModalFields(this.event.data);
+		return this.reader;
+	}
+	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
+	update(response) {
+		this.ensureSourceMessage("update");
+		return super.update(response);
+	}
+	/** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
+	deferUpdate() {
+		this.ensureSourceMessage("deferUpdate");
+		return super.deferUpdate();
+	}
+	ensureSourceMessage(method) {
+		if (this.event.message) return;
+		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
 	}
 };
 
 //#endregion
-//#region src/manifest/entries.ts
-function isHandlerClass(value) {
-	if (typeof value !== "function") return false;
-	return value.prototype instanceof InteractionHandler || value.prototype instanceof AutocompleteHandler;
-}
-function isMiddlewareClass(value) {
-	return typeof value === "function" && value.prototype instanceof InteractionMiddleware;
-}
-function isSubscriberClass(value) {
-	return typeof value === "function" && value.prototype instanceof Subscriber;
-}
-function wrongClass(array, value, base) {
-	const name = typeof value === "function" ? value.name : String(value);
-	return new SeedcordTypeError(SeedcordErrorCode.ManifestEntryWrongClass, [
-		array,
-		name,
-		base
-	]);
-}
-function noRoutes(array, className, decorator) {
-	return new SeedcordError(SeedcordErrorCode.ManifestEntryNoRoutes, [
-		array,
-		className,
-		decorator
-	]);
+//#region src/handlers/interaction/components/SelectMenuHandler.ts
+function resolvedOf(data) {
+	return data.resolved ?? {};
 }
-
-//#endregion
-//#region src/dispatch/registerSubscribers.ts
-function registerSubscribers(bus, subscribers) {
-	for (const ctor of subscribers) {
-		if (!isSubscriberClass(ctor)) throw wrongClass("subscribers", ctor, "Subscriber");
-		if (!Reflect.hasMetadata(SubscribeMetadataKey, ctor)) throw noRoutes("subscribers", ctor.name, "@Subscribe");
-		bus[RegisterSubscriber](registrationFor(ctor));
+/**
+* Shared base the select menu handlers extend on the HTTP transport.
+*
+* Not a public entry point. Extend {@link StringMenuHandler}, {@link UserMenuHandler},
+* {@link RoleMenuHandler}, {@link ChannelMenuHandler}, or {@link MentionableMenuHandler} instead. This
+* class defines the `values` getter those bases share.
+*
+* @typeParam Event - The select menu interaction type this handler processes
+* @typeParam Defs - The customId route definitions registered on the concrete handler
+*/
+var SelectMenuHandler = class extends ComponentHandler {
+	/** The values this select picked. On every kind but the string menu they are snowflake ids. */
+	get values() {
+		return this.event.data.values ?? [];
 	}
-}
-
-//#endregion
-//#region src/handlers/defaults/UnhandledAutocomplete.ts
-var UnhandledAutocomplete = class extends AutocompleteHandler {
-	async execute() {
-		await this.respond([]);
+};
+/**
+* Base class for a string select menu handler on the HTTP transport.
+*
+* Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
+* the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
+* several. Reply through the handler members, or rewrite the source message with `this.update`.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
+*
+* @example
+* ```ts
+* \@StringMenuRoute(TopicsId)
+* class Topics extends StringMenuHandler<[typeof TopicsId]> {
+*     async execute() {
+*         const { userId } = this.params;
+*         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
+*     }
+* }
+* ```
+*/
+var StringMenuHandler = class extends SelectMenuHandler {};
+/**
+* Base class for a user select menu handler on the HTTP transport.
+*
+* Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
+* definitions with `@UserMenuRoute` and list the same ones in the generic.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+*
+* @example
+* ```ts
+* \@UserMenuRoute(AssignId)
+* class Assign extends UserMenuHandler<[typeof AssignId]> {
+*     async execute() {
+*         const { roleId } = this.params;
+*         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
+*     }
+* }
+* ```
+*/
+var UserMenuHandler = class extends SelectMenuHandler {
+	/** The users this select picked. */
+	get users() {
+		return pick(this.values, resolvedOf(this.event.data).users);
+	}
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	get members() {
+		return pick(this.values, resolvedOf(this.event.data).members);
 	}
 };
-
-//#endregion
-//#region src/handlers/defaults/UnhandledRepliable.ts
-var UnhandledRepliable = class extends InteractionHandler {
-	async execute() {
-		await this.reply("Feature not implemented yet.");
+/**
+* Base class for a role select menu handler on the HTTP transport.
+*
+* Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
+* `@RoleMenuRoute` and list the same ones in the generic.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
+*
+* @example
+* ```ts
+* \@RoleMenuRoute(GrantId)
+* class Grant extends RoleMenuHandler<[typeof GrantId]> {
+*     async execute() {
+*         await this.update(`granting ${this.roles.size} role(s)`);
+*     }
+* }
+* ```
+*/
+var RoleMenuHandler = class extends SelectMenuHandler {
+	/** The roles this select picked. */
+	get roles() {
+		return pick(this.values, resolvedOf(this.event.data).roles);
 	}
 };
-
-//#endregion
-//#region src/dispatch/resolve.ts
-function commandKind(type) {
-	switch (type) {
-		case ApplicationCommandType.ChatInput: return InteractionKind.Slash;
-		case ApplicationCommandType.User: return InteractionKind.UserContextMenu;
-		case ApplicationCommandType.Message: return InteractionKind.MessageContextMenu;
-		default: return null;
+/**
+* Base class for a channel select menu handler on the HTTP transport.
+*
+* Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
+* `@ChannelMenuRoute` and list the same ones in the generic.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
+*
+* @example
+* ```ts
+* \@ChannelMenuRoute(LogTargetId)
+* class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
+*     async execute() {
+*         await this.update(`logging to ${this.channels.size} channel(s)`);
+*     }
+* }
+* ```
+*/
+var ChannelMenuHandler = class extends SelectMenuHandler {
+	/** The channels this select picked. */
+	get channels() {
+		return pick(this.values, resolvedOf(this.event.data).channels);
 	}
-}
-function componentMapKey(type) {
-	switch (type) {
-		case ComponentType.Button: return InteractionKind.Button;
-		case ComponentType.StringSelect: return InteractionKind.StringMenu;
-		case ComponentType.UserSelect: return InteractionKind.UserMenu;
-		case ComponentType.RoleSelect: return InteractionKind.RoleMenu;
-		case ComponentType.ChannelSelect: return InteractionKind.ChannelMenu;
-		case ComponentType.MentionableSelect: return InteractionKind.MentionableMenu;
-		default: return null;
+};
+/**
+* Base class for a mentionable select menu handler on the HTTP transport.
+*
+* A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
+* can each come back empty.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
+*
+* @example
+* ```ts
+* \@MentionableMenuRoute(InviteId)
+* class Invite extends MentionableMenuHandler<[typeof InviteId]> {
+*     async execute() {
+*         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
+*     }
+* }
+* ```
+*/
+var MentionableMenuHandler = class extends SelectMenuHandler {
+	/** The users this select picked. */
+	get users() {
+		return pick(this.values, resolvedOf(this.event.data).users);
 	}
-}
-function emptyRouteMaps() {
-	return {
-		[InteractionKind.Slash]: /* @__PURE__ */ new Map(),
-		[InteractionKind.UserContextMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.MessageContextMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Autocomplete]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Button]: /* @__PURE__ */ new Map(),
-		[InteractionKind.StringMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.UserMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.RoleMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.ChannelMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.MentionableMenu]: /* @__PURE__ */ new Map(),
-		[InteractionKind.Modal]: /* @__PURE__ */ new Map()
-	};
-}
-function unhandled(kind, attemptedKey) {
+	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
+	get members() {
+		return pick(this.values, resolvedOf(this.event.data).members);
+	}
+	/** The roles this select picked. */
+	get roles() {
+		return pick(this.values, resolvedOf(this.event.data).roles);
+	}
+};
+
+//#endregion
+//#region src/subscribers/index.ts
+/**
+* Base class for an HTTP subscriber, binding `this.core` to the HTTP {@link Core}.
+*
+* @typeParam KeyOfSubscribers - The subscription key this handler receives
+*/
+var Subscriber$1 = class extends Subscriber {};
+/**
+* Base class for an HTTP subscriber that delivers its event to a Discord webhook, binding
+* `this.core` to the HTTP {@link Core}.
+*
+* @typeParam KeyOfSubscribers - The subscription key this reporter receives
+*/
+var WebhookLog$1 = class extends WebhookLog {};
+
+//#endregion
+//#region src/pagination/Paginator.ts
+function contextOf(interaction, core) {
 	return {
-		kind,
-		routeId: null,
-		attemptedKey,
-		ctor: kind === InteractionKind.Autocomplete ? UnhandledAutocomplete : UnhandledRepliable
+		interaction,
+		user: interaction.member?.user ?? interaction.user,
+		guildId: interaction.guild_id ?? null,
+		core
 	};
 }
 /**
-* Matches a verified non-PING interaction to a registered handler. A known kind with no handler resolves
-* to the unhandled default. Null is an unrecognized payload shape, which the engine acks with a 202
+* 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) => loadBans(ctx.guildId), { perPage: 10 }),
+*     renderItem: (ban) => ban.user.username
+* });
+*
+* \@ButtonRoute(Bans.cursor)
+* export class BansNav extends Bans.Handler {}
+* ```
+*/
+var Paginator = class extends PaginatorBase {
+	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
+	Handler;
+	constructor(config) {
+		super(config);
+		const pageFor = (handler, n) => this.page(handler, n);
+		this.Handler = class Nav extends ButtonHandler {
+			async execute() {
+				await this.deferUpdate();
+				const response = await pageFor(this, this.params.page);
+				await this.update(response);
+			}
+		};
+	}
+	/**
+	* Render a page as a {@link ReplyResponse} without sending anything.
+	*
+	* @param handler - The handler rendering the page, normally `this`.
+	* @param n - The zero-based page.
+	*/
+	async page(handler, n) {
+		return this.buildPage(contextOf(handler.getEvent(), handler.core), n);
+	}
+	/**
+	* Send a page through the handler's sender. The sender picks reply, edit, or followUp from its ack state.
+	*
+	* @param handler - The handler starting the paginator, normally `this`.
+	* @param n - The zero-based page to open on.
+	*/
+	async start(handler, n = 0) {
+		const response = await this.page(handler, n);
+		return handler.sender.send(response, { ephemeral: this.config.ephemeral ?? false });
+	}
+};
+
+//#endregion
+//#region src/pagination/sources.ts
+/**
+* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
+* page, 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 extends ArraySourceBase {};
+/**
+* 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 extends CursorSourceBase {};
+
+//#endregion
+//#region src/gates/Gated.ts
+/**
+* Attaches gates to an HTTP interaction 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. A gate
+* that requires a context the handler does not provide (a button gate on a slash handler, a gate on an
+* autocomplete handler, or a `RequirePermissions([...], { in: 'guild' })` gate the http transport cannot
+* satisfy) 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-api-types/v10';
+*
+* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.ManageMessages]))
+* \@SlashRoute('purge')
+* class Purge extends SlashHandler<'purge'> {
+*     async execute() {
+*         // both gates passed, so this runs in a guild with a caller who can moderate this channel
+*     }
+* }
+* ```
+*
+* @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 requires 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/version.ts
+const version = "0.11.0-next.0";
+
+//#endregion
+//#region src/publicKey.ts
+async function publicKeyOf(rest) {
+	const fromEnv = Envapter.get("DISCORD_PUBLIC_KEY");
+	if (fromEnv !== void 0) return fromEnv;
+	try {
+		return (await currentApplication(rest)).verify_key;
+	} catch (error) {
+		throw new SeedcordError(SeedcordErrorCode.CoreDiscordReadFailed, [
+			"the public key",
+			asError(error).message,
+			`The bot reads it there because ${paint.bold("DISCORD_PUBLIC_KEY")} is unset. Check ${paint.bold("DISCORD_BOT_TOKEN")}, or set ${paint.bold("DISCORD_PUBLIC_KEY")} to the key from your application's General Information page.`
+		], { cause: error });
+	}
+}
+
+//#endregion
+//#region src/HttpStartupTasks.ts
+var HttpStartupTasks = class {
+	host;
+	service;
+	commands;
+	emojis;
+	constructor(host, service) {
+		this.host = host;
+		this.service = service;
+		this.commands = host.config.bot.commands.path ? new CommandRegistry(host) : void 0;
+		this.emojis = new EmojiInjector(host);
+	}
+	registerHmr(hmr) {
+		this.host.startup.addTask(StartupPhase.Configuration, "hmr-registration", () => {
+			if (this.service.interactions) hmr.register(this.service.interactions);
+			if (this.commands) hmr.register(this.commands);
+			hmr.register(this.service.subscribers);
+			for (const { instance } of attachmentsOf(this.host)) hmr.register(instance);
+			return Promise.resolve();
+		});
+	}
+	addDiscordTasks() {
+		const { startup } = this.host;
+		startup.addTask(StartupPhase.Login, "interactions-engine", async () => {
+			this.service.prepareEngine(await publicKeyOf(this.service.rest));
+		});
+		const { commands } = this;
+		if (!commands) {
+			startup.addTask(StartupPhase.Login, "emoji-injection", () => this.emojis.init());
+			return;
+		}
+		startup.addTask(StartupPhase.Login, "command-deploy", async (signal) => {
+			await this.emojis.init();
+			await commands.deploy(signal, { routes: this.service.interactions });
+		}, COMMAND_DEPLOY_TIMEOUT_MS);
+	}
+};
+
+//#endregion
+//#region src/handlers/defaults/UnhandledAutocomplete.ts
+var UnhandledAutocomplete = class extends AutocompleteHandler {
+	async execute() {
+		await this.respond([]);
+	}
+};
+
+//#endregion
+//#region src/handlers/defaults/UnhandledRepliable.ts
+var UnhandledRepliable = class extends InteractionHandler {
+	async execute() {
+		await this.reply("Feature not implemented yet.");
+	}
+};
+
+//#endregion
+//#region src/dispatch/resolve.ts
+function commandKind(type) {
+	switch (type) {
+		case ApplicationCommandType.ChatInput: return InteractionKind.Slash;
+		case ApplicationCommandType.User: return InteractionKind.UserContextMenu;
+		case ApplicationCommandType.Message: return InteractionKind.MessageContextMenu;
+		default: return null;
+	}
+}
+function componentMapKey(type) {
+	switch (type) {
+		case ComponentType.Button: return InteractionKind.Button;
+		case ComponentType.StringSelect: return InteractionKind.StringMenu;
+		case ComponentType.UserSelect: return InteractionKind.UserMenu;
+		case ComponentType.RoleSelect: return InteractionKind.RoleMenu;
+		case ComponentType.ChannelSelect: return InteractionKind.ChannelMenu;
+		case ComponentType.MentionableSelect: return InteractionKind.MentionableMenu;
+		default: return null;
+	}
+}
+function emptyRouteMaps() {
+	return {
+		[InteractionKind.Slash]: /* @__PURE__ */ new Map(),
+		[InteractionKind.UserContextMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.MessageContextMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Autocomplete]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Button]: /* @__PURE__ */ new Map(),
+		[InteractionKind.StringMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.UserMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.RoleMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.ChannelMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.MentionableMenu]: /* @__PURE__ */ new Map(),
+		[InteractionKind.Modal]: /* @__PURE__ */ new Map()
+	};
+}
+function unhandled(kind, attemptedKey) {
+	return {
+		kind,
+		routeId: null,
+		attemptedKey,
+		ctor: kind === InteractionKind.Autocomplete ? UnhandledAutocomplete : UnhandledRepliable
+	};
+}
+/**
+* Matches a verified non-PING interaction to a registered handler. A known kind with no handler resolves
+* to the unhandled default. Null is an unrecognized payload shape, which the engine acks with a 202
 * without dispatching. Components and modals route by the stable customId prefix. A wire whose layout
 * hash drifted still reaches its handler, where decode refuses with `StaleCustomId`.
 */
@@ -868,16 +1367,16 @@ var RouteRegistry = class {
 	/**
 	* Writes every route the class declares. A class declaring none returns false.
 	*
-	* @throws A **SeedcordError** when another class already holds one of them.
+	* @throws A **SeedcordTypeError** when another class already holds one of them.
 	*/
 	register(ctor, from) {
 		const writes = [];
 		for (const [kind, keys] of interactionRoutesOf(ctor)) for (const key of keys) {
 			const existing = this.owners.get(`${kind}:${key}`);
-			if (existing && existing.ctor !== ctor) throw new SeedcordError(SeedcordErrorCode.InteractionDuplicateRoute, [
+			if (existing && existing.ctor !== ctor) throw new SeedcordTypeError(SeedcordErrorCode.CoreDuplicateName, [
+				"route",
 				`${kind}:${key}`,
-				`${existing.ctor.name} (${existing.from})`,
-				`${ctor.name} (${from})`
+				[`${paint.bold(existing.ctor.name)} (${paint.path(existing.from)})`, `${paint.bold(ctor.name)} (${paint.path(from)})`]
 			]);
 			writes.push({
 				kind,
@@ -917,1008 +1416,624 @@ var RouteRegistry = class {
 };
 
 //#endregion
-//#region src/receiver/Ed25519Verifier.ts
-const PUBLIC_KEY_BYTES = 32;
-const SIGNATURE_BYTES = 64;
-const HEX_RADIX = 16;
-const HEX_PATTERN = /^[0-9a-f]+$/i;
-function hexToBytes(hex, byteLength) {
-	if (hex.length !== byteLength * 2 || !HEX_PATTERN.test(hex)) return null;
-	const bytes = new Uint8Array(byteLength);
-	for (let index = 0; index < byteLength; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), HEX_RADIX);
-	return bytes;
-}
-const encoder = new TextEncoder();
-var Ed25519Verifier = class {
-	key;
-	constructor(publicKeyHex) {
-		const publicKey = hexToBytes(publicKeyHex, PUBLIC_KEY_BYTES);
-		if (!publicKey) throw new SeedcordTypeError(SeedcordErrorCode.ConfigInvalidEnv, ["DISCORD_PUBLIC_KEY", "64 hex characters"]);
-		this.key = crypto.subtle.importKey("raw", publicKey, "Ed25519", false, ["verify"]);
+//#region src/dispatch/InteractionDispatcher.ts
+var InteractionDispatcher = class {
+	handlersDir;
+	middlewaresDir;
+	/** @internal */
+	middlewares = new MiddlewareRegistry(interactionMiddleware);
+	/** @internal */
+	logger = new Logger("Interactions", { channel: "interactions" });
+	routes = new RouteRegistry();
+	get maps() {
+		return this.routes.maps;
+	}
+	isInitialized = false;
+	hmrHandler;
+	loading = false;
+	loadedHandlers = [];
+	loadedMiddlewares = [];
+	constructor(handlersDir, middlewaresDir) {
+		this.handlersDir = handlersDir;
+		this.middlewaresDir = middlewaresDir;
+		if (!Envapter.isDevelopment && !Envapter.isTest) return;
+		this.hmrHandler = new HmrModuleHandler({
+			handlersDir,
+			...middlewaresDir && { middlewaresDir },
+			isHandler: this.isHandler.bind(this),
+			isMiddleware: this.isMiddleware.bind(this),
+			registerHandler: this.registerHandler.bind(this),
+			registerMiddleware: this.registerMiddleware.bind(this),
+			unregisterHandler: this.routes.unregister.bind(this.routes),
+			unregisterMiddleware: this.unregisterMiddleware.bind(this),
+			getArtifacts: this.routes.routesOf.bind(this.routes),
+			logger: this.logger
+		});
 	}
-	async verify(signatureHex, timestamp, body) {
-		const signature = hexToBytes(signatureHex, SIGNATURE_BYTES);
-		if (!signature) return false;
-		const timestampBytes = encoder.encode(timestamp);
-		const message = new Uint8Array(timestampBytes.length + body.length);
-		message.set(timestampBytes, 0);
-		message.set(body, timestampBytes.length);
-		return crypto.subtle.verify("Ed25519", await this.key, signature, message);
+	/** @internal */
+	async init() {
+		if (this.isInitialized) return;
+		this.isInitialized = true;
+		this.loading = true;
+		this.loadedHandlers.length = 0;
+		this.loadedMiddlewares.length = 0;
+		try {
+			if (this.middlewaresDir) await this.loadMiddlewares(this.middlewaresDir);
+			await this.loadHandlers(this.handlersDir);
+		} finally {
+			this.loading = false;
+		}
+		this.reportLoad();
 	}
-};
-
-//#endregion
-//#region src/receiver/ReplayGuard.ts
-const REPLAY_WINDOW_MS = 3e5;
-const SWEEP_GAP_MS = 6e4;
-const MS_PER_SECOND = 1e3;
-const TIMESTAMP_PATTERN = /^\d+$/;
-var ReplayGuard = class {
-	seen = /* @__PURE__ */ new Map();
-	lastSweep = Date.now();
-	fresh(timestampHeader) {
-		if (!TIMESTAMP_PATTERN.test(timestampHeader)) return null;
-		const timestampMs = Number(timestampHeader) * MS_PER_SECOND;
-		return Math.abs(Date.now() - timestampMs) <= REPLAY_WINDOW_MS ? timestampMs : null;
+	async loadHandlers(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const value of Object.values(imported)) {
+			if (!this.isHandler(value)) continue;
+			this.registerHandler(value, relativePath);
+			this.hmrHandler?.trackHandler(fullPath, value);
+		}
 	}
-	unseen(signatureHex, timestampMs) {
-		const now = Date.now();
-		this.maybeSweep(now);
-		const rejectUntil = this.seen.get(signatureHex);
-		if (rejectUntil !== void 0 && rejectUntil >= now) return false;
-		this.seen.set(signatureHex, timestampMs + REPLAY_WINDOW_MS);
-		return true;
+	async loadMiddlewares(dir) {
+		for await (const { fullPath, relativePath, imported } of importFiles(dir)) for (const value of Object.values(imported)) {
+			if (!this.isMiddleware(value)) continue;
+			this.registerMiddleware(value, relativePath);
+			this.hmrHandler?.trackMiddleware(fullPath, value);
+		}
 	}
-	maybeSweep(now) {
-		if (now - this.lastSweep < SWEEP_GAP_MS) return;
-		this.lastSweep = now;
-		for (const [signature, rejectUntil] of this.seen) if (rejectUntil < now) this.seen.delete(signature);
+	reportLoad() {
+		const { utils } = this.logger;
+		if (this.loadedMiddlewares.length > 0) utils.block("Loaded middlewares", utils.entries(this.loadedMiddlewares), "debug");
+		utils.block("Loaded handlers", [...utils.entries(this.loadedHandlers), ...utils.counts({ routes: this.routes.size })], "debug");
 	}
-};
-
-//#endregion
-//#region src/engine.ts
-const SIGNATURE_HEADER = "x-signature-ed25519";
-const TIMESTAMP_HEADER = "x-signature-timestamp";
-const ACCEPTED = 202;
-const BAD_REQUEST = 400;
-const UNAUTHORIZED = 401;
-const METHOD_NOT_ALLOWED = 405;
-const PING = InteractionType.Ping;
-const decoder = new TextDecoder();
-function hasInteractionType(payload) {
-	return typeof payload === "object" && payload !== null && "type" in payload && typeof payload.type === "number";
-}
-function buildEngine(core, maps, middlewares) {
-	if (!Envapter.has("DISCORD_PUBLIC_KEY")) throw new SeedcordError(SeedcordErrorCode.ConfigMissingEnv, ["DISCORD_PUBLIC_KEY"]);
-	const publicKey = Envapter.getRequired("DISCORD_PUBLIC_KEY", Converters.String);
-	const verifier = new Ed25519Verifier(publicKey);
-	const replays = new ReplayGuard();
-	const inFlight = /* @__PURE__ */ new Set();
-	const logger = new Logger("Engine", { channel: "bot" });
-	async function dispatchMatched(match, payload, ctx) {
-		const start = await dispatchInteraction({
-			match,
-			payload,
-			core,
-			middlewares
-		});
-		if (!start) return;
-		const work = start().catch(rootFault);
-		if (ctx) ctx.waitUntil(work);
-		else {
-			inFlight.add(work);
-			work.finally(() => inFlight.delete(work));
+	/** @internal */
+	async onHmr(event) {
+		await this.hmrHandler?.handle(event);
+	}
+	warnUnhandledRoutes(commandLeaves) {
+		this.warnMissing(commandLeaves, this.maps[InteractionKind.Slash], "Slash route", "@SlashRoute");
+	}
+	warnUnhandledContextMenuRoutes(leaves) {
+		const user = this.maps[InteractionKind.UserContextMenu];
+		const message = this.maps[InteractionKind.MessageContextMenu];
+		this.warnMissing(leaves.user, user, "User context menu", "@ContextMenuRoute");
+		this.warnMissing(leaves.message, message, "Message context menu", "@ContextMenuRoute");
+	}
+	warnMissing(names, map, label, decorator) {
+		for (const name of names) {
+			if (map.has(name)) continue;
+			this.logger.warn(`${label} ${paint.sky.bold(name)} has no registered ${paint.bold(decorator)} handler.`);
 		}
 	}
-	function rootFault(caught) {
-		const error = asError(caught);
-		logger.error("dispatch failed past the boundary", error);
-		core.bus[PublishDefault]("unhandledInteractionError", { error });
+	isHandler(value) {
+		if (typeof value !== "function" || !Reflect.hasMetadata(InteractionMetadataKey, value)) return false;
+		return value.prototype instanceof InteractionHandler || value.prototype instanceof AutocompleteHandler;
+	}
+	isMiddleware(value) {
+		if (typeof value !== "function") return false;
+		return value.prototype instanceof InteractionMiddleware && Reflect.hasMetadata(InteractionMiddlewareMetadataKey, value);
+	}
+	registerMiddleware(ctor, relativePath) {
+		const metadata = this.middlewares.register(ctor);
+		if (!metadata || !this.loading) return;
+		const scope = metadata.keys ? `${metadata.priority}, ${metadata.keys.join(", ")}` : metadata.priority;
+		this.loadedMiddlewares.push({
+			name: `${ctor.name} (${String(scope)})`,
+			from: formatFilePath(relativePath)
+		});
 	}
-	const handle = async (request, ctx) => {
-		const [response, outcome] = await respond(request, ctx);
-		logger.debug(`${paint.sky.bold(request.method)} ${outcome} ${paint.amber(String(response.status))}`);
-		return response;
-	};
-	const respond = async (request, ctx) => {
-		if (request.method !== "POST") return [new Response(null, {
-			status: METHOD_NOT_ALLOWED,
-			headers: { allow: "POST" }
-		}), "not-post"];
-		const signature = request.headers.get(SIGNATURE_HEADER);
-		const timestamp = request.headers.get(TIMESTAMP_HEADER);
-		if (signature === null || timestamp === null) return [new Response(null, { status: UNAUTHORIZED }), "unsigned"];
-		const timestampMs = replays.fresh(timestamp);
-		if (timestampMs === null) return [new Response(null, { status: UNAUTHORIZED }), "stale"];
-		const body = new Uint8Array(await request.arrayBuffer());
-		if (!await verifier.verify(signature, timestamp, body)) return [new Response(null, { status: UNAUTHORIZED }), "bad-signature"];
-		let payload;
-		try {
-			payload = JSON.parse(decoder.decode(body));
-		} catch {
-			return [new Response(null, { status: BAD_REQUEST }), "bad-body"];
-		}
-		if (!hasInteractionType(payload)) return [new Response(null, { status: BAD_REQUEST }), "bad-body"];
-		if (payload.type === PING) return [Response.json({ type: InteractionResponseType.Pong }), "ping"];
-		if (!replays.unseen(signature, timestampMs)) return [new Response(null, { status: UNAUTHORIZED }), "replay"];
-		try {
-			core.bus[PublishDefault]("anyInteraction", { interaction: payload });
-			const match = resolve(maps, payload);
-			if (match) await dispatchMatched(match, payload, ctx);
-		} catch (caught) {
-			rootFault(caught);
-		}
-		return [new Response(null, { status: ACCEPTED }), "dispatched"];
-	};
+	unregisterMiddleware(ctor) {
+		this.middlewares.unregister(ctor);
+	}
+	registerHandler(ctor, relativePath) {
+		const from = formatFilePath(relativePath);
+		if (!this.routes.register(ctor, from)) return;
+		if (this.loading) this.loadedHandlers.push({
+			name: ctor.name,
+			from
+		});
+	}
+};
+
+//#endregion
+//#region src/gates/context.ts
+function interactionGateContext(payload, core, dispatch) {
+	const member = payload.member ?? null;
+	const resolved = member?.user ?? payload.user;
 	return {
-		handle,
-		inFlight
+		kind: "interaction",
+		core,
+		dispatch,
+		interaction: payload,
+		user: resolved,
+		member,
+		userId: resolved?.id ?? null,
+		guildId: payload.guild_id ?? null,
+		channelId: payload.channel?.id ?? null,
+		memberRoleIds: member?.roles ?? [],
+		memberPermissions: member ? BigInt(member.permissions) : null,
+		appPermissions: BigInt(payload.app_permissions),
+		declaredRoute: null
 	};
 }
 
 //#endregion
-//#region src/createSeedcord.ts
-const MANIFEST_ORIGIN = "the manifest";
-/**
-* Builds the HTTP-interactions engine, a `(request, ctx?) => Promise<Response>` handler.
-*
-* The handler verifies the Ed25519 signature over the raw request bytes, rejects stale or replayed
-* requests, answers a PING with an in-body PONG, and acks every other interaction with an empty 202.
-* The engine dispatches a matched interaction through the manifest before the 202 goes out. Gates run
-* first and the sender posts any refusal over the REST callback. `execute()` continues past the 202 under
-* `ctx.waitUntil` when the caller passes one (the edge entry), and an engine-held in-flight set tracks
-* it otherwise (node paths). It reads only the method, headers, and body. Mount it at any path.
-*
-* Reads `DISCORD_PUBLIC_KEY` and `DISCORD_BOT_TOKEN` from the environment through envapt and throws a
-* `SeedcordError` when either is missing or malformed.
-*
-* Applies `config.logger`. An omitted `logger` resets the level and the sinks to their defaults, the
-* way `installNodeDefaults` does on the node hosts.
-*/
-function createSeedcord(config, manifest) {
-	Logger.configure(config.logger ?? {});
-	const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
-	const core = createCore(config, token);
-	core.bus[RegisterDefaults]();
-	registerSubscribers(core.bus, manifest.subscribers);
-	const routes = new RouteRegistry();
-	for (const handler of manifest.handlers) {
-		if (!isHandlerClass(handler)) throw wrongClass("handlers", handler, "InteractionHandler or AutocompleteHandler");
-		if (!routes.register(handler, MANIFEST_ORIGIN)) throw noRoutes("handlers", handler.name, "route decorator");
-	}
-	const middlewares = new MiddlewareRegistry(interactionMiddleware);
-	for (const middleware of manifest.middleware) {
-		if (!isMiddlewareClass(middleware)) throw wrongClass("middleware", middleware, "InteractionMiddleware");
-		if (!middlewares.register(middleware)) throw noRoutes("middleware", middleware.name, "@RegisterInteractionMiddleware");
-	}
-	return buildEngine(core, routes.maps, middlewares).handle;
+//#region src/dispatch/reportFault.ts
+function reportFault(error, uuid, dispatch, payload, core) {
+	const source = interactionSource(payload);
+	const from = {
+		uuid,
+		dispatchId: dispatch.id,
+		origin: dispatch.routeId
+	};
+	if (error instanceof Notice && source) core.bus[PublishDefault]("handledException", {
+		denial: error,
+		...from,
+		source
+	});
+	else core.bus[PublishDefault]("unknownException", {
+		...from,
+		error,
+		...actors(payload),
+		metadata: payload
+	});
 }
-
-//#endregion
-//#region src/inputs/pick.ts
-function pick(ids, bucket) {
-	const found = new Collection();
-	if (!ids || !bucket) return found;
-	for (const id of ids) if (Object.hasOwn(bucket, id)) found.set(id, bucket[id]);
-	return found;
+function actors(payload) {
+	const user = payload.member?.user ?? payload.user;
+	return {
+		guild: void 0,
+		user: user ? {
+			id: user.id,
+			username: user.username
+		} : void 0
+	};
+}
+function interactionSource(payload) {
+	const user = payload.member?.user ?? payload.user;
+	if (!user) return null;
+	const common = {
+		kind: "interaction",
+		userId: user.id,
+		guildId: payload.guild_id ?? null,
+		channelId: payload.channel?.id ?? null,
+		interactionId: payload.id,
+		raw: payload
+	};
+	if (payload.type === InteractionType.ApplicationCommand) {
+		const { data } = payload;
+		const isSlash = data.type === ApplicationCommandType.ChatInput;
+		return {
+			...common,
+			interactionKind: isSlash ? "slash" : "context-menu",
+			command: isSlash ? slashRouteOf(data) : data.name,
+			customId: null
+		};
+	}
+	if (payload.type === InteractionType.ModalSubmit) return {
+		...common,
+		interactionKind: "modal",
+		command: null,
+		customId: payload.data.custom_id
+	};
+	if (payload.type === InteractionType.MessageComponent) {
+		const isButton = payload.data.component_type === ComponentType.Button;
+		return {
+			...common,
+			interactionKind: isButton ? "button" : "select",
+			command: null,
+			customId: payload.data.custom_id
+		};
+	}
+	return null;
 }
 
 //#endregion
-//#region src/inputs/ModalFields.ts
-const FIELD_KINDS = {
-	[ComponentType.TextInput]: {
-		label: "a text input",
-		getter: "getTextInputValue"
-	},
-	[ComponentType.StringSelect]: {
-		label: "a string select",
-		getter: "getStringSelectValues"
-	},
-	[ComponentType.UserSelect]: {
-		label: "a user select",
-		getter: "getSelectedUsers"
-	},
-	[ComponentType.RoleSelect]: {
-		label: "a role select",
-		getter: "getSelectedRoles"
-	},
-	[ComponentType.MentionableSelect]: {
-		label: "a mentionable select",
-		getter: "getSelectedMentionables"
-	},
-	[ComponentType.ChannelSelect]: {
-		label: "a channel select",
-		getter: "getSelectedChannels"
-	},
-	[ComponentType.FileUpload]: {
-		label: "a file upload",
-		getter: "getUploadedFiles"
-	},
-	[ComponentType.RadioGroup]: {
-		label: "a radio group",
-		getter: "getRadioGroup"
-	},
-	[ComponentType.CheckboxGroup]: {
-		label: "a checkbox group",
-		getter: "getCheckboxGroup"
-	},
-	[ComponentType.Checkbox]: {
-		label: "a checkbox",
-		getter: "getCheckbox"
+//#region src/dispatch/dispatchInteraction.ts
+let dispatchLogger;
+function logger() {
+	dispatchLogger ??= new Logger("Dispatcher", { channel: "interactions" });
+	return dispatchLogger;
+}
+const HARMLESS_API_CODES = /* @__PURE__ */ new Set([
+	RESTJSONErrorCodes.UnknownInteraction,
+	RESTJSONErrorCodes.InteractionHasAlreadyBeenAcknowledged,
+	RESTJSONErrorCodes.UnknownMessage
+]);
+async function sendGuarded(routeId, send) {
+	try {
+		await send();
+	} catch (error) {
+		if (error instanceof DiscordAPIError && HARMLESS_API_CODES.has(error.code)) {
+			logger().debug(`boundary send hit harmless code ${paint.amber(String(error.code))}`);
+			return;
+		}
+		logger().error(`boundary send failed for route ${paint.sky.bold(routeId)}`, error);
 	}
-};
-function nameOfChannelType(type) {
-	return ChannelType[type] ?? String(type);
 }
-function listOf(values) {
-	return values ?? [];
+async function respondEmptyChoices(scope) {
+	const telemetry = {
+		bus: scope.core.bus,
+		dispatch: scope.dispatch,
+		interactionId: scope.payload.id
+	};
+	await reportedWrite(telemetry, "respond", () => scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
+		type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+		data: { choices: [] }
+	} }));
 }
-function isKind(entry, kinds) {
-	return kinds.includes(entry.type);
+function renderContext(scope, uuid) {
+	const { dispatch } = scope;
+	const developerUsername = scope.core.config.notifications?.developerUsername;
+	return developerUsername === void 0 ? {
+		uuid,
+		dispatch
+	} : {
+		uuid,
+		developerUsername,
+		dispatch
+	};
 }
-/**
-* The fields a modal carries, read by custom id.
-*
-* Every getter throws when no field in the modal has that custom id. It also throws when the field holds a
-* kind that getter does not read. The message names the getter that does.
-*
-* A select getter resolves the ids its field picked against the interaction's `resolved` data and returns a
-* `Collection` keyed by id. A field that picked nothing returns null. Pass `required` to throw there instead.
-*/
-var ModalFields = class {
-	entries = /* @__PURE__ */ new Map();
-	resolved;
-	constructor(data) {
-		this.resolved = data.resolved;
-		for (const component of data.components ?? []) {
-			if ("components" in component) for (const child of component.components) this.entries.set(child.custom_id, child);
-			if ("component" in component) this.entries.set(component.component.custom_id, component.component);
-		}
+async function handleNotice(notice, uuid, scope) {
+	if (notice.report) {
+		logger().error(`${notice.name}: ${paint.mute(uuid)}`, notice);
+		reportFault(notice, uuid, scope.dispatch, scope.payload, scope.core);
 	}
-	entry(customId) {
-		const found = this.entries.get(customId);
-		if (!found) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldNotFound, [customId]);
-		return found;
+	const { sender } = scope;
+	if (!sender) {
+		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
+		return;
 	}
-	field(customId, kinds) {
-		const entry = this.entry(customId);
-		if (!isKind(entry, kinds)) {
-			const known = FIELD_KINDS[entry.type];
-			const args = known ? [
-				customId,
-				known.label,
-				known.getter
-			] : [customId, `component type ${entry.type}`];
-			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldWrongKind, [...args]);
-		}
-		return entry;
+	const response = notice.render(renderContext(scope, uuid));
+	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: notice.ephemeral }));
+}
+async function handleRawFault(error, uuid, scope) {
+	const { core, sender } = scope;
+	logUnknownFault(logger(), paint.mute(uuid), error, core.config.errors);
+	reportFault(error, uuid, scope.dispatch, scope.payload, core);
+	if (!sender) {
+		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
+		return;
 	}
-	selected(customId, kinds, bucket, required) {
-		const { values } = this.field(customId, kinds);
-		const found = pick(values, bucket);
-		if (found.size > 0) return found;
-		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
-		return null;
+	const Override = core.config.errors?.defaultError;
+	const response = (Override ? new Override(uuid) : new Fault()).render(renderContext(scope, uuid));
+	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
+}
+async function handleFault(caught, scope) {
+	if (caught instanceof Silence) {
+		if (caught.reason !== void 0 && (scope.core.config.errors?.logSilences ?? true)) logger().debug(`Silence: ${caught.reason}`);
+		return;
 	}
-	getField(customId, kind) {
-		return kind === void 0 ? this.entry(customId) : this.field(customId, [kind]);
+	const uuid = crypto.randomUUID();
+	if (caught instanceof Notice) {
+		await handleNotice(caught, uuid, scope);
+		return;
 	}
-	getTextInputValue(customId) {
-		return this.field(customId, [ComponentType.TextInput]).value;
+	const error = asError(caught);
+	const ignore = new Set(scope.core.config.errors?.ignoreApiCodes ?? []);
+	if (error instanceof DiscordAPIError && ignore.has(error.code)) {
+		logger().debug(`swallowed api code ${paint.amber(String(error.code))}`);
+		return;
 	}
-	getStringSelectValues(customId) {
-		return listOf(this.field(customId, [ComponentType.StringSelect]).values);
+	await handleRawFault(error, uuid, scope);
+}
+function unhandledRouteId(match) {
+	if (match.routeId) return match.routeId;
+	const key = match.attemptedKey ?? "";
+	return `${match.kind}:${key.length > 0 ? key : "unrouted"}`;
+}
+function freshScope(match, payload, core, dispatch) {
+	const ref = {
+		application_id: payload.application_id,
+		id: payload.id,
+		token: payload.token
+	};
+	return {
+		core,
+		payload,
+		routeId: unhandledRouteId(match),
+		dispatch,
+		sender: match.kind === InteractionKind.Autocomplete ? null : new ReplySender(ref, core.rest, dispatch, core.bus)
+	};
+}
+function dispatchReporter(match, payload, core, dispatchId) {
+	const startedAt = performance.now();
+	const queuedMs = queuedMsFor(payload.id);
+	return (outcome) => {
+		reportDispatch(core.bus, {
+			dispatchId,
+			routeId: unhandledRouteId(match),
+			interactionId: payload.id,
+			kind: match.kind,
+			outcome,
+			fallback: match.routeId === null,
+			userId: (payload.member?.user ?? payload.user)?.id ?? null,
+			guildId: payload.guild_id ?? null,
+			startedAt,
+			queuedMs
+		});
+	};
+}
+async function answer(caught, scope, report, outcome = outcomeFor(caught)) {
+	try {
+		await handleFault(caught, scope);
+	} finally {
+		report(outcome);
 	}
-	getSelectedUsers(customId, required = false) {
-		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
-		return this.selected(customId, kinds, this.resolved?.users, required);
+}
+async function runMiddlewares(step, kind, sender) {
+	const { args, dispatch, ran } = step;
+	for (const Middleware of args.middlewares.chainFor(kind)) {
+		const event = args.payload;
+		const instance = new Middleware(event, args.core, dispatch, sender);
+		ran.push(instance);
+		await instance.execute();
 	}
-	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
-	getSelectedMembers(customId) {
-		const kinds = [ComponentType.UserSelect, ComponentType.MentionableSelect];
-		return this.selected(customId, kinds, this.resolved?.members, false);
+}
+async function refusalBeforeHandler(step) {
+	const { args, scope } = step;
+	const { kind } = args.match;
+	if (kind !== InteractionKind.Autocomplete && scope.sender) try {
+		await runMiddlewares(step, kind, scope.sender);
+	} catch (caught) {
+		return { caught };
 	}
-	getSelectedRoles(customId, required = false) {
-		const kinds = [ComponentType.RoleSelect, ComponentType.MentionableSelect];
-		return this.selected(customId, kinds, this.resolved?.roles, required);
+	return gateRefusal(step);
+}
+async function dispatchInteraction(args) {
+	const { match, payload, core } = args;
+	const routeId = unhandledRouteId(match);
+	const dispatch = new DispatchContext(routeId);
+	const report = dispatchReporter(match, payload, core, dispatch.id);
+	const Handler = match.ctor;
+	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(Handler.name)}`);
+	let handler;
+	try {
+		handler = new Handler(payload, core, dispatch);
+	} catch (caught) {
+		await answer(caught, freshScope(match, payload, core, dispatch), report);
+		return null;
 	}
-	getSelectedChannels(customId, required = false, channelTypes = []) {
-		const kinds = [ComponentType.ChannelSelect];
-		const picked = this.selected(customId, kinds, this.resolved?.channels, required);
-		if (!picked || channelTypes.length === 0) return picked;
-		for (const found of picked.values()) {
-			if (channelTypes.includes(found.type)) continue;
-			const allowed = channelTypes.map(nameOfChannelType).join(", ");
-			throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldChannelType, [
-				customId,
-				nameOfChannelType(found.type),
-				allowed
-			]);
+	const scope = {
+		core,
+		payload,
+		routeId,
+		dispatch,
+		sender: handler instanceof RepliableHandler$1 ? handler.sender : null
+	};
+	const ran = [];
+	const refusal = await refusalBeforeHandler({
+		args,
+		Handler,
+		dispatch,
+		scope,
+		ran
+	});
+	if (refusal) {
+		try {
+			await answer(refusal.caught, scope, report);
+		} finally {
+			await runAfter(ran, resultFor(refusal.caught), logger());
 		}
-		return picked;
-	}
-	getSelectedMentionables(customId, required = false) {
-		const { values } = this.field(customId, [ComponentType.MentionableSelect]);
-		const resolved = this.resolved;
-		const picked = {
-			users: pick(values, resolved?.users),
-			members: pick(values, resolved?.members),
-			roles: pick(values, resolved?.roles)
-		};
-		if (picked.users.size + picked.members.size + picked.roles.size > 0) return picked;
-		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
 		return null;
 	}
-	getUploadedFiles(customId, required = false) {
-		const kinds = [ComponentType.FileUpload];
-		return this.selected(customId, kinds, this.resolved?.attachments, required);
-	}
-	getRadioGroup(customId, required = false) {
-		const value = this.field(customId, [ComponentType.RadioGroup]).value ?? null;
-		if (value !== null) return value;
-		if (required) throw new SeedcordTypeError(SeedcordErrorCode.ModalFieldEmpty, [customId]);
+	return async () => {
+		let result = { outcome: "handled" };
+		try {
+			await handler.execute();
+			report("handled");
+		} catch (caught) {
+			result = resultFor(caught);
+			await answer(caught, scope, report);
+		} finally {
+			await runAfter(ran, result, logger());
+		}
+	};
+}
+async function gateRefusal(step) {
+	const { Handler, dispatch } = step;
+	const { match, payload, core } = step.args;
+	if (match.kind === InteractionKind.Autocomplete || payload.type === InteractionType.ApplicationCommandAutocomplete) return null;
+	const monitor = slowGateMonitor();
+	try {
+		await runHandlerGates(Handler, interactionGateContext(payload, core, dispatch), match.routeId ?? void 0, monitor?.observe);
 		return null;
+	} catch (caught) {
+		return { caught };
+	} finally {
+		monitor?.report(match.routeId);
 	}
-	getCheckboxGroup(customId) {
-		return listOf(this.field(customId, [ComponentType.CheckboxGroup]).values);
-	}
-	getCheckbox(customId) {
-		return this.field(customId, [ComponentType.Checkbox]).value;
-	}
-};
+}
 
 //#endregion
-//#region src/emojis/EmojiInjector.ts
-const emojiStorage = accessorStore();
-function reasonOf(error) {
-	return Error.isError(error) ? error.message : String(error);
-}
-function byName(list) {
-	const map = /* @__PURE__ */ new Map();
-	for (const entry of list) if (entry.name) map.set(entry.name, entry);
-	return map;
+//#region src/receiver/Ed25519Verifier.ts
+const PUBLIC_KEY_BYTES = 32;
+const SIGNATURE_BYTES = 64;
+const HEX_RADIX = 16;
+const HEX_PATTERN = /^[0-9a-f]+$/i;
+function hexToBytes(hex, byteLength) {
+	if (hex.length !== byteLength * 2 || !HEX_PATTERN.test(hex)) return null;
+	const bytes = new Uint8Array(byteLength);
+	for (let index = 0; index < byteLength; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), HEX_RADIX);
+	return bytes;
 }
-/**
-* The bot's resolved emojis, keyed by {@link EmojiMap}. Filled by {@link EmojiInjector} during startup.
-* Throws if you read a key the injector did not fill.
-*/
-const Emojis = guardedAccessor("Emojis", emojiStorage);
-var EmojiInjector = class {
-	core;
-	logger = new Logger("Emojis", { channel: "bot" });
-	constructor(core) {
-		this.core = core;
-	}
-	async init() {
-		clearStore(emojiStorage);
-		const configured = this.core.config.bot.emojis;
-		if (!configured || Object.keys(configured).length === 0) {
-			this.logger.debug("No emojis configured, skipping emoji injection.");
-			return;
-		}
-		const failures = [];
-		const guilds = /* @__PURE__ */ new Map();
-		let application;
-		for (const [key, value] of Object.entries(configured)) if (isEmojiTuple(value)) await this.resolveTuple(key, value, guilds, failures);
-		else if (typeof value === "string") {
-			application ??= await this.applicationEmojis(failures);
-			this.resolve(key, value, application, failures, "the application");
-		} 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 applicationEmojis(failures) {
-		try {
-			const appId = this.core.applicationId;
-			return byName((await this.core.rest.get(Routes.applicationEmojis(appId))).items);
-		} catch (error) {
-			failures.push(`  - the application emojis could not be read (${reasonOf(error)})`);
-			return /* @__PURE__ */ new Map();
-		}
-	}
-	async resolveTuple(key, [name, guildId], guilds, failures) {
-		let guild = guilds.get(guildId);
-		if (!guild) {
-			try {
-				guild = byName(await this.core.rest.get(Routes.guildEmojis(guildId)));
-			} catch (error) {
-				failures.push(`  - "${name}" for "${key}" targets guild ${guildId}, which could not be read (${reasonOf(error)})`);
-				return;
-			}
-			guilds.set(guildId, guild);
-		}
-		this.resolve(key, name, guild, failures, `guild ${guildId}`);
-	}
-	resolve(key, name, source, failures, where) {
-		const found = source.get(name);
-		if (!found?.id) {
-			failures.push(`  - "${name}" for "${key}" was not found in ${where}`);
-			return;
-		}
-		emojiStorage[key] = new ResolvedEmoji(name, found.id, found.animated ?? false);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/SlashHandler.ts
-/**
-* Base class for a chat-input (slash) command handler on the HTTP transport.
-*
-* Pass the route from the generated registry as the generic, 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 SlashRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
-*/
-var SlashHandler = class extends InteractionHandler {
-	resolver;
-	/**
-	* The typed options for this command's route. Only the getters for kinds this command declares appear.
-	* Each getter's name argument is restricted to that command's options of its kind.
-	*
-	* - A required option drops the null.
-	*
-	* - Choices narrow to their literal union.
-	*
-	* - A channel option declared with `addChannelTypes` narrows to those types.
-	*
-	* Rich kinds resolve from the interaction's `resolved` data.
-	*/
-	get options() {
-		this.resolver ??= new HttpSlashOptions(this.event.data);
-		return this.resolver;
-	}
-	/**
-	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* routes.
-	*
-	* 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.
-	*/
-	async match(arms) {
-		const route = slashRouteOf(this.event.data);
-		const arm = Object.hasOwn(arms, route) ? arms[route] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
-		return await arm(this.options);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/ContextMenuHandler.ts
-function armFor(arms, name) {
-	const arm = Object.hasOwn(arms, name) ? arms[name] : void 0;
-	if (typeof arm !== "function") throw new SeedcordTypeError(SeedcordErrorCode.ContextMenuMatchArmMissing, [name]);
-	return arm;
-}
-/**
-* Base class for a user context-menu command handler on the HTTP transport (right-click a user).
-*
-* Pass the command name(s) as the generic, the same as `@UserContextMenuRoute`. Read the right-clicked user
-* from `this.target` and that same user's guild member from `this.targetMember`.
-*
-* @typeParam Names - One or more command names from the generated user registry.
-*/
-var UserContextMenuHandler = class extends InteractionHandler {
-	get target() {
-		const { target_id: targetId, resolved } = this.event.data;
-		return resolved.users[targetId];
-	}
-	/** The right-clicked user's guild member, null outside a guild. */
-	get targetMember() {
-		const { target_id: targetId, resolved } = this.event.data;
-		return resolved.members?.[targetId] ?? null;
-	}
-	/** Which of the registered commands fired. */
-	get commandName() {
-		return this.event.data.name;
-	}
-	/**
-	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* names.
-	*
-	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-	* arm receives the clicked user and that user's guild member. The arms must cover every name in the
-	* generic. A missing name or an unknown key is a compile error.
-	*
-	* @param arms - One handler per registered command name.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@UserContextMenuRoute('View Profile', 'Warn')
-	* class Moderation extends UserContextMenuHandler<'View Profile' | 'Warn'> {
-	*     async execute() {
-	*         await this.match({
-	*             'View Profile': (user) => this.reply(`Profile for ${user.username}.`),
-	*             Warn: (user, member) => this.reply(`Warned ${member?.nick ?? user.username}.`)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		return await armFor(arms, this.event.data.name)(this.target, this.targetMember);
-	}
-};
-/**
-* Base class for a message context-menu command handler on the HTTP transport (right-click a message).
-*
-* Pass the command name(s) as the generic, the same as `@MessageContextMenuRoute`. Read the right-clicked
-* message from `this.target`.
-*
-* @typeParam Names - One or more command names from the generated message registry.
-*/
-var MessageContextMenuHandler = class extends InteractionHandler {
-	get target() {
-		const { target_id: targetId, resolved } = this.event.data;
-		return resolved.messages[targetId];
-	}
-	/** Which of the registered commands fired. */
-	get commandName() {
-		return this.event.data.name;
-	}
-	/**
-	* Run the arm for whichever command fired. Use this only when the handler is registered for several
-	* names.
-	*
-	* Provide one arm per registered name, keyed by the name Discord shows in the right-click menu. Each
-	* arm receives the clicked message. The arms must cover every name in the generic. A missing name or
-	* an unknown key is a compile error.
-	*
-	* @param arms - One handler per registered command name.
-	* @returns The result of the arm that ran.
-	*
-	* @example
-	* ```ts
-	* \@MessageContextMenuRoute('Report Message', 'Quote Message')
-	* class MessageTools extends MessageContextMenuHandler<'Report Message' | 'Quote Message'> {
-	*     async execute() {
-	*         await this.match({
-	*             'Report Message': (message) => this.report(message),
-	*             'Quote Message': (message) => this.reply(`> ${message.content}`)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		return await armFor(arms, this.event.data.name)(this.target);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ComponentHandler.ts
-/**
-* Shared base the customId-routed component handlers extend on the HTTP transport.
-*
-* Not a public entry point. Extend {@link ButtonHandler}, {@link ModalHandler}, or one of the select menu
-* bases instead. This class defines the customId decode, the route matching, and the source-message
-* verbs `update` and `deferUpdate`.
-*
-* @typeParam Event - The component or modal interaction type this handler processes
-* @typeParam Defs - The customId route definitions registered on the concrete handler
-*/
-var ComponentHandler = class extends InteractionHandler {
-	/** Rewrite the source message this component interaction came from. */
-	update(response) {
-		return this.sender.update(response);
-	}
-	/** Acknowledge the component without changing the source message. */
-	deferUpdate() {
-		return this.sender.deferUpdate();
-	}
-	decoded;
-	get route() {
-		this.decoded ??= decodeComponentRoute(this.constructor, this.event.data.custom_id);
-		return this.decoded;
-	}
-	/**
-	* The decoded params of the single route this handler is registered for.
-	*
-	* Reading this decodes `this.event.data.custom_id` once (cached after the first read) and throws
-	* `StaleCustomId` or `InvalidCustomId` when the wire no longer matches the current shape, which the
-	* dispatcher 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 cover every registered route prefix, checked at compile time, and a prefix
-	* unmatched at runtime throws `CustomIdMatchArmMissing`. Decoding runs before any arm, so a stale or
-	* corrupt wire throws before an arm body executes.
-	*
-	* @param arms - One callback 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.reply(`approved <@${userId}>`),
-	*             reject: ({ userId }) => this.reply(`rejected <@${userId}>`)
-	*         });
-	*     }
-	* }
-	* ```
-	*/
-	async match(arms) {
-		const { prefix, params } = this.route;
-		const arm = Object.hasOwn(arms, prefix) ? arms[prefix] : void 0;
-		if (!arm) throw new SeedcordTypeError(SeedcordErrorCode.CustomIdMatchArmMissing, [prefix]);
-		return await arm(params);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/ButtonHandler.ts
-/**
-* Base class for a button interaction handler on the HTTP transport.
-*
-* 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. Reply through the
-* handler members, or rewrite the source message with `this.update`. 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]`.
-*/
-var ButtonHandler = class extends ComponentHandler {};
-
-//#endregion
-//#region src/handlers/interaction/components/ModalHandler.ts
-/**
-* Base class for a modal submit handler on the HTTP transport.
-*
-* Register the customId definitions this handler decodes with `@ModalRoute` and list the same ones in the
-* generic. Read the submitted inputs from `this.fields`. Reply through the handler members. `showModal`
-* fails compilation on this kind, because Discord forbids opening a modal in response to a modal.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
-*
-* @example
-* ```ts
-* \@ModalRoute(ConfigId)
-* class ConfigModal extends ModalHandler<[typeof ConfigId]> {
-*     async execute() {
-*         const { guildId } = this.params;
-*         const name = this.fields.getTextInputValue('name');
-*         await this.reply(`saved ${name} for ${guildId}`);
-*     }
-* }
-* ```
-*/
-var ModalHandler = class extends ComponentHandler {
-	reader;
-	/** The fields this modal submitted, read by custom id. */
-	get fields() {
-		this.reader ??= new ModalFields(this.event.data);
-		return this.reader;
-	}
-	/** Rewrite the message this modal was opened from. Throws when a command opened the modal. */
-	update(response) {
-		this.ensureSourceMessage("update");
-		return super.update(response);
-	}
-	/** Acknowledge the submit without changing the source message. Throws when a command opened the modal. */
-	deferUpdate() {
-		this.ensureSourceMessage("deferUpdate");
-		return super.deferUpdate();
-	}
-	ensureSourceMessage(method) {
-		if (this.event.message) return;
-		throw new SeedcordError(SeedcordErrorCode.ReplyUpdateWithoutSource, [method, this.routeId]);
-	}
-};
-
-//#endregion
-//#region src/handlers/interaction/components/SelectMenuHandler.ts
-function resolvedOf(data) {
-	return data.resolved ?? {};
-}
-/**
-* Shared base the select menu handlers extend on the HTTP transport.
-*
-* Not a public entry point. Extend {@link StringMenuHandler}, {@link UserMenuHandler},
-* {@link RoleMenuHandler}, {@link ChannelMenuHandler}, or {@link MentionableMenuHandler} instead. This
-* class defines the `values` getter those bases share.
-*
-* @typeParam Event - The select menu interaction type this handler processes
-* @typeParam Defs - The customId route definitions registered on the concrete handler
-*/
-var SelectMenuHandler = class extends ComponentHandler {
-	/** The values this select picked. On every kind but the string menu they are snowflake ids. */
-	get values() {
-		return this.event.data.values ?? [];
-	}
-};
-/**
-* Base class for a string select menu handler on the HTTP transport.
-*
-* Register the customId definitions with `@StringMenuRoute`, list the same ones in the generic, then read
-* the chosen option values from `this.values`. Read `this.params` for a single route or `this.match` for
-* several. Reply through the handler members, or rewrite the source message with `this.update`.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof TopicsId]`.
-*
-* @example
-* ```ts
-* \@StringMenuRoute(TopicsId)
-* class Topics extends StringMenuHandler<[typeof TopicsId]> {
-*     async execute() {
-*         const { userId } = this.params;
-*         await this.update(`<@${userId}> now follows ${this.values.join(', ')}`);
-*     }
-* }
-* ```
-*/
-var StringMenuHandler = class extends SelectMenuHandler {};
-/**
-* Base class for a user select menu handler on the HTTP transport.
-*
-* Beside `this.values` this handler declares `this.users` and `this.members`. Register the customId
-* definitions with `@UserMenuRoute` and list the same ones in the generic.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
-*
-* @example
-* ```ts
-* \@UserMenuRoute(AssignId)
-* class Assign extends UserMenuHandler<[typeof AssignId]> {
-*     async execute() {
-*         const { roleId } = this.params;
-*         await this.reply(`assigning ${this.users.size} member(s) to <@&${roleId}>`);
-*     }
-* }
-* ```
-*/
-var UserMenuHandler = class extends SelectMenuHandler {
-	/** The users this select picked. */
-	get users() {
-		return pick(this.values, resolvedOf(this.event.data).users);
-	}
-	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
-	get members() {
-		return pick(this.values, resolvedOf(this.event.data).members);
-	}
-};
-/**
-* Base class for a role select menu handler on the HTTP transport.
-*
-* Beside `this.values` this handler declares `this.roles`. Register the customId definitions with
-* `@RoleMenuRoute` and list the same ones in the generic.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof GrantId]`.
-*
-* @example
-* ```ts
-* \@RoleMenuRoute(GrantId)
-* class Grant extends RoleMenuHandler<[typeof GrantId]> {
-*     async execute() {
-*         await this.update(`granting ${this.roles.size} role(s)`);
-*     }
-* }
-* ```
-*/
-var RoleMenuHandler = class extends SelectMenuHandler {
-	/** The roles this select picked. */
-	get roles() {
-		return pick(this.values, resolvedOf(this.event.data).roles);
+const encoder = new TextEncoder();
+var Ed25519Verifier = class {
+	key;
+	constructor(publicKeyHex) {
+		const publicKey = hexToBytes(publicKeyHex, PUBLIC_KEY_BYTES);
+		if (!publicKey) throw new SeedcordError(SeedcordErrorCode.ConfigInvalidEnv, ["DISCORD_PUBLIC_KEY", "64 hex characters"]);
+		this.key = crypto.subtle.importKey("raw", publicKey, "Ed25519", false, ["verify"]);
 	}
-};
-/**
-* Base class for a channel select menu handler on the HTTP transport.
-*
-* Beside `this.values` this handler declares `this.channels`. Register the customId definitions with
-* `@ChannelMenuRoute` and list the same ones in the generic.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof LogTargetId]`.
-*
-* @example
-* ```ts
-* \@ChannelMenuRoute(LogTargetId)
-* class LogTarget extends ChannelMenuHandler<[typeof LogTargetId]> {
-*     async execute() {
-*         await this.update(`logging to ${this.channels.size} channel(s)`);
-*     }
-* }
-* ```
-*/
-var ChannelMenuHandler = class extends SelectMenuHandler {
-	/** The channels this select picked. */
-	get channels() {
-		return pick(this.values, resolvedOf(this.event.data).channels);
+	async verify(signatureHex, timestamp, body) {
+		const signature = hexToBytes(signatureHex, SIGNATURE_BYTES);
+		if (!signature) return false;
+		const timestampBytes = encoder.encode(timestamp);
+		const message = new Uint8Array(timestampBytes.length + body.length);
+		message.set(timestampBytes, 0);
+		message.set(body, timestampBytes.length);
+		return crypto.subtle.verify("Ed25519", await this.key, signature, message);
 	}
 };
-/**
-* Base class for a mentionable select menu handler on the HTTP transport.
-*
-* A mentionable menu accepts users and roles together. `this.users`, `this.members`, and `this.roles`
-* can each come back empty.
-*
-* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof InviteId]`.
-*
-* @example
-* ```ts
-* \@MentionableMenuRoute(InviteId)
-* class Invite extends MentionableMenuHandler<[typeof InviteId]> {
-*     async execute() {
-*         await this.update(`inviting ${this.users.size} user(s) and ${this.roles.size} role(s)`);
-*     }
-* }
-* ```
-*/
-var MentionableMenuHandler = class extends SelectMenuHandler {
-	/** The users this select picked. */
-	get users() {
-		return pick(this.values, resolvedOf(this.event.data).users);
+
+//#endregion
+//#region src/receiver/ReplayGuard.ts
+const REPLAY_WINDOW_MS = 3e5;
+const SWEEP_GAP_MS = 6e4;
+const MS_PER_SECOND = 1e3;
+const TIMESTAMP_PATTERN = /^\d+$/;
+var ReplayGuard = class {
+	seen = /* @__PURE__ */ new Map();
+	lastSweep = Date.now();
+	fresh(timestampHeader) {
+		if (!TIMESTAMP_PATTERN.test(timestampHeader)) return null;
+		const timestampMs = Number(timestampHeader) * MS_PER_SECOND;
+		return Math.abs(Date.now() - timestampMs) <= REPLAY_WINDOW_MS ? timestampMs : null;
 	}
-	/** The guild members behind the picked users. Discord resolves these only inside a guild. */
-	get members() {
-		return pick(this.values, resolvedOf(this.event.data).members);
+	unseen(signatureHex, timestampMs) {
+		const now = Date.now();
+		this.maybeSweep(now);
+		const rejectUntil = this.seen.get(signatureHex);
+		if (rejectUntil !== void 0 && rejectUntil >= now) return false;
+		this.seen.set(signatureHex, timestampMs + REPLAY_WINDOW_MS);
+		return true;
 	}
-	/** The roles this select picked. */
-	get roles() {
-		return pick(this.values, resolvedOf(this.event.data).roles);
+	maybeSweep(now) {
+		if (now - this.lastSweep < SWEEP_GAP_MS) return;
+		this.lastSweep = now;
+		for (const [signature, rejectUntil] of this.seen) if (rejectUntil < now) this.seen.delete(signature);
 	}
 };
 
 //#endregion
-//#region src/subscribers/index.ts
-/**
-* Base class for an HTTP subscriber, binding `this.core` to the HTTP {@link Core}.
-*
-* @typeParam KeyOfSubscribers - The subscription key this handler receives
-*/
-var Subscriber$1 = class extends Subscriber {};
-/**
-* Base class for an HTTP subscriber that delivers its event to a Discord webhook, binding
-* `this.core` to the HTTP {@link Core}.
-*
-* @typeParam KeyOfSubscribers - The subscription key this reporter receives
-*/
-var WebhookLog$1 = class extends WebhookLog {};
-
-//#endregion
-//#region src/pagination/Paginator.ts
-function contextOf(interaction, core) {
-	return {
-		interaction,
-		user: interaction.member?.user ?? interaction.user,
-		guildId: interaction.guild_id ?? null,
-		core
-	};
+//#region src/engine.ts
+const SIGNATURE_HEADER = "x-signature-ed25519";
+const TIMESTAMP_HEADER = "x-signature-timestamp";
+const ACCEPTED = 202;
+const BAD_REQUEST = 400;
+const UNAUTHORIZED = 401;
+const METHOD_NOT_ALLOWED = 405;
+const PING = InteractionType.Ping;
+const decoder = new TextDecoder();
+function rejectNonPost(request) {
+	if (request.method === "POST") return void 0;
+	return new Response(null, {
+		status: METHOD_NOT_ALLOWED,
+		headers: { allow: "POST" }
+	});
 }
-/**
-* 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) => loadBans(ctx.guildId), { perPage: 10 }),
-*     renderItem: (ban) => ban.user.username
-* });
-*
-* \@ButtonRoute(Bans.cursor)
-* export class BansNav extends Bans.Handler {}
-* ```
-*/
-var Paginator = class extends PaginatorBase {
-	/** The nav handler base. Extend it with an empty body and decorate it, `@ButtonRoute(p.cursor)`. */
-	Handler;
-	constructor(config) {
-		super(config);
-		const pageFor = (handler, n) => this.page(handler, n);
-		this.Handler = class Nav extends ButtonHandler {
-			async execute() {
-				await this.deferUpdate();
-				const response = await pageFor(this, this.params.page);
-				await this.update(response);
-			}
-		};
-	}
-	/**
-	* Render a page as a {@link ReplyResponse} without sending anything.
-	*
-	* @param handler - The handler rendering the page, normally `this`.
-	* @param n - The zero-based page.
-	*/
-	async page(handler, n) {
-		return this.buildPage(contextOf(handler.getEvent(), handler.core), n);
+function hasInteractionType(payload) {
+	return typeof payload === "object" && payload !== null && "type" in payload && typeof payload.type === "number";
+}
+function buildEngine(core, maps, middlewares, publicKey) {
+	const verifier = new Ed25519Verifier(publicKey);
+	const replays = new ReplayGuard();
+	const logger = new Logger("Engine", { channel: "bot" });
+	async function dispatchMatched(match, payload, ctx) {
+		const start = await dispatchInteraction({
+			match,
+			payload,
+			core,
+			middlewares
+		});
+		if (!start) return;
+		const work = start().catch(rootFault);
+		ctx?.waitUntil(work);
 	}
-	/**
-	* Send a page through the handler's sender. The sender picks reply, edit, or followUp from its ack state.
-	*
-	* @param handler - The handler starting the paginator, normally `this`.
-	* @param n - The zero-based page to open on.
-	*/
-	async start(handler, n = 0) {
-		const response = await this.page(handler, n);
-		return handler.sender.send(response, { ephemeral: this.config.ephemeral ?? false });
+	function rootFault(caught) {
+		const error = asError(caught);
+		logger.error("dispatch failed past the boundary", error);
+		core.bus[PublishDefault]("unhandledInteractionError", { error });
 	}
-};
+	const handle = async (request, ctx) => {
+		const [response, outcome] = await respond(request, ctx);
+		logger.debug(`${paint.sky.bold(request.method)} ${outcome} ${paint.amber(String(response.status))}`);
+		return response;
+	};
+	const respond = async (request, ctx) => {
+		const notPost = rejectNonPost(request);
+		if (notPost) return [notPost, "not-post"];
+		const signature = request.headers.get(SIGNATURE_HEADER);
+		const timestamp = request.headers.get(TIMESTAMP_HEADER);
+		if (signature === null || timestamp === null) return [new Response(null, { status: UNAUTHORIZED }), "unsigned"];
+		const timestampMs = replays.fresh(timestamp);
+		if (timestampMs === null) return [new Response(null, { status: UNAUTHORIZED }), "stale"];
+		const body = new Uint8Array(await request.arrayBuffer());
+		if (!await verifier.verify(signature, timestamp, body)) return [new Response(null, { status: UNAUTHORIZED }), "bad-signature"];
+		let payload;
+		try {
+			payload = JSON.parse(decoder.decode(body));
+		} catch {
+			return [new Response(null, { status: BAD_REQUEST }), "bad-body"];
+		}
+		if (!hasInteractionType(payload)) return [new Response(null, { status: BAD_REQUEST }), "bad-body"];
+		if (payload.type === PING) return [Response.json({ type: InteractionResponseType.Pong }), "ping"];
+		if (!replays.unseen(signature, timestampMs)) return [new Response(null, { status: UNAUTHORIZED }), "replay"];
+		try {
+			core.bus[PublishDefault]("anyInteraction", { interaction: payload });
+			const match = resolve(maps, payload);
+			if (match) await dispatchMatched(match, payload, ctx);
+		} catch (caught) {
+			rootFault(caught);
+		}
+		return [new Response(null, { status: ACCEPTED }), "dispatched"];
+	};
+	return handle;
+}
 
 //#endregion
-//#region src/pagination/sources.ts
-/**
-* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
-* page, 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 extends ArraySourceBase {};
-/**
-* 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 extends CursorSourceBase {};
+//#region src/InteractionsService.ts
+var InteractionsService = class {
+	host;
+	rest;
+	rateLimiter;
+	bus;
+	subscribers;
+	interactions;
+	token;
+	builtEngine;
+	constructor(host, config, restOptions) {
+		this.host = host;
+		this.rest = new REST(restOptions);
+		this.rateLimiter = config.store ?? new MemoryRateLimiter();
+		this.bus = new Bus(host);
+		this.subscribers = new SubscriberLoader(this.bus, config.subscribers.path);
+		const interactions = config.bot.interactions;
+		this.interactions = interactions.path ? new InteractionDispatcher(interactions.path, interactions.middlewares) : void 0;
+	}
+	get applicationId() {
+		if (!this.token) throw new SeedcordError(SeedcordErrorCode.CoreApplicationUnavailable);
+		return this.token.applicationId;
+	}
+	authenticate() {
+		this.token = readBotToken();
+		this.rest.setToken(this.token.value);
+	}
+	get engine() {
+		if (!this.builtEngine) throw new SeedcordError(SeedcordErrorCode.CoreFetchBeforeStart);
+		return this.builtEngine;
+	}
+	prepareEngine(publicKey) {
+		this.builtEngine ??= this.createEngine(publicKey);
+		return this.builtEngine;
+	}
+	createEngine(publicKey) {
+		const maps = this.interactions?.maps ?? emptyRouteMaps();
+		const middlewares = this.interactions?.middlewares ?? new MiddlewareRegistry(interactionMiddleware);
+		return buildEngine(this.host, maps, middlewares, publicKey);
+	}
+};
 
 //#endregion
-//#region src/gates/Gated.ts
-/**
-* Attaches gates to an HTTP interaction 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. A gate
-* that requires a context the handler does not provide (a button gate on a slash handler, a gate on an
-* autocomplete handler, or a `RequirePermissions([...], { in: 'guild' })` gate the http transport cannot
-* satisfy) 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-api-types/v10';
-*
-* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.ManageMessages]))
-* \@SlashRoute('purge')
-* class Purge extends SlashHandler<'purge'> {
-*     async execute() {
-*         // both gates passed, so this runs in a guild with a caller who can moderate this channel
-*     }
-* }
-* ```
-*
-* @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 requires 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);
-	};
+//#region src/username.ts
+async function usernameOf(rest, logger) {
+	try {
+		const me = await rest.get(Routes.user("@me"));
+		if (me.username) logger.info(`Running as ${paint.sky.bold(me.username)}`);
+		return me.username;
+	} catch (caught) {
+		logger.warn("could not fetch the bot identity", caught);
+		return;
+	}
 }
 
 //#endregion
-//#region src/version.ts
-const version = "0.10.2";
-
-//#endregion
-export { InteractionHandler as A, createSeedcord as C, isHandlerClass as D, emptyRouteMaps as E, RepliableHandler$1 as M, ReplySender as N, isMiddlewareClass as O, ModalFields as S, RouteRegistry as T, MessageContextMenuHandler as _, Paginator as a, EmojiInjector as b, ChannelMenuHandler as c, SelectMenuHandler as d, StringMenuHandler as f, ComponentHandler as g, ButtonHandler as h, CursorSource as i, AutocompleteHandler as j, InteractionMiddleware as k, MentionableMenuHandler as l, ModalHandler as m, Gated as n, Subscriber$1 as o, UserMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, RoleMenuHandler as u, UserContextMenuHandler as v, buildEngine as w, Emojis as x, SlashHandler as y };
-//# sourceMappingURL=edge.index-DCP1BD6f.mjs.map
+export { Emojis as A, MessageContextMenuHandler as C, InteractionHandler as D, InteractionMiddleware as E, ModalFields as M, Plugin$1 as N, RepliableHandler$1 as O, AutocompleteHandler as S, SlashHandler as T, StringMenuHandler as _, HmrModuleHandler$1 as a, ButtonHandler as b, ArraySource as c, Subscriber$1 as d, WebhookLog$1 as f, SelectMenuHandler as g, RoleMenuHandler as h, HttpStartupTasks as i, installEmojis as j, ReplySender as k, CursorSource as l, MentionableMenuHandler as m, InteractionsService as n, version as o, ChannelMenuHandler as p, rejectNonPost as r, Gated as s, usernameOf as t, Paginator as u, UserMenuHandler as v, UserContextMenuHandler as w, ComponentHandler as x, ModalHandler as y };
+//# sourceMappingURL=username-3UsqzTSd.mjs.map