@azurioh/discord-kernel 0.1.0 → 1.0.0

package/src/color.ts

@@ -0,0 +1,134 @@
+/**
+ * The generic web colours, at the value the name carries everywhere else — an
+ * administrator typing `orange` gets the orange they would get in CSS, not a
+ * shade this module invented.
+ */
+const RED = "#ff0000";
+const BLUE = "#0000ff";
+const GREEN = "#008000";
+const YELLOW = "#ffff00";
+const ORANGE = "#ffa500";
+const PURPLE = "#800080";
+const PINK = "#ffc0cb";
+const WHITE = "#ffffff";
+
+/**
+ * Discord's own brand colour. Kept with the base names rather than in the
+ * Discord ring so a `blurple` setting means the same colour on every surface,
+ * and so embeds fall back to it when a bot declares no palette.
+ */
+export const DISCORD_BLURPLE = "#5865f2";
+
+/**
+ * Not `#000000`: Discord reads a zero colour as "no colour set" and renders the
+ * default grey bar instead, so pure black is the one value an administrator
+ * could ask for and never see. One step off zero reads as black.
+ */
+const BLACK = "#010101";
+
+const GREY = "#808080";
+const CYAN = "#00ffff";
+const BROWN = "#a52a2a";
+const SILVER = "#c0c0c0";
+const TURQUOISE = "#40e0d0";
+const MAGENTA = "#ff00ff";
+const NAVY = "#000080";
+
+/**
+ * Colour names an administrator may type instead of a hex code, French and
+ * English side by side.
+ *
+ * This table is **input vocabulary, not display text**. Nothing in it is ever
+ * shown to anyone, and its keys must never be translated at runtime: a catalog
+ * lookup resolves against the reply locale, which would make `rouge` stop
+ * working the moment an admin's Discord is set to English — the opposite of the
+ * point. Both spellings are accepted from everyone, always, which only a flat
+ * table can promise.
+ *
+ * Fixed on purpose: a value stored from one of these names must mean the same
+ * colour in every bot. Names a bot adds for its own inputs live with those
+ * inputs, not here.
+ */
+export const BASE_COLOR_NAMES: Readonly<Record<string, string>> = {
+	red: RED,
+	rouge: RED,
+	blue: BLUE,
+	bleu: BLUE,
+	green: GREEN,
+	vert: GREEN,
+	yellow: YELLOW,
+	jaune: YELLOW,
+	orange: ORANGE,
+	purple: PURPLE,
+	// French for purple, not the CSS `violet` (a pale pink): an admin typing it
+	// here is asking for the colour the word means in their own language.
+	violet: PURPLE,
+	pink: PINK,
+	rose: PINK,
+	white: WHITE,
+	blanc: WHITE,
+	black: BLACK,
+	noir: BLACK,
+	grey: GREY,
+	gray: GREY,
+	gris: GREY,
+	cyan: CYAN,
+	brown: BROWN,
+	marron: BROWN,
+	silver: SILVER,
+	argent: SILVER,
+	argenté: SILVER,
+	turquoise: TURQUOISE,
+	magenta: MAGENTA,
+	navy: NAVY,
+	marine: NAVY,
+	blurple: DISCORD_BLURPLE,
+};
+
+/**
+ * Accents must not be a trap: `dore` and `doré` are the same request, and an
+ * administrator has no way of knowing which one a table happened to spell.
+ * Case and surrounding whitespace are folded for the same reason.
+ */
+export function normalizeColorName(raw: string): string {
+	return raw
+		.trim()
+		.toLowerCase()
+		.normalize("NFD")
+		.replace(/\p{Diacritic}/gu, "");
+}
+
+/** Index a name → `#rrggbb` table by {@link normalizeColorName}, so lookups fold case and accents. */
+export function indexColorNames(names: Readonly<Record<string, string>>): Map<string, string> {
+	return new Map(Object.entries(names).map(([name, hex]) => [normalizeColorName(name), hex]));
+}
+
+const BASE_COLORS_BY_NORMALIZED_NAME: ReadonlyMap<string, string> =
+	indexColorNames(BASE_COLOR_NAMES);
+
+/** `#RGB` and `#RRGGBB`, with or without the leading hash. */
+const HEX_COLOR_PATTERN = /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+
+/**
+ * Normalize a hexadecimal colour code to `#rrggbb`, `null` when the input is
+ * not one. Surrounding whitespace is ignored.
+ */
+export function parseHexColor(raw: string): string | null {
+	const value = raw.trim();
+	if (!HEX_COLOR_PATTERN.test(value)) {
+		return null;
+	}
+	const digits = value.replace("#", "").toLowerCase();
+	const expanded =
+		digits.length === 3 ? [...digits].map((digit) => `${digit}${digit}`).join("") : digits;
+	return `#${expanded}`;
+}
+
+/**
+ * Normalize a colour to `#rrggbb`, from a hexadecimal code or from one of the
+ * {@link BASE_COLOR_NAMES}. `null` for anything else: the refusal belongs to
+ * whichever caller asked, so this only reports that it could not read the value.
+ */
+export function parseColor(raw: string): string | null {
+	return BASE_COLORS_BY_NORMALIZED_NAME.get(normalizeColorName(raw)) ?? parseHexColor(raw);
+}

package/src/discord/command/all-required.ts

@@ -0,0 +1,12 @@
+import type { Option, Options } from "@/discord/command/options";
+
+type AsRequired<O> = O extends Option<infer V, boolean> ? Option<V, true> : never;
+
+/** Turn every option in a record into its required variant. */
+export function allRequired<O extends Options>(fields: O): { [K in keyof O]: AsRequired<O[K]> } {
+	const out = {} as { [K in keyof O]: AsRequired<O[K]> };
+	for (const [key, option] of Object.entries(fields)) {
+		out[key as keyof O] = option.required() as AsRequired<O[keyof O]>;
+	}
+	return out;
+}

package/src/discord/command/autocomplete-dispatcher.ts

@@ -1,6 +1,7 @@
 import type { Interaction } from "discord.js";
 import type { SlashCommand } from "@/discord/command/types";
 import type { InteractionDispatcher } from "@/discord/interaction/interaction-router";
+import { errorMessage } from "@/errors/error-message";
 import type { Logger } from "@/logger";
 
 /**
@@ -44,7 +45,7 @@ export class AutocompleteDispatcher implements InteractionDispatcher {
 			this.logger.error(
 				{
 					command: interaction.commandName,
-					err: error instanceof Error ? error.message : String(error),
+					err: errorMessage(error),
 				},
 				"Autocomplete handler failed",
 			);

package/src/discord/command/autocomplete-limits.ts

@@ -0,0 +1,2 @@
+/** Discord refuses an autocomplete response carrying more than this many choices. */
+export const MAX_AUTOCOMPLETE_CHOICES = 25;

package/src/discord/command/autocomplete.ts

@@ -1,6 +1,9 @@
 import type { AutocompleteInteraction } from "discord.js";
-import { type CompiledSubcommand, routeKey } from "@/discord/command/create-command";
-import type { Choice, Options } from "@/discord/command/options";
+import { MAX_AUTOCOMPLETE_CHOICES } from "@/discord/command/autocomplete-limits";
+import type { CompiledSubcommand } from "@/discord/command/create-command";
+import type { Options } from "@/discord/command/options";
+import { routeKey } from "@/discord/command/route-key";
+import type { Choice } from "@/settings/choice";
 
 /**
  * Serving option autocomplete. Kept beside the DSL because resolving *which*
@@ -8,9 +11,6 @@ import type { Choice, Options } from "@/discord/command/options";
  * dispatcher only decides that an interaction is an autocomplete request.
  */
 
-/** Discord refuses more than this many suggestions in one response. */
-const MAX_CHOICES = 25;
-
 /**
  * Answer a focused option's autocomplete request.
  *
@@ -47,12 +47,13 @@ export async function respondWithSuggestions(
 }
 
 /**
- * Discord rejects the whole response when it carries more than 25 choices, so a
+ * Discord rejects the whole response when it carries more than
+ * {@link MAX_AUTOCOMPLETE_CHOICES} choices, so a
  * resolver returning more is trimmed rather than failing outright — a partial
  * list is still useful to the user typing.
  */
 function truncate(choices: readonly Choice[]): Choice[] {
-	return choices.slice(0, MAX_CHOICES);
+	return choices.slice(0, MAX_AUTOCOMPLETE_CHOICES);
 }
 
 /**

package/src/discord/command/command-responders.ts

@@ -0,0 +1,39 @@
+import type { CommandInteraction } from "discord.js";
+import { sendEmbed } from "@/discord/command/send-embed";
+import type { Presenter } from "@/discord/presenter";
+import type { Locale } from "@/i18n/locale";
+import type { TranslationParams, Translator } from "@/i18n/translator";
+import type { Logger } from "@/logger";
+
+/**
+ * What every command handler's context offers, whatever kind of command it
+ * serves: the reply language, a translate helper bound to it, and responders
+ * that route through the injected {@link Presenter}.
+ */
+export interface CommandResponders {
+	/** Reply language: user's client locale → guild locale → configured default. */
+	readonly locale: Locale;
+	/** Translate a catalog key for this interaction's locale. */
+	t(key: string, params?: TranslationParams): string;
+	confirm(message: string): Promise<void>;
+	error(message: string): Promise<void>;
+	deny(message: string): Promise<void>;
+}
+
+/** Bind the shared responders to one interaction, its locale and its visibility. */
+export function createCommandResponders(
+	interaction: CommandInteraction,
+	locale: Locale,
+	ephemeral: boolean,
+	deps: { readonly presenter: Presenter; readonly logger: Logger; readonly translator: Translator },
+): CommandResponders {
+	const { presenter, logger, translator } = deps;
+	return {
+		locale,
+		t: (key, params) => translator.translate(locale, key, params),
+		confirm: (message) =>
+			sendEmbed(interaction, presenter.confirmation(message, locale), ephemeral, logger),
+		error: (message) => sendEmbed(interaction, presenter.error(message, locale), ephemeral, logger),
+		deny: (message) => sendEmbed(interaction, presenter.denial(message, locale), ephemeral, logger),
+	};
+}

package/src/discord/command/context.ts

@@ -1,7 +1,14 @@
-import { type ChatInputCommandInteraction, type EmbedBuilder, MessageFlags } from "discord.js";
+import type { ChatInputCommandInteraction, EmbedBuilder } from "discord.js";
+import {
+	type CommandResponders,
+	createCommandResponders,
+} from "@/discord/command/command-responders";
 import type { Options, Values } from "@/discord/command/options";
+import { sendEmbed } from "@/discord/command/send-embed";
+import { interactionLocale } from "@/discord/interaction/interaction-locale";
 import type { Presenter } from "@/discord/presenter";
-import { type Locale, resolveLocale, type TranslationParams, type Translator } from "@/i18n";
+import type { Locale } from "@/i18n/locale";
+import type { Translator } from "@/i18n/translator";
 import type { Logger } from "@/logger";
 
 /**
@@ -10,55 +17,16 @@ import type { Logger } from "@/logger";
  * translate helper bound to it, and convenience responders that route through
  * the injected {@link Presenter}.
  */
-export interface Context<O extends Options> {
+export interface Context<O extends Options> extends CommandResponders {
 	readonly interaction: ChatInputCommandInteraction;
 	readonly options: Values<O>;
-	/** Reply language: user's client locale → guild locale → configured default. */
-	readonly locale: Locale;
-	/** Translate a catalog key for this interaction's locale. */
-	t(key: string, params?: TranslationParams): string;
 	reply(embed: EmbedBuilder): Promise<void>;
-	confirm(message: string): Promise<void>;
-	error(message: string): Promise<void>;
-	deny(message: string): Promise<void>;
 }
 
 /**
- * Deliver an embed regardless of the interaction's lifecycle state, and never
- * throw: a failed delivery (e.g. an expired/unknown interaction, code 10062)
- * must not escape a handler and reach the client's unhandled `error` event,
- * which would crash the process. Visibility on a deferred interaction is fixed
- * at deferReply time, so editReply carries no flags.
+ * @param locale - the reply language the pipeline already resolved (through
+ * the bot's `LocaleResolver`); omitted, the interaction's own locales are used.
  */
-export async function sendEmbed(
-	interaction: ChatInputCommandInteraction,
-	embed: EmbedBuilder,
-	ephemeral: boolean,
-	logger: Logger,
-): Promise<void> {
-	const flags = ephemeral ? MessageFlags.Ephemeral : undefined;
-	try {
-		if (interaction.deferred) {
-			await interaction.editReply({ embeds: [embed] });
-			return;
-		}
-		if (interaction.replied) {
-			await interaction.followUp({ embeds: [embed], flags });
-			return;
-		}
-		await interaction.reply({ embeds: [embed], flags });
-	} catch (error) {
-		logger.error(
-			{
-				commandName: interaction.commandName,
-				interactionId: interaction.id,
-				err: error instanceof Error ? error.message : String(error),
-			},
-			"Failed to deliver interaction response",
-		);
-	}
-}
-
 export function createContext<O extends Options>(
 	interaction: ChatInputCommandInteraction,
 	options: Values<O>,
@@ -66,20 +34,12 @@ export function createContext<O extends Options>(
 	presenter: Presenter,
 	logger: Logger,
 	translator: Translator,
+	locale: Locale = interactionLocale(interaction, translator),
 ): Context<O> {
-	const locale = resolveLocale(
-		[interaction.locale, interaction.guildLocale],
-		translator.defaultLocale,
-	);
 	return {
+		...createCommandResponders(interaction, locale, ephemeral, { presenter, logger, translator }),
 		interaction,
 		options,
-		locale,
-		t: (key, params) => translator.translate(locale, key, params),
 		reply: (embed) => sendEmbed(interaction, embed, ephemeral, logger),
-		confirm: (message) =>
-			sendEmbed(interaction, presenter.confirmation(message, locale), ephemeral, logger),
-		error: (message) => sendEmbed(interaction, presenter.error(message, locale), ephemeral, logger),
-		deny: (message) => sendEmbed(interaction, presenter.denial(message, locale), ephemeral, logger),
 	};
 }

package/src/discord/command/cooldown-guard.ts

@@ -2,7 +2,7 @@ import type { CommandInteraction } from "discord.js";
 import { type Clock, systemClock } from "@/clock";
 import type { Guard, GuardResult } from "@/discord/command/guard";
 import { CORE_MESSAGES } from "@/discord/i18n";
-import type { LocalizedText } from "@/i18n";
+import type { LocalizedText } from "@/i18n/translator";
 
 const ALLOW: GuardResult = { ok: true };
 const MILLISECONDS_PER_SECOND = 1000;

package/src/discord/command/create-command.ts

@@ -7,14 +7,17 @@ import {
 	type SlashCommandSubcommandBuilder,
 } from "discord.js";
 import { resolveRouteOptions, respondWithSuggestions } from "@/discord/command/autocomplete";
-import { type Context, createContext, sendEmbed } from "@/discord/command/context";
+import { type Context, createContext } from "@/discord/command/context";
 import type { Guard } from "@/discord/command/guard";
 import type { Options, Values } from "@/discord/command/options";
+import { passesGuard } from "@/discord/command/passes-guard";
+import { renderCommandFailure } from "@/discord/command/render-command-failure";
+import { routeKey } from "@/discord/command/route-key";
 import type { CommandRuntime, SlashCommand } from "@/discord/command/types";
 import { CORE_MESSAGES } from "@/discord/i18n";
+import { replyLocale } from "@/discord/interaction/reply-locale";
 import { type PermissionBit, resolvePermissions } from "@/discord/permissions";
-import { BusinessError, createIncidentRef } from "@/errors";
-import { type Locale, type LocalizedText, resolveLocale } from "@/i18n";
+import type { LocalizedText } from "@/i18n/translator";
 
 export interface SubcommandDef<O extends Options> {
 	description: string;
@@ -117,27 +120,6 @@ interface SubcommandContainer {
 	): unknown;
 }
 
-/** Resolve the reply locale for an interaction handled outside `createContext`. */
-function interactionLocale(
-	interaction: ChatInputCommandInteraction,
-	runtime: CommandRuntime,
-): Locale {
-	return resolveLocale(
-		[interaction.locale, interaction.guildLocale],
-		runtime.translator.defaultLocale,
-	);
-}
-
-/**
- * The key a subcommand is stored and looked up under. Exported because dispatch
- * and autocomplete must agree on it: if they ever built it differently, an
- * autocomplete inside a group would silently resolve to no options instead of
- * failing loudly.
- */
-export function routeKey(group: string | null, name: string): string {
-	return group ? `${group}/${name}` : name;
-}
-
 /**
  * The root-level settings, split out of {@link CommandDef} so applying them does
  * not drag the option generic `O` along (a `CommandDef<O>` is not assignable to
@@ -211,29 +193,6 @@ function ephemeralReplyOptions(ephemeral: boolean): { flags?: MessageFlags.Ephem
 	return {};
 }
 
-/** Run a guard if present; reply with a denial and return `false` when it fails. */
-async function passesGuard(
-	interaction: ChatInputCommandInteraction,
-	guard: Guard | undefined,
-	runtime: CommandRuntime,
-): Promise<boolean> {
-	if (!guard) {
-		return true;
-	}
-	const result = await guard.check(interaction);
-	if (!result.ok) {
-		const locale = interactionLocale(interaction, runtime);
-		await interaction.reply({
-			embeds: [
-				runtime.presenter.denial(runtime.translator.resolve(locale, result.message), locale),
-			],
-			flags: MessageFlags.Ephemeral,
-		});
-		return false;
-	}
-	return true;
-}
-
 /** Read options, optionally defer, build the context and invoke the handler. */
 async function executeRoute(
 	interaction: ChatInputCommandInteraction,
@@ -254,10 +213,21 @@ async function executeRoute(
 			presenter,
 			logger,
 			translator,
+			await replyLocale(interaction, runtime),
 		);
 		await route.invoke(ctx);
 	} catch (error) {
-		await renderError(interaction, route, label, error, runtime);
+		await renderCommandFailure(
+			interaction,
+			{
+				error,
+				ephemeral: route.ephemeral,
+				fallbackError: route.fallbackError,
+				logFields: { subcommand: label },
+				logMessage: "Command handler failed",
+			},
+			runtime,
+		);
 	}
 }
 
@@ -284,7 +254,7 @@ async function dispatchGrouped(
 	const route = routes.get(label);
 
 	if (!route) {
-		const locale = interactionLocale(interaction, runtime);
+		const locale = await replyLocale(interaction, runtime);
 		await interaction.reply({
 			embeds: [
 				runtime.presenter.error(
@@ -303,51 +273,6 @@ async function dispatchGrouped(
 	await executeRoute(interaction, route, label, runtime);
 }
 
-async function renderError(
-	interaction: ChatInputCommandInteraction,
-	route: CompiledSubcommand,
-	label: string,
-	error: unknown,
-	runtime: CommandRuntime,
-): Promise<void> {
-	const { presenter, logger, translator } = runtime;
-	const locale = interactionLocale(interaction, runtime);
-	if (error instanceof BusinessError) {
-		const text = error.translation
-			? translator.translate(locale, error.translation.key, error.translation.params)
-			: error.message;
-		const embed =
-			error.severity === "warning"
-				? presenter.warning(text, locale)
-				: presenter.error(text, locale);
-		await sendEmbed(interaction, embed, route.ephemeral, logger);
-		return;
-	}
-
-	const ref = createIncidentRef();
-	logger.error(
-		{
-			command: interaction.commandName,
-			subcommand: label,
-			userId: interaction.user.id,
-			ref,
-			err: error instanceof Error ? error.message : String(error),
-			stack: error instanceof Error ? error.stack : undefined,
-		},
-		"Command handler failed",
-	);
-	await sendEmbed(
-		interaction,
-		presenter.systemError(
-			translator.resolve(locale, route.fallbackError ?? { key: CORE_MESSAGES.genericError }),
-			ref,
-			locale,
-		),
-		route.ephemeral,
-		logger,
-	);
-}
-
 /**
  * Build a {@link SlashCommand} from a declarative definition: it produces the
  * discord.js builder *and* the routing/guard/error pipeline. The runtime

package/src/discord/command/create-context-menu-command.ts

@@ -2,21 +2,24 @@ import {
 	ApplicationCommandType,
 	ContextMenuCommandBuilder,
 	type ContextMenuCommandInteraction,
-	type EmbedBuilder,
 	InteractionContextType,
 	type LocalizationMap,
 	type Message,
 	MessageFlags,
 	type User,
 } from "discord.js";
+import {
+	type CommandResponders,
+	createCommandResponders,
+} from "@/discord/command/command-responders";
 import { ContextMenuTargetError } from "@/discord/command/errors";
 import type { Guard } from "@/discord/command/guard";
+import { passesGuard } from "@/discord/command/passes-guard";
+import { renderCommandFailure } from "@/discord/command/render-command-failure";
 import type { CommandRuntime, ContextMenuCommand } from "@/discord/command/types";
-import { CORE_MESSAGES } from "@/discord/i18n";
+import { replyLocale } from "@/discord/interaction/reply-locale";
 import { type PermissionBit, resolvePermissions } from "@/discord/permissions";
-import { BusinessError, createIncidentRef } from "@/errors";
-import { type Locale, type LocalizedText, resolveLocale, type TranslationParams } from "@/i18n";
-import type { Logger } from "@/logger";
+import type { LocalizedText } from "@/i18n/translator";
 
 /**
  * Context-menu commands: the entries a user reaches by right-clicking a member
@@ -35,17 +38,10 @@ export interface ContextMenuTarget {
 	readonly message: Message;
 }
 
-export interface ContextMenuContext<K extends keyof ContextMenuTarget> {
+export interface ContextMenuContext<K extends keyof ContextMenuTarget> extends CommandResponders {
 	readonly interaction: ContextMenuCommandInteraction;
 	/** The right-clicked member or message. */
 	readonly target: ContextMenuTarget[K];
-	/** Reply language: user's client locale → guild locale → configured default. */
-	readonly locale: Locale;
-	/** Translate a catalog key for this interaction's locale. */
-	t(key: string, params?: TranslationParams): string;
-	confirm(message: string): Promise<void>;
-	error(message: string): Promise<void>;
-	deny(message: string): Promise<void>;
 }
 
 export interface ContextMenuCommandDef<K extends keyof ContextMenuTarget> {
@@ -124,104 +120,30 @@ async function dispatch<K extends keyof ContextMenuTarget>(
 	ephemeral: boolean,
 	runtime: CommandRuntime,
 ): Promise<void> {
-	const { presenter, logger, translator } = runtime;
-	const locale = resolveLocale(
-		[interaction.locale, interaction.guildLocale],
-		translator.defaultLocale,
-	);
-
-	if (def.guard) {
-		const result = await def.guard.check(interaction);
-		if (!result.ok) {
-			await interaction.reply({
-				embeds: [presenter.denial(translator.resolve(locale, result.message), locale)],
-				flags: MessageFlags.Ephemeral,
-			});
-			return;
-		}
+	if (!(await passesGuard(interaction, def.guard, runtime))) {
+		return;
 	}
+	const locale = await replyLocale(interaction, runtime);
 
 	try {
 		if (def.defer) {
 			await interaction.deferReply(ephemeral ? { flags: MessageFlags.Ephemeral } : {});
 		}
 		await def.handler({
+			...createCommandResponders(interaction, locale, ephemeral, runtime),
 			interaction,
 			target: resolveTarget(interaction, def.target),
-			locale,
-			t: (key, params) => translator.translate(locale, key, params),
-			confirm: (message) =>
-				send(interaction, presenter.confirmation(message, locale), ephemeral, logger),
-			error: (message) => send(interaction, presenter.error(message, locale), ephemeral, logger),
-			deny: (message) => send(interaction, presenter.denial(message, locale), ephemeral, logger),
 		});
 	} catch (error) {
-		if (error instanceof BusinessError) {
-			const text = error.translation
-				? translator.translate(locale, error.translation.key, error.translation.params)
-				: error.message;
-			const embed =
-				error.severity === "warning"
-					? presenter.warning(text, locale)
-					: presenter.error(text, locale);
-			await send(interaction, embed, ephemeral, logger);
-			return;
-		}
-		const ref = createIncidentRef();
-		logger.error(
-			{
-				command: interaction.commandName,
-				userId: interaction.user.id,
-				ref,
-				err: error instanceof Error ? error.message : String(error),
-				stack: error instanceof Error ? error.stack : undefined,
-			},
-			"Context menu handler failed",
-		);
-		await send(
+		await renderCommandFailure(
 			interaction,
-			presenter.systemError(
-				translator.resolve(locale, def.fallbackError ?? { key: CORE_MESSAGES.genericError }),
-				ref,
-				locale,
-			),
-			ephemeral,
-			logger,
-		);
-	}
-}
-
-/**
- * Deliver an embed whatever the interaction's lifecycle state, and never throw:
- * a failed delivery (e.g. an expired interaction) must not escape into the
- * client's unhandled `error` event. Mirrors the command pipeline's `sendEmbed`,
- * which is typed for chat-input interactions only.
- */
-async function send(
-	interaction: ContextMenuCommandInteraction,
-	embed: EmbedBuilder,
-	ephemeral: boolean,
-	logger: Logger,
-): Promise<void> {
-	const flags = ephemeral ? MessageFlags.Ephemeral : undefined;
-	try {
-		if (interaction.deferred) {
-			await interaction.editReply({ embeds: [embed] });
-			return;
-		}
-		if (interaction.replied) {
-			await interaction.followUp({ embeds: [embed], flags });
-			return;
-		}
-		await interaction.reply({ embeds: [embed], flags });
-	} catch (error) {
-		logger.error(
 			{
-				commandName: interaction.commandName,
-				interactionId: interaction.id,
-				err: error instanceof Error ? error.message : String(error),
+				error,
+				ephemeral,
+				fallbackError: def.fallbackError,
+				logMessage: "Context menu handler failed",
 			},
-			"Failed to deliver interaction response",
+			runtime,
 		);
 	}
 }

package/src/discord/command/errors.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from "@/errors";
+import { ValidationError } from "@/errors/business-error";
 
 /**
  * Raised when a slash command option is declared or read in a way discord.js