@azurioh/discord-kernel 0.1.0 → 1.0.0

package/src/discord/settings/guild-locale-resolver.ts

@@ -0,0 +1,38 @@
+import type { LocaleResolver } from "@/discord/interaction/locale-resolver";
+import { normalizeLocale, resolveLocale } from "@/i18n/locale";
+import type { Translator } from "@/i18n/translator";
+import type { SettingsRegistry } from "@/settings/registry";
+import type { SettingsService } from "@/settings/settings-service";
+
+/**
+ * The default {@link LocaleResolver} of a bot with settings (FR-038): the
+ * member's locale if supported, then the guild's language setting
+ * (`registry.kernel`, read through the service's cache), then the guild's
+ * Discord locale if supported, then the translator's default.
+ *
+ * The setting is read only when the member's locale is not supported, and
+ * never outside a guild. A failed read rejects: the kernel's
+ * reply paths log it and fall back to the interaction's own locales.
+ *
+ * @param deps.service - reads the guild's kernel settings.
+ * @param deps.registry - holds the kernel declaration.
+ * @param deps.translator - gives the bot's default language.
+ * @returns the resolver to hand to the command and component routers.
+ */
+export function createGuildLocaleResolver(deps: {
+	service: SettingsService;
+	registry: SettingsRegistry;
+	translator: Translator;
+}): LocaleResolver {
+	const { service, registry, translator } = deps;
+	return {
+		async resolve({ locale, guildLocale, guildId }) {
+			const member = normalizeLocale(locale);
+			if (member !== undefined || !guildId) {
+				return resolveLocale([member, guildLocale], translator.defaultLocale);
+			}
+			const setting = (await service.get(registry.kernel, guildId)).locale;
+			return resolveLocale([setting, guildLocale], translator.defaultLocale);
+		},
+	};
+}

package/src/discord/settings/is-module-disabled.ts

@@ -0,0 +1,22 @@
+import type { ModuleGate } from "@/settings/system/module-gate";
+
+/**
+ * Whether a router must skip a handler because its module is disabled on the
+ * guild it runs for. Nothing is gated without a gate, for a handler registered
+ * without a module, or outside a guild (FR-036).
+ *
+ * @param params.gate - the bot's module gate, if the router was given one.
+ * @param params.moduleName - the module that registered the handler.
+ * @param params.guildId - the guild the handler would run for, `null` outside one.
+ */
+export async function isModuleDisabled(params: {
+	gate: ModuleGate | undefined;
+	moduleName: string | undefined;
+	guildId: string | null | undefined;
+}): Promise<boolean> {
+	const { gate, moduleName, guildId } = params;
+	if (gate === undefined || moduleName === undefined || !guildId) {
+		return false;
+	}
+	return !(await gate.isEnabled(moduleName, guildId));
+}

package/src/discord/settings/module-disabled-embed.ts

@@ -0,0 +1,19 @@
+import type { EmbedBuilder } from "discord.js";
+import type { LocaleSubject } from "@/discord/interaction/locale-resolver";
+import { type ReplyLocaleDeps, replyLocale } from "@/discord/interaction/reply-locale";
+import type { Presenter } from "@/discord/presenter";
+import { SETTINGS_MESSAGES } from "@/settings/messages";
+
+/**
+ * The answer to an interaction with a module disabled on its guild: the
+ * translated "disabled on this server" message, as a denial in the reply
+ * language the router's `LocaleResolver` gives (or the interaction's own).
+ */
+export async function moduleDisabledEmbed(
+	interaction: LocaleSubject,
+	deps: ReplyLocaleDeps & { readonly presenter: Presenter },
+): Promise<EmbedBuilder> {
+	const locale = await replyLocale(interaction, deps);
+	const message = deps.translator.translate(locale, SETTINGS_MESSAGES.moduleDisabled);
+	return deps.presenter.denial(message, locale);
+}

package/src/discord/settings/require-configured.ts

@@ -0,0 +1,68 @@
+import { type BaseInteraction, PermissionFlagsBits } from "discord.js";
+import type { Guard, GuardResult } from "@/discord/command/guard";
+import { CORE_MESSAGES } from "@/discord/i18n";
+import { replyLocale } from "@/discord/interaction/reply-locale";
+import type { SettingsDeclaration } from "@/settings/define-settings";
+import { SETTINGS_MESSAGES } from "@/settings/messages";
+import type { SettingsService } from "@/settings/settings-service";
+
+const ALLOW: GuardResult = { ok: true };
+
+const NOT_CONFIGURED: GuardResult = {
+	ok: false,
+	message: { key: SETTINGS_MESSAGES.moduleNotConfigured },
+};
+
+/**
+ * Block a command or a component until its module is configured on the guild
+ * (FR-041): until `service.status` lists no missing field, the member gets the
+ * translated "not configured" message instead of the handler.
+ *
+ * - Members allowed to configure the bot (the `ManageGuild` permission, until
+ *   the permissions feature exists) also read which settings are missing, by
+ *   their translated labels, in the reply language (the pipeline's
+ *   `LocaleResolver`). Other members never see them.
+ * - The status is read through the service's cache, which every write
+ *   invalidates: the guard passes as soon as the value is set, no restart.
+ * - Outside a guild there is nothing to configure for: denied like
+ *   `guildOnlyGuard`, without reading any setting.
+ *
+ * Typed over `BaseInteraction`, so the same guard is a command's `guard` and a
+ * component handler's `guard`.
+ *
+ * @param declaration - the module's settings declaration.
+ * @param service - reads the guild's configuration status.
+ */
+export function requireConfigured(
+	declaration: SettingsDeclaration,
+	service: SettingsService,
+): Guard<BaseInteraction> {
+	return {
+		async check(interaction, runtime) {
+			if (!interaction.guildId) {
+				return { ok: false, message: { key: CORE_MESSAGES.guardGuildOnly } };
+			}
+			const { missing } = await service.status(declaration, interaction.guildId);
+			if (missing.length === 0) {
+				return ALLOW;
+			}
+			const canConfigure =
+				interaction.memberPermissions?.has(PermissionFlagsBits.ManageGuild) ?? false;
+			if (!canConfigure || runtime === undefined) {
+				return NOT_CONFIGURED;
+			}
+			const { translator } = runtime;
+			const locale = await replyLocale(interaction, runtime);
+			const fields = missing
+				.map((key) => translator.translate(locale, declaration.fields[key]?.label ?? key))
+				.join(", ");
+			return {
+				ok: false,
+				message: [
+					translator.translate(locale, SETTINGS_MESSAGES.moduleNotConfigured),
+					translator.translate(locale, SETTINGS_MESSAGES.moduleNotConfiguredMissing, { fields }),
+				].join(" "),
+			};
+		},
+	};
+}

package/src/discord/ui/color-aliases.ts

@@ -0,0 +1,70 @@
+import { BASE_COLOR_NAMES, indexColorNames, normalizeColorName } from "@/color";
+import { ColorAliasTooLongError } from "@/discord/ui/color-input-errors";
+
+/**
+ * The names the kernel ships: the vendor-neutral base colours, `blurple` included.
+ *
+ * A bot adds its own — the colour it calls by its brand's name — through
+ * {@link registerColorAliases}, which is also why this table is not the one
+ * lookups read: {@link COLOR_ALIASES} is.
+ */
+const BUILT_IN_COLOR_ALIASES: Readonly<Record<string, string>> = {
+	...BASE_COLOR_NAMES,
+};
+
+/**
+ * Every name a lookup answers to: the kernel's own, plus whatever the bot
+ * registered. Exposed for inspection — a screen listing the colours it accepts
+ * reads this — never for mutation, which goes through
+ * {@link registerColorAliases} so the length check cannot be skipped.
+ */
+export const COLOR_ALIASES: Readonly<Record<string, string>> = {
+	...BUILT_IN_COLOR_ALIASES,
+};
+
+const COLORS_BY_NORMALIZED_NAME = indexColorNames(COLOR_ALIASES);
+
+/** The `#rrggbb` a recognised colour name stands for, `null` for anything else. */
+export function resolveNamedColor(raw: string): string | null {
+	return COLORS_BY_NORMALIZED_NAME.get(normalizeColorName(raw)) ?? null;
+}
+
+/** `#RRGGBB` — the longest hexadecimal form the parser accepts. */
+const HEX_INPUT_LENGTH = 7;
+
+/**
+ * What a colour input field may hold.
+ *
+ * Derived from the built-in table rather than written down, so adding a longer
+ * name here cannot leave the field silently truncating it at the client — and
+ * fixed rather than recomputed on registration, because field definitions read
+ * it once at module load, long before a bot registers anything.
+ */
+export const MAX_COLOR_INPUT_LENGTH = Math.max(
+	HEX_INPUT_LENGTH,
+	...Object.keys(BUILT_IN_COLOR_ALIASES).map((name) => name.length),
+);
+
+/**
+ * Teach the parser the colours this bot calls by name — its brand gold, its
+ * team colours — from the composition root, before any module is constructed.
+ *
+ * A name over {@link MAX_COLOR_INPUT_LENGTH} is refused rather than accepted:
+ * the input field is already sized, so registering a longer name would let an
+ * administrator type a colour the client cuts short, which then reads as the
+ * parser rejecting a name it actually knows.
+ *
+ * @throws ColorAliasTooLongError when a name cannot fit the input field.
+ */
+export function registerColorAliases(aliases: Readonly<Record<string, string>>): void {
+	for (const [name, hex] of Object.entries(aliases)) {
+		if (name.length > MAX_COLOR_INPUT_LENGTH) {
+			throw new ColorAliasTooLongError(name, MAX_COLOR_INPUT_LENGTH);
+		}
+		// Both views are written: the table is what a screen lists, the map is what
+		// a lookup reads, and a name present in one but not the other would be a
+		// colour the bot advertises and refuses.
+		(COLOR_ALIASES as Record<string, string>)[name] = hex;
+		COLORS_BY_NORMALIZED_NAME.set(normalizeColorName(name), hex);
+	}
+}

package/src/discord/ui/color-input.ts

@@ -1,179 +1,14 @@
-import { ColorAliasTooLongError } from "@/discord/ui/color-input-errors";
-import { DISCORD_BLURPLE } from "@/discord/ui/colors";
-
-/**
- * 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";
-
-/**
- * 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.
- *
- * These are the names the kernel ships. A bot adds its own — the colour it
- * calls by its brand's name — through {@link registerColorAliases}, which is
- * also why this table is not the one lookups read: {@link COLOR_ALIASES} is.
- */
-const BUILT_IN_COLOR_ALIASES: 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 this file happened to spell.
- * Case and surrounding whitespace are folded for the same reason.
- */
-function normalizeColorName(raw: string): string {
-	return raw
-		.trim()
-		.toLowerCase()
-		.normalize("NFD")
-		.replace(/\p{Diacritic}/gu, "");
-}
-
-/**
- * Every name a lookup answers to: the kernel's own, plus whatever the bot
- * registered. Exposed for inspection — a screen listing the colours it accepts
- * reads this — never for mutation, which goes through
- * {@link registerColorAliases} so the length check cannot be skipped.
- */
-export const COLOR_ALIASES: Readonly<Record<string, string>> = {
-	...BUILT_IN_COLOR_ALIASES,
-};
-
-const COLORS_BY_NORMALIZED_NAME = new Map(
-	Object.entries(COLOR_ALIASES).map(([name, hex]) => [normalizeColorName(name), hex]),
-);
-
-/** The `#rrggbb` a recognised colour name stands for, `null` for anything else. */
-function resolveNamedColor(raw: string): string | null {
-	return COLORS_BY_NORMALIZED_NAME.get(normalizeColorName(raw)) ?? null;
-}
-
-/** `#RRGGBB` — the longest hexadecimal form the parser accepts. */
-const HEX_INPUT_LENGTH = 7;
-
-/**
- * What a colour input field may hold.
- *
- * Derived from the built-in table rather than written down, so adding a longer
- * name here cannot leave the field silently truncating it at the client — and
- * fixed rather than recomputed on registration, because field definitions read
- * it once at module load, long before a bot registers anything.
- */
-export const MAX_COLOR_INPUT_LENGTH = Math.max(
-	HEX_INPUT_LENGTH,
-	...Object.keys(BUILT_IN_COLOR_ALIASES).map((name) => name.length),
-);
-
-/**
- * Teach the parser the colours this bot calls by name — its brand gold, its
- * team colours — from the composition root, before any module is constructed.
- *
- * A name over {@link MAX_COLOR_INPUT_LENGTH} is refused rather than accepted:
- * the input field is already sized, so registering a longer name would let an
- * administrator type a colour the client cuts short, which then reads as the
- * parser rejecting a name it actually knows.
- *
- * @throws ColorAliasTooLongError when a name cannot fit the input field.
- */
-export function registerColorAliases(aliases: Readonly<Record<string, string>>): void {
-	for (const [name, hex] of Object.entries(aliases)) {
-		if (name.length > MAX_COLOR_INPUT_LENGTH) {
-			throw new ColorAliasTooLongError(name, MAX_COLOR_INPUT_LENGTH);
-		}
-		// Both views are written: the table is what a screen lists, the map is what
-		// a lookup reads, and a name present in one but not the other would be a
-		// colour the bot advertises and refuses.
-		(COLOR_ALIASES as Record<string, string>)[name] = hex;
-		COLORS_BY_NORMALIZED_NAME.set(normalizeColorName(name), hex);
-	}
-}
-
-/** Discord accepts `#RGB` and `#RRGGBB`, with or without the leading hash. */
-const HEX_COLOR_PATTERN = /^#?(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+import { parseHexColor } from "@/color";
+import { resolveNamedColor } from "@/discord/ui/color-aliases";
 
 /**
  * Normalize a colour input to `#RRGGBB`, from a hexadecimal code or from one of
- * the names in {@link COLOR_ALIASES} — an administrator picking a colour should
- * not have to look a hex code up. `null` for anything that is neither: the
- * refusal an administrator reads belongs to whichever screen asked, so core
- * reports that it could not read the value and leaves the wording to the caller.
+ * the names in {@link import("@/discord/ui/color-aliases").COLOR_ALIASES} — an
+ * administrator picking a colour should not have to look a hex code up. `null`
+ * for anything that is neither: the refusal an administrator reads belongs to
+ * whichever screen asked, so core reports that it could not read the value and
+ * leaves the wording to the caller.
  */
 export function parseColorInput(raw: string): string | null {
-	const value = raw.trim();
-	const named = resolveNamedColor(value);
-	if (named !== null) {
-		return named;
-	}
-	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}`;
+	return resolveNamedColor(raw) ?? parseHexColor(raw);
 }

package/src/discord/ui/colors.ts

@@ -1,3 +1,5 @@
+import { DISCORD_BLURPLE } from "@/color";
+
 /**
  * The five roles an embed colour can play. A bot restyles by supplying its own
  * values for these, never by adding a sixth: a role the kernel does not know is
@@ -18,9 +20,6 @@ export function toDiscordColor(hex: string): number {
 	return Number.parseInt(hex.slice(1), 16);
 }
 
-/** Discord's own brand colour, the fallback for a bot that declares no palette. */
-export const DISCORD_BLURPLE = "#5865f2";
-
 /**
  * What every embed renders as until the composition root says otherwise. Kept
  * deliberately unbranded: a kernel that shipped one bot's colours would make

package/src/discord/ui/embed.ts

@@ -1,4 +1,5 @@
 import { EmbedBuilder } from "discord.js";
+import { truncateText } from "@/discord/ui/truncate-text";
 
 /** Discord hard limit on the number of fields per embed. */
 const MAX_EMBED_FIELDS = 25;
@@ -35,8 +36,8 @@ export function appendBoundedFields(
 		if (shown >= MAX_EMBED_FIELDS) {
 			break;
 		}
-		const name = truncate(field.name, MAX_FIELD_NAME);
-		const value = truncate(field.value, MAX_FIELD_VALUE);
+		const name = truncateText(field.name, MAX_FIELD_NAME);
+		const value = truncateText(field.value, MAX_FIELD_VALUE);
 		if (usedChars + name.length + value.length > MAX_EMBED_TOTAL - EMBED_TOTAL_SAFETY_MARGIN) {
 			break;
 		}
@@ -51,13 +52,6 @@ export function appendBoundedFields(
 	}
 }
 
-function truncate(text: string, max: number): string {
-	if (text.length <= max) {
-		return text;
-	}
-	return `${text.slice(0, max - 1)}…`;
-}
-
 /** Build a plain titled embed. */
 export function buildEmbed(title: string, description: string): EmbedBuilder {
 	return new EmbedBuilder().setTitle(title).setDescription(description);

package/src/discord/ui/truncate-text.ts

@@ -0,0 +1,15 @@
+/**
+ * `text` cut to at most `max` characters, its last one an ellipsis when it
+ * had to be cut: Discord rejects a whole message over one text that is too
+ * long, so a value of unknown length is shortened rather than sent as is.
+ *
+ * @param text - the text to fit.
+ * @param max - the most characters the result may hold.
+ * @returns `text` itself when it fits, its shortened form otherwise.
+ */
+export function truncateText(text: string, max: number): string {
+	if (text.length <= max) {
+		return text;
+	}
+	return `${text.slice(0, max - 1)}…`;
+}

package/src/errors/error-message.ts

@@ -0,0 +1,10 @@
+/**
+ * The message of an unknown thrown value, for a log field that only needs the
+ * one line: an `Error`'s own message, anything else as its string form.
+ *
+ * {@link import("@/errors/describe-error").describeError} is the fuller record
+ * — name, stack and nested causes — for failures worth investigating.
+ */
+export function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/i18n/business-message.ts

@@ -1,4 +1,4 @@
-import type { BusinessError } from "@/errors";
+import type { BusinessError } from "@/errors/business-error";
 import type { Locale } from "@/i18n/locale";
 import type { Translator } from "@/i18n/translator";
 

package/src/i18n/catalog.ts

@@ -18,6 +18,15 @@ export interface CatalogEntry {
  */
 export type Catalog = Readonly<Record<string, CatalogEntry>>;
 
+/** The catalog keys a `*_MESSAGES` constant holds. */
+export type MessageKey<M extends Readonly<Record<string, string>>> = M[keyof M];
+
+/**
+ * A catalog with exactly one entry per key: a key without its entry, or an
+ * entry under a key no `*_MESSAGES` constant declares, fails to compile.
+ */
+export type KeyedCatalog<K extends string> = Readonly<Record<K, CatalogEntry>>;
+
 /**
  * Accumulates the core catalog and every module's catalog at boot. Registration
  * is fail-fast: a duplicate key throws {@link DuplicateTranslationKeyError}
@@ -35,6 +44,11 @@ export class TranslationRegistry {
 		}
 	}
 
+	/** Whether `key` was registered by some catalog (and so has an English source). */
+	has(key: string): boolean {
+		return this.entries.has(key);
+	}
+
 	get(key: string): CatalogEntry | undefined {
 		return this.entries.get(key);
 	}

package/src/i18n/locale.ts

@@ -7,6 +7,9 @@ export const SUPPORTED_LOCALES = ["en", "fr"] as const;
 
 export type Locale = (typeof SUPPORTED_LOCALES)[number];
 
+/** The language every catalog entry provides (`CatalogEntry.en`): the last fallback of any lookup. */
+export const SOURCE_LOCALE: Locale = "en";
+
 /**
  * Map a raw Discord locale string (`en-US`, `en-GB`, `fr`, `de`…) to a
  * supported base language. Regional variants collapse to their base tag, so

package/src/i18n/translator.ts

@@ -22,6 +22,9 @@ export interface Translator {
 	resolve(locale: Locale, text: LocalizedText): string;
 }
 
+/** Translates one catalog key into a locale already chosen by the caller. */
+export type TranslateKey = (key: string) => string;
+
 export interface TranslatorOptions {
 	readonly defaultLocale: Locale;
 	readonly logger: Logger;

package/src/module/module.ts

@@ -1,8 +1,9 @@
 import type { ContextMenuCommand, SlashCommand } from "@/discord/command/types";
 import type { ComponentHandler } from "@/discord/components/component-router";
 import type { DiscordEvent } from "@/discord/events/types";
-import type { Catalog } from "@/i18n";
+import type { Catalog } from "@/i18n/catalog";
 import type { ScheduledJob } from "@/scheduler/scheduler";
+import type { SettingsDeclaration } from "@/settings/define-settings";
 
 /**
  * A self-contained vertical feature slice. A module bundles everything it
@@ -17,6 +18,12 @@ import type { ScheduledJob } from "@/scheduler/scheduler";
 export interface BotModule {
 	/** Stable identifier, used in logs. */
 	readonly name: string;
+	/**
+	 * Catalog key of the module's name as administrators read it (for example on
+	 * its enable/disable toggle). Without one, screens show {@link name} as is and
+	 * the translator logs it as an unknown key.
+	 */
+	readonly label?: string;
 	readonly commands?: readonly SlashCommand[];
 	/** Right-click entries on a member or a message (the Apps submenu). */
 	readonly contextMenuCommands?: readonly ContextMenuCommand[];
@@ -30,6 +37,13 @@ export interface BotModule {
 	 * duplicate key across modules fails the boot, never a runtime lookup.
 	 */
 	readonly translations?: Catalog;
+	/**
+	 * The module's settings declarations. The composition root collects them into
+	 * the settings registry at boot, the same way it collects `translations`.
+	 */
+	readonly settings?: readonly SettingsDeclaration[];
+	/** Whether the module starts enabled in a guild that never toggled it. Defaults to `true`. */
+	readonly defaultEnabled?: boolean;
 	/** One-off initialisation run once at boot, after the client is ready. */
 	setup?(): Promise<void> | void;
 	/**

package/src/resilience/retry.ts

@@ -1,4 +1,4 @@
-import { BusinessError } from "@/errors";
+import { BusinessError } from "@/errors/business-error";
 
 const MIN_ATTEMPTS = 1;
 const DEFAULT_ATTEMPTS = 3;

package/src/scheduler/scheduler.ts

@@ -1,4 +1,5 @@
 import cron from "node-cron";
+import { errorMessage } from "@/errors/error-message";
 import type { Logger } from "@/logger";
 import {
 	AmbiguousJobScheduleError,
@@ -64,10 +65,6 @@ export interface Scheduler {
 	stop(): void;
 }
 
-function describeError(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
 /**
  * A job as it actually arrives at runtime. The exported union already forbids
  * the invalid combinations, which is exactly why the check below cannot be
@@ -233,7 +230,7 @@ export class CronScheduler implements Scheduler {
 		try {
 			await job.run();
 		} catch (error) {
-			this.logger.error({ job: job.name, err: describeError(error) }, "Scheduled job failed");
+			this.logger.error({ job: job.name, err: errorMessage(error) }, "Scheduled job failed");
 		}
 	}