@seedcord/http 0.0.1 → 0.1.0-next.0

package/dist/index.mjs

@@ -1,7 +1,1014 @@
+import { SeedcordErrorCode } from "@seedcord/errors";
+import { SeedcordError, validateDiscordToken } from "@seedcord/errors/internal";
+import { Logger, paint } from "@seedcord/logger";
+import { ApplicationCommandOptionType, ApplicationCommandType, ComponentType, InteractionResponseType, InteractionType, MessageFlags, RESTJSONErrorCodes, Routes } from "discord-api-types/v10";
+import { Converters, Envapter } from "envapt";
+import { DiscordAPIError, REST } from "@discordjs/rest";
+import { BaseHandler, DispatchContext, Fault, Notice, RepliableHandler as RepliableHandler$1, Silence } from "@seedcord/core";
+import { BaseReplySender, GatedMetadataKey, decodeComponentRoute, deferFlags, prefixOf, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { MemoryRateLimiter } from "@seedcord/rate-limiter";
+import { buildSlashRoute } from "@seedcord/utils/internal";
+
+export * from "@seedcord/core"
+
+//#region src/reply/ReplySender.ts
+function wireAllowedMentions(mentions) {
+	const { repliedUser, ...wire } = mentions;
+	return {
+		...wire,
+		...repliedUser !== void 0 && { replied_user: repliedUser }
+	};
+}
+function wireAttachments(files) {
+	if (!files?.some((file) => file.description)) return null;
+	return files.map((file, index) => ({
+		id: index,
+		...file.name && { filename: file.name },
+		...file.description && { description: file.description }
+	}));
+}
+function callbackData(reply, flags) {
+	const attachments = wireAttachments(reply.files);
+	return {
+		flags,
+		components: reply.components,
+		...reply.allowedMentions && { allowed_mentions: wireAllowedMentions(reply.allowedMentions) },
+		...attachments && { attachments }
+	};
+}
+/**
+* Writes interaction responses over the Discord REST callback and webhook endpoints. Construction is
+* internal to the repliable handler bases and the dispatcher.
+*/
+var ReplySender = class extends BaseReplySender {
+	ref;
+	rest;
+	constructor(ref, rest, routeId) {
+		super(routeId);
+		this.ref = ref;
+		this.rest = rest;
+	}
+	async writeReply(response, opts) {
+		const reply = this.serialize(response);
+		const result = await this.callback(InteractionResponseType.ChannelMessageWithSource, callbackData(reply, sendFlags(opts)), reply.files);
+		return this.createdMessage(result);
+	}
+	async writeDefer(opts) {
+		await this.callback(InteractionResponseType.DeferredChannelMessageWithSource, { flags: deferFlags(opts) });
+	}
+	async writeDeferUpdate() {
+		await this.callback(InteractionResponseType.DeferredMessageUpdate);
+	}
+	async writeUpdate(response) {
+		const reply = this.serialize(response);
+		const result = await this.callback(InteractionResponseType.UpdateMessage, callbackData(reply, MessageFlags.IsComponentsV2), reply.files);
+		return this.createdMessage(result);
+	}
+	async writeFollowUp(response, opts) {
+		const reply = this.serialize(response);
+		return await this.rest.post(Routes.webhook(this.ref.application_id, this.ref.token), {
+			body: callbackData(reply, sendFlags(opts)),
+			query: new URLSearchParams({ wait: "true" }),
+			...reply.files && { files: this.rawFiles(reply.files) }
+		});
+	}
+	writeEditOriginal(response) {
+		return this.editMessage(Routes.webhookMessage(this.ref.application_id, this.ref.token), this.serialize(response));
+	}
+	writeEditTarget(targetId, response) {
+		const route = Routes.webhookMessage(this.ref.application_id, this.ref.token, targetId);
+		return this.editMessage(route, this.serialize(response));
+	}
+	async writeDeleteOriginal() {
+		await this.rest.delete(Routes.webhookMessage(this.ref.application_id, this.ref.token));
+	}
+	async writeDeleteTarget(targetId) {
+		await this.rest.delete(Routes.webhookMessage(this.ref.application_id, this.ref.token, targetId));
+	}
+	async writeModal(data) {
+		await this.callback(InteractionResponseType.Modal, data);
+	}
+	async callback(type, data, files) {
+		const withResponse = type === InteractionResponseType.ChannelMessageWithSource || type === InteractionResponseType.UpdateMessage;
+		return await this.rest.post(Routes.interactionCallback(this.ref.id, this.ref.token), {
+			body: {
+				type,
+				...data !== void 0 && { data }
+			},
+			...withResponse && { query: new URLSearchParams({ with_response: "true" }) },
+			...files && { files: this.rawFiles(files) }
+		});
+	}
+	async editMessage(route, reply) {
+		return await this.rest.patch(route, {
+			body: callbackData(reply, MessageFlags.IsComponentsV2),
+			...reply.files && { files: this.rawFiles(reply.files) }
+		});
+	}
+	rawFiles(files) {
+		return files.map((file, index) => ({
+			name: file.name ?? `file-${index}`,
+			data: file.attachment
+		}));
+	}
+	createdMessage(result) {
+		return result.resource?.message;
+	}
+};
+
+//#endregion
+//#region src/handlers/RepliableHandler.ts
+/**
+* Shared base the repliable HTTP interaction handlers extend.
+*
+* Not a public entry point. Extend {@link SlashHandler}, {@link ButtonHandler}, {@link ModalHandler},
+* {@link SelectMenuHandler}, or {@link ContextMenuHandler} instead. This class binds the core reply base
+* to the http sender.
+*
+* @typeParam Event - The repliable interaction type this handler processes
+*/
+var RepliableHandler = class extends RepliableHandler$1 {
+	buildSender(event, core, routeId) {
+		return new ReplySender({
+			application_id: event.application_id,
+			id: event.id,
+			token: event.token
+		}, core.rest, routeId);
+	}
+};
+
+//#endregion
+//#region src/gates/context.ts
+function interactionGateContext(payload, core, routeId) {
+	const member = payload.member ?? null;
+	const resolved = member?.user ?? payload.user;
+	return {
+		kind: "interaction",
+		core,
+		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),
+		routeId
+	};
+}
+
+//#endregion
+//#region src/dispatch/dispatchInteraction.ts
+let dispatchLogger;
+function logger() {
+	dispatchLogger ??= new Logger("Dispatcher");
+	return dispatchLogger;
+}
+function createCore(config, token) {
+	return {
+		config,
+		rateLimiter: config.store ?? new MemoryRateLimiter(),
+		rest: new REST().setToken(token),
+		version: "0.1.0-next.0",
+		username: void 0,
+		augmentTarget: "@seedcord/http"
+	};
+}
+function isHandlerCtor(value) {
+	return typeof value === "function" && value.prototype instanceof BaseHandler;
+}
+function handlerCtorOf(moduleExports) {
+	if (typeof moduleExports !== "object" || moduleExports === null) return null;
+	for (const value of Object.values(moduleExports)) if (isHandlerCtor(value)) return value;
+	return null;
+}
+const HARMLESS_API_CODES = 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);
+	}
+}
+async function respondEmptyChoices(scope) {
+	await scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
+		type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+		data: { choices: [] }
+	} });
+}
+function renderContext(core, uuid) {
+	const developerUsername = core.config.notifications?.developerUsername;
+	return developerUsername === void 0 ? { uuid } : {
+		uuid,
+		developerUsername
+	};
+}
+async function handleNotice(notice, uuid, scope) {
+	if (notice.report) logger().error(`${notice.name}: ${paint.mute(uuid)}`, notice);
+	const { sender } = scope;
+	if (!sender) {
+		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
+		return;
+	}
+	const response = notice.render(renderContext(scope.core, 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}`);
+	if (!sender) {
+		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
+		return;
+	}
+	const override = core.config.errors?.defaultError;
+	const response = (override ? new override(uuid) : new Fault()).render(renderContext(core, uuid));
+	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
+}
+async function handleFault(caught, scope) {
+	if (caught instanceof Silence) {
+		if (caught.reason !== void 0) logger().debug(`Silence: ${caught.reason}`);
+		return;
+	}
+	const uuid = crypto.randomUUID();
+	if (caught instanceof Notice) {
+		await handleNotice(caught, uuid, scope);
+		return;
+	}
+	const error = Error.isError(caught) ? caught : new Error(String(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 freshScope(match, payload, core) {
+	const ref = {
+		application_id: payload.application_id,
+		id: payload.id,
+		token: payload.token
+	};
+	const routeId = match.routeId ?? "unhandled";
+	return {
+		core,
+		payload,
+		routeId,
+		sender: match.kind === "autocomplete" ? null : new ReplySender(ref, core.rest, routeId)
+	};
+}
+/**
+* Runs the pre-ack phase for a matched interaction. Loads the route module, constructs the handler, and
+* runs its gates, and the sender posts any refusal. Returns the post-ack execute continuation, or null
+* when a gate refuses or nothing can run.
+*/
+async function dispatchInteraction(args) {
+	const { match, payload, core } = args;
+	let moduleExports;
+	try {
+		moduleExports = await match.load();
+	} catch (caught) {
+		logger().error(`Route ${paint.sky.bold(match.routeId ?? "unhandled")} failed to load its module.`, caught);
+		await handleFault(caught, freshScope(match, payload, core));
+		return null;
+	}
+	const ctor = handlerCtorOf(moduleExports);
+	if (!ctor) {
+		const routeId = match.routeId ?? "unhandled";
+		logger().error(`Route ${paint.sky.bold(routeId)} loaded a module with no handler class.`);
+		await handleFault(/* @__PURE__ */ new Error(`route ${routeId} loaded a module with no handler class`), freshScope(match, payload, core));
+		return null;
+	}
+	const dispatch = new DispatchContext(match.routeId);
+	let handler;
+	try {
+		handler = new ctor(payload, core, dispatch);
+	} catch (caught) {
+		await handleFault(caught, freshScope(match, payload, core));
+		return null;
+	}
+	const scope = {
+		core,
+		payload,
+		routeId: match.routeId ?? handler.constructor.name,
+		sender: handler instanceof RepliableHandler ? handler.getSender() : null
+	};
+	if (!await passedGates(ctor, match, payload, core, scope)) return null;
+	return async () => {
+		try {
+			await handler.execute();
+		} catch (caught) {
+			await handleFault(caught, scope);
+		}
+	};
+}
+async function passedGates(ctor, match, payload, core, scope) {
+	if (match.kind === "autocomplete" || payload.type === InteractionType.ApplicationCommandAutocomplete) return true;
+	const monitor = slowGateMonitor();
+	try {
+		await runHandlerGates(ctor, interactionGateContext(payload, core, match.routeId), match.routeId ?? void 0, monitor?.observe);
+		return true;
+	} catch (caught) {
+		await handleFault(caught, scope);
+		return false;
+	} finally {
+		monitor?.report(match.routeId);
+	}
+}
+
+//#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;
+}
+
+//#endregion
+//#region src/dispatch/slashRouteOf.ts
+/**
+* Computes the dispatch route for a chat-input or autocomplete payload, the raw-payload port of the
+* gateway's `slashRouteOf`. Both assemble keys through `buildSlashRoute`, so a dispatched interaction
+* and a generated registry key always match.
+*/
+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
+/**
+* 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 SlashOptionRegistry}, e.g. `'search'`.
+*/
+var AutocompleteHandler = class extends BaseHandler {
+	constructor(event, core, dispatch) {
+		super(event, core, dispatch);
+	}
+	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, so
+	* 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. A
+	* focused field with no arm, only reachable from a stale-deployed command, throws at runtime.
+	*
+	* @param arms - One handler per autocompletable field, keyed by field name.
+	* @returns The result of the arm that ran.
+	*/
+	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 SeedcordError(SeedcordErrorCode.AutocompleteMatchArmMissing, [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 this.core.rest.post(Routes.interactionCallback(this.event.id, this.event.token), { body: {
+			type: InteractionResponseType.ApplicationCommandAutocompleteResult,
+			data: { choices }
+		} });
+	}
+	/** The firing command route, for a field whose completion differs per registered command. */
+	get route() {
+		return slashRouteOf(this.event.data);
+	}
+	/**
+	* The already-entered options on this command, restricted to the kinds Discord resolves during autocomplete
+	* (string, integer, number, boolean) with every read nullable, since a sibling is partial while the user
+	* types the focused field. The focused field is on `this.focused`.
+	*/
+	get options() {
+		return this.reader;
+	}
+};
+
+//#endregion
+//#region src/handlers/defaults/UnhandledAutocomplete.ts
+/**
+* Default handler for autocomplete no manifest row matches.
+* Empty choices are the only legal answer, they clear the pending state.
+*
+* @internal
+*/
+var UnhandledAutocomplete = class extends AutocompleteHandler {
+	async execute() {
+		await this.respond([]);
+	}
+};
+
+//#endregion
+//#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 SelectMenuHandler}, or {@link ModalHandler} 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 {
+	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/handlers/defaults/UnhandledRepliable.ts
+/**
+* Default handler for interactions no manifest row matches. A reply failure here
+* goes directly to the dispatch fault boundary, so it needs no guard of its own.
+*
+* @internal
+*/
+var UnhandledRepliable = class extends InteractionHandler {
+	async execute() {
+		await this.reply("Feature not implemented yet.");
+	}
+};
+
+//#endregion
+//#region src/dispatch/resolve.ts
+const COMPONENT_KIND = {
+	button: "button",
+	stringSelect: "stringMenu",
+	userSelect: "userMenu",
+	roleSelect: "roleMenu",
+	channelSelect: "channelMenu",
+	mentionableSelect: "mentionableMenu",
+	modal: "modal"
+};
+function commandKind(type) {
+	switch (type) {
+		case ApplicationCommandType.ChatInput: return "slash";
+		case ApplicationCommandType.User: return "userContextMenu";
+		case ApplicationCommandType.Message: return "messageContextMenu";
+		default: return null;
+	}
+}
+function componentMapKey(type) {
+	switch (type) {
+		case ComponentType.Button: return "button";
+		case ComponentType.StringSelect: return "stringSelect";
+		case ComponentType.UserSelect: return "userSelect";
+		case ComponentType.RoleSelect: return "roleSelect";
+		case ComponentType.ChannelSelect: return "channelSelect";
+		case ComponentType.MentionableSelect: return "mentionableSelect";
+		default: return null;
+	}
+}
+function set(map, kind, key, load) {
+	map.set(key, {
+		kind,
+		routeId: `${kind}:${key}`,
+		load
+	});
+}
+/** Builds the per-kind lookup maps. */
+function buildRouteMaps(manifest) {
+	const maps = {
+		slash: /* @__PURE__ */ new Map(),
+		userContextMenu: /* @__PURE__ */ new Map(),
+		messageContextMenu: /* @__PURE__ */ new Map(),
+		autocomplete: /* @__PURE__ */ new Map(),
+		components: {
+			button: /* @__PURE__ */ new Map(),
+			stringSelect: /* @__PURE__ */ new Map(),
+			userSelect: /* @__PURE__ */ new Map(),
+			roleSelect: /* @__PURE__ */ new Map(),
+			channelSelect: /* @__PURE__ */ new Map(),
+			mentionableSelect: /* @__PURE__ */ new Map(),
+			modal: /* @__PURE__ */ new Map()
+		}
+	};
+	for (const row of manifest.commands) {
+		const kind = commandKind(row.type);
+		if (kind) set(maps[kind], kind, row.name, row.load);
+	}
+	for (const row of manifest.autocomplete) set(maps.autocomplete, "autocomplete", row.name, row.load);
+	for (const row of manifest.components) set(maps.components[row.kind], COMPONENT_KIND[row.kind], row.prefix, row.load);
+	return maps;
+}
+function unhandled(kind) {
+	return {
+		kind,
+		routeId: null,
+		load: () => Promise.resolve(kind === "autocomplete" ? { UnhandledAutocomplete } : { UnhandledRepliable })
+	};
+}
+/**
+* Matches a verified non-PING interaction to its manifest row. A known kind with no row resolves to the
+* unhandled default, whose handler replies "Feature not implemented yet." (empty choices on autocomplete).
+* Null is an unrecognized payload shape, which the engine acks with a 202 without dispatching.
+* Components and modals route by the stable customId prefix, so a wire whose layout hash drifted still
+* routes to its handler, where decode refuses with `StaleCustomId`.
+*/
+function resolve(maps, interaction) {
+	switch (interaction.type) {
+		case InteractionType.ApplicationCommand: {
+			if (interaction.data.type === ApplicationCommandType.ChatInput) return maps.slash.get(slashRouteOf(interaction.data)) ?? unhandled("slash");
+			const kind = commandKind(interaction.data.type);
+			return kind ? maps[kind].get(interaction.data.name) ?? unhandled(kind) : null;
+		}
+		case InteractionType.ApplicationCommandAutocomplete: return maps.autocomplete.get(slashRouteOf(interaction.data)) ?? unhandled("autocomplete");
+		case InteractionType.MessageComponent: {
+			const key = componentMapKey(interaction.data.component_type);
+			if (!key) return null;
+			return maps.components[key].get(prefixOf(interaction.data.custom_id)) ?? unhandled(COMPONENT_KIND[key]);
+		}
+		case InteractionType.ModalSubmit: return maps.components.modal.get(prefixOf(interaction.data.custom_id)) ?? unhandled("modal");
+		default: return null;
+	}
+}
+
+//#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 SeedcordError(SeedcordErrorCode.ConfigIncorrectPublicKey);
+		this.key = crypto.subtle.importKey("raw", publicKey, "Ed25519", false, ["verify"]);
+	}
+	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);
+	}
+};
+
+//#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();
+	accepts(signatureHex, timestampHeader) {
+		const now = Date.now();
+		this.maybeSweep(now);
+		if (!TIMESTAMP_PATTERN.test(timestampHeader)) return false;
+		const timestampMs = Number(timestampHeader) * MS_PER_SECOND;
+		if (Math.abs(now - timestampMs) > REPLAY_WINDOW_MS) return false;
+		const rejectUntil = this.seen.get(signatureHex);
+		if (rejectUntil !== void 0 && rejectUntil >= now) return false;
+		this.seen.set(signatureHex, timestampMs + REPLAY_WINDOW_MS);
+		return true;
+	}
+	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/createSeedcord.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";
+}
+/**
+* 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.
+*/
+function createSeedcord(config, manifest) {
+	if (!Envapter.has("DISCORD_PUBLIC_KEY")) throw new SeedcordError(SeedcordErrorCode.ConfigMissingPublicKey);
+	const publicKey = Envapter.getRequired("DISCORD_PUBLIC_KEY", Converters.String);
+	const token = validateDiscordToken(Envapter.get("DISCORD_BOT_TOKEN"));
+	const verifier = new Ed25519Verifier(publicKey);
+	const replays = new ReplayGuard();
+	const maps = buildRouteMaps(manifest);
+	const inFlight = /* @__PURE__ */ new Set();
+	const core = createCore(config, token);
+	const logger = new Logger("Engine");
+	async function dispatchMatched(match, payload, ctx) {
+		const start = await dispatchInteraction({
+			match,
+			payload,
+			core
+		});
+		if (!start) return;
+		const work = start();
+		if (ctx) ctx.waitUntil(work);
+		else {
+			inFlight.add(work);
+			work.finally(() => inFlight.delete(work));
+		}
+	}
+	return async (request, ctx) => {
+		if (request.method !== "POST") return new Response(null, {
+			status: METHOD_NOT_ALLOWED,
+			headers: { allow: "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 });
+		const body = new Uint8Array(await request.arrayBuffer());
+		if (!await verifier.verify(signature, timestamp, body)) return new Response(null, { status: UNAUTHORIZED });
+		if (!replays.accepts(signature, timestamp)) return new Response(null, { status: UNAUTHORIZED });
+		let payload;
+		try {
+			payload = JSON.parse(decoder.decode(body));
+		} catch {
+			return new Response(null, { status: BAD_REQUEST });
+		}
+		if (!hasInteractionType(payload)) return new Response(null, { status: BAD_REQUEST });
+		if (payload.type === PING) return Response.json({ type: InteractionResponseType.Pong });
+		try {
+			const match = resolve(maps, payload);
+			if (match) await dispatchMatched(match, payload, ctx);
+		} catch (caught) {
+			logger.error("dispatch failed, acking anyway", caught);
+		}
+		return new Response(null, { status: ACCEPTED });
+	};
+}
+
+//#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 SlashOptionRegistry}, e.g. `'ban'` or `'ban' | 'kick'`.
+*/
+var SlashHandler = class extends InteractionHandler {
+	resolver;
+	/**
+	* The typed options for this command's route. Required options drop the null, choices narrow to their
+	* literal union, and only the getters for kinds this command actually uses appear. 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 SeedcordError(SeedcordErrorCode.SlashMatchArmMissing, [route]);
+		return await arm(this.options);
+	}
+};
+
+//#endregion
+//#region src/handlers/interaction/ContextMenuHandler.ts
+/**
+* Base class for a context-menu command handler on the HTTP transport (right-click a user or a message).
+*
+* Pass the kind from {@link ApplicationCommandType} as the generic. Read the right-clicked entity from
+* `this.target`, an `APIUser` for a user menu and an `APIMessage` for a message menu. Context menus carry
+* no options, so a handler registered for several names reads `this.target` uniformly with no per-name
+* branch.
+*
+* @typeParam Kind - `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
+*/
+var ContextMenuHandler = class extends InteractionHandler {
+	get target() {
+		const data = this.event.data;
+		return data.type === ApplicationCommandType.User ? data.resolved.users[data.target_id] : data.resolved.messages[data.target_id];
+	}
+	/**
+	* The right-clicked user's guild member, resolved only on user menus fired in a guild. Reading it on a
+	* message menu is a compile error.
+	*/
+	get targetMember() {
+		const data = this.event.data;
+		return data.type === ApplicationCommandType.User ? data.resolved.members?.[data.target_id] ?? null : null;
+	}
+};
+
+//#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 SelectMenuHandler}, or {@link ModalHandler}
+* 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 SeedcordError(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/SelectMenuHandler.ts
+/**
+* Base class for a select menu handler on the HTTP transport.
+*
+* Pass the select kind first and the customId definitions second, the same order as `@SelectMenuRoute`,
+* so `this.event.data` and its `values`/`resolved` are narrowed to that kind. Read `this.params` for a
+* single route or `this.match` for several, and reply through the handler members or rewrite the source
+* message with `this.update`.
+*
+* @typeParam Kind - The select kind from {@link SelectMenuKind}, e.g. `SelectMenuKind.User`.
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof AssignId]`.
+*/
+var SelectMenuHandler = 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 off `this.event.data.components`. Reply through the handler members.
+* Discord forbids opening a modal in response to a modal, so `showModal` fails compilation on this kind.
+*
+* @typeParam Defs - The customId definitions this handler decodes, e.g. `[typeof ConfigId]`.
+*/
+var ModalHandler = class extends ComponentHandler {
+	/** Rewrite the message this modal was opened from (only when a component opened it). */
+	update(response) {
+		this.ensureSourceMessage("update");
+		return super.update(response);
+	}
+	/** Silently acknowledge, leaving the source message untouched. */
+	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/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, so each must pass. 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/index.ts
 /** Package version */
-const version = "0.0.1";
+const version = "0.1.0-next.0";
 
 //#endregion
-export { version };
+export { AutocompleteHandler, ButtonHandler, ComponentHandler, ContextMenuHandler, Gated, InteractionHandler, ModalHandler, RepliableHandler, SelectMenuHandler, SlashHandler, createSeedcord, version };
 //# sourceMappingURL=index.mjs.map