meocord 4.2.2 → 4.2.3

package/dist/esm/util/timer-limit.util.js

@@ -1,4 +1,7 @@
 /** The longest delay a timer keeps: 2^31 - 1 ms, about 24.8 days. Node fires a longer one at once. */ const MAX_TIMER_MS = 2147483647;
+const MS_PER_SECOND = 1000;
+/** The most whole seconds a timer keeps, as a message about an option given in seconds names the limit. */ const MAX_TIMER_SECONDS = Math.floor(MAX_TIMER_MS / MS_PER_SECOND);
+/** Whether a timer keeps a delay given in seconds, a fraction of a second included. */ const timerKeepsSeconds = (seconds)=>seconds * MS_PER_SECOND <= MAX_TIMER_MS;
 /** A value as a refusal quotes it: a number as itself, `Infinity` and `NaN` included, a string in quotes. */ function quoted(value) {
     if (typeof value === 'string') return JSON.stringify(value);
     if (typeof value === 'number' || typeof value === 'boolean' || value === null) return String(value);
@@ -12,4 +15,4 @@
     return `must be a number of milliseconds ${allowZero ? '0 or more' : 'above 0'}, at most ${max} (got ${quoted(value)})`;
 }
 
-export { MAX_TIMER_MS, timeoutProblem };
+export { MAX_TIMER_MS, MAX_TIMER_SECONDS, timeoutProblem, timerKeepsSeconds };

package/dist/esm/util/tsconfig-paths.util.js

@@ -11,13 +11,15 @@ const STAR = '__meocord_paths_star__';
  */ function projectPaths(cwd = process.cwd()) {
     const configPath = path.join(cwd, 'tsconfig.json');
     if (!existsSync(configPath)) return undefined;
-    const tsconfig = {
-        path: configPath,
-        config: parseTsconfig(configPath)
-    };
-    const paths = tsconfig.config.compilerOptions?.paths;
+    return absolutePaths(configPath, parseTsconfig(configPath));
+}
+/** A parsed tsconfig's `paths`, each target absolute, as {@link projectPaths} gives them. */ function absolutePaths(configPath, config) {
+    const paths = config.compilerOptions?.paths;
     // The matcher resolves each target from the file that declares it, or from baseUrl, as tsc does
-    const match = createPathsMatcher(tsconfig);
+    const match = createPathsMatcher({
+        path: configPath,
+        config
+    });
     if (!paths || !match) return undefined;
     // Resolved, so each is the platform's own absolute path: get-tsconfig writes Windows paths with forward slashes
     return Object.fromEntries(Object.keys(paths).map((alias)=>[
@@ -25,5 +27,34 @@ const STAR = '__meocord_paths_star__';
             match(alias.replace('*', STAR)).map((target)=>path.resolve(target).replace(STAR, '*'))
         ]));
 }
+/** The top-level lists of files and globs. */ const FILE_LISTS = [
+    'include',
+    'exclude',
+    'files'
+];
+/**
+ * The project's tsconfig as the bundler resolves modules with it, written as one file with no `extends`: `baseUrl`
+ * and `paths` as `tsc` reads them through `extends` (`paths` as {@link projectPaths} gives them), and `include`,
+ * `exclude` and `files`, each absolute, from the file that declares it and with `${configDir}` as the project. Rspack's
+ * resolver reads no other compiler option, so no other is written: one inferred by a TypeScript other than the
+ * project's can't reach the copy. Undefined when there is no tsconfig.json.
+ */ function resolutionTsconfig(cwd = process.cwd()) {
+    const configPath = path.join(cwd, 'tsconfig.json');
+    if (!existsSync(configPath)) return undefined;
+    const resolved = parseTsconfig(configPath);
+    const absolute = (entry)=>path.resolve(cwd, String(entry));
+    const tsconfig = {
+        compilerOptions: {}
+    };
+    const baseUrl = resolved.compilerOptions?.baseUrl;
+    if (typeof baseUrl === 'string') tsconfig.compilerOptions.baseUrl = absolute(baseUrl);
+    const paths = absolutePaths(configPath, resolved);
+    if (paths) tsconfig.compilerOptions.paths = paths;
+    for (const key of FILE_LISTS){
+        const value = resolved[key];
+        if (Array.isArray(value)) tsconfig[key] = value.map(absolute);
+    }
+    return tsconfig;
+}
 
-export { projectPaths };
+export { projectPaths, resolutionTsconfig };

package/dist/esm/util/tsconfig.util.js

@@ -1,25 +1,9 @@
 import path from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdtempSync, rmSync, readlinkSync, readdirSync } from 'fs';
 import { tmpdir, hostname } from 'os';
-import { createRequire } from 'module';
 import { parseJsonc } from './json.util.js';
-import { projectPaths } from './tsconfig-paths.util.js';
+import { resolutionTsconfig } from './tsconfig-paths.util.js';
 
-/**
- * An `extends` made to work from another directory: a relative path made absolute, and a package
- * resolved from the project's `node_modules`, or kept as it is when it cannot be found there.
- */ function resolveExtends(value, cwd) {
-    const projectRequire = createRequire(path.join(cwd, 'tsconfig.json'));
-    const resolve = (entry)=>{
-        if (entry.startsWith('.') || path.isAbsolute(entry)) return path.resolve(cwd, entry);
-        try {
-            return projectRequire.resolve(entry);
-        } catch  {
-            return entry;
-        }
-    };
-    return Array.isArray(value) ? value.map(resolve) : resolve(value);
-}
 // The directory this process writes its copies in, and how many it has written there
 let copiesDir;
 let copies = 0;
@@ -89,12 +73,11 @@ function isRunning(pid) {
     return dir;
 }
 /**
- * Writes a copy of the project's tsconfig.json for the bundler and returns its path: comments and trailing commas
- * removed, paths made absolute (`paths` as {@link projectPaths} reads them), `noEmit` dropped. One file per call in this
- * process's directory, removed at exit; the project's file is never written.
+ * Writes a copy of the project's tsconfig.json for the bundler and returns its path. The copy is for module resolution
+ * only: what {@link resolutionTsconfig} gives, with no `extends`, and the project's own references. One file per call
+ * in this process's directory, removed at exit; the project's file is never written.
  * @throws When `tsconfig.json` is missing or cannot be parsed.
  */ function prepareModifiedTsConfig() {
-    var _parsedConfig;
     const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
     // Ensure tsconfig.json exists
     if (!existsSync(tsConfigPath)) {
@@ -108,46 +91,21 @@ function isRunning(pid) {
     } catch (error) {
         throw new Error(`Could not parse tsconfig.json in ${process.cwd()}: ${error instanceof Error ? error.message : String(error)}. ` + `Fix the JSON, then build again.`);
     }
-    // The copy lives in the temp directory, so every path in it is made absolute from the project
+    // The copy lives in the temp directory and is for module resolution alone: what the bundler resolves with, every path
+    // absolute and no `extends` left, since the bundler's own lookup of one can't read a Windows absolute path
     const cwd = process.cwd();
-    if (parsedConfig?.extends) parsedConfig.extends = resolveExtends(parsedConfig.extends, cwd);
-    // `${configDir}` is the project, which the copy's own directory would otherwise stand for
-    for (const key of [
-        'include',
-        'exclude',
-        'files'
-    ]){
-        if (Array.isArray(parsedConfig?.[key])) {
-            parsedConfig[key] = parsedConfig[key].map((p)=>path.resolve(cwd, p.replaceAll('${configDir}', cwd)));
-        }
-    }
-    // Process compilerOptions
-    if (parsedConfig?.compilerOptions) {
-        const pathOptions = [
-            'outDir',
-            'rootDir',
-            'baseUrl',
-            'tsBuildInfoFile'
-        ];
-        // Convert relative paths to absolute paths in `compilerOptions`
-        pathOptions.forEach((option)=>{
-            if (parsedConfig.compilerOptions[option]) {
-                parsedConfig.compilerOptions[option] = path.resolve(process.cwd(), parsedConfig.compilerOptions[option]);
-            }
-        });
-        if (Array.isArray(parsedConfig.compilerOptions.typeRoots)) {
-            parsedConfig.compilerOptions.typeRoots = parsedConfig.compilerOptions.typeRoots.map((p)=>path.resolve(cwd, p));
-        }
-        // Remove `noEmit` option if it exists
-        if ('noEmit' in parsedConfig.compilerOptions) {
-            delete parsedConfig.compilerOptions.noEmit;
-        }
+    const copy = {
+        ...resolutionTsconfig(cwd)
+    };
+    // Project references, which tsc reads from this file alone and resolves from the project, `${configDir}` as written
+    if (Array.isArray(parsedConfig?.references)) {
+        copy.references = parsedConfig.references.map((reference)=>typeof reference?.path === 'string' ? {
+                ...reference,
+                path: path.resolve(cwd, reference.path)
+            } : reference);
     }
-    // The paths as tsc reads them, inherited ones included, written absolute so the copy in the temp directory keeps them
-    const paths = projectPaths(cwd);
-    if (paths) ((_parsedConfig = parsedConfig).compilerOptions ?? (_parsedConfig.compilerOptions = {})).paths = paths;
     const tempTsConfigPath = path.join(copiesDirectory(), `modified-tsconfig-${++copies}.json`);
-    writeFileSync(tempTsConfigPath, JSON.stringify(parsedConfig, null, 2));
+    writeFileSync(tempTsConfigPath, JSON.stringify(copy, null, 2));
     return tempTsConfigPath;
 }
 

package/dist/esm/util/user-text.util.js

@@ -1,7 +1,7 @@
 import { escapeMarkdown } from 'discord.js';
 
-/** Characters a log line shows escaped: C0 and C1 controls, DEL, line and paragraph separators, and bidi controls. */ const UNSAFE_IN_LOG = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
-/** The same, with the quote and the backslash, for text shown between quotes. */ const UNSAFE_IN_QUOTES = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069"\\]/g;
+/** Characters a log line shows escaped: C0 and C1 controls, DEL, line and paragraph separators, and bidi controls. */ const UNSAFE_IN_LOG = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}]/gu;
+/** The same, with the quote and the backslash, for text shown between quotes. */ const UNSAFE_IN_QUOTES = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\p{Bidi_Control}"\\]/gu;
 const SHORT_ESCAPES = {
     '\n': '\\n',
     '\r': '\\r',
@@ -25,8 +25,12 @@ const escapeChar = (char)=>SHORT_ESCAPES[char] ?? `\\u${char.charCodeAt(0).toStr
     if (characters.length <= LOGGED_CHARACTERS) return quoted(text);
     return `${quoted(`${characters.slice(0, LOGGED_CHARACTERS).join('')}…`)} (${characters.length} characters)`;
 }
-/** Words a user wrote, as a reply quotes them: on one line, with their markdown, masked links included, shown as typed. */ function userWords(text) {
-    return escapeMarkdown(text.replace(/\s+/g, ' ').trim(), {
+/**
+ * Words a user wrote, as a reply quotes them: on one line, with their markdown, masked links included, shown as typed.
+ * Each run of whitespace reads as one space, and the spaces around the words are kept, since a word in quotes can
+ * carry them and be refused for them.
+ */ function userWords(text) {
+    return escapeMarkdown(text.replace(/\s+/g, ' '), {
         maskedLink: true
     });
 }

package/dist/esm/util/value.util.js

@@ -26,15 +26,26 @@ import { quoteForLog } from './user-text.util.js';
 }
 /** A class's name after its article, such as `an AutocompleteInteraction`; a `U` name reads as "you", so takes `a`. */ const withArticle = (name)=>`${/^[AEIO]/i.test(name) ? 'an' : 'a'} ${name}`;
 /**
- * Sets `key` on `target` as an own, enumerable data property: unlike `target[key] = value`, a key named `__proto__`
- * is a key like any other rather than the object's prototype.
+ * Sets `key` on a plain object `target` as an own, enumerable data property: unlike `target[key] = value`, a key
+ * named `__proto__` is a key like any other rather than the object's prototype, and a key such as `toString` is set
+ * even where `Object.prototype` is frozen.
  */ function setOwn(target, key, value) {
-    Object.defineProperty(target, key, {
+    // An assignment would call __proto__'s setter, and throw for a member of a frozen Object.prototype. Any other key
+    // assigned is an own data property already; defining each would cost V8 its fast object shape
+    if (key in Object.prototype) Object.defineProperty(target, key, {
         value,
         enumerable: true,
         writable: true,
         configurable: true
     });
+    else target[key] = value;
+}
+/** `target`'s own value for `key`, never one it inherits, such as `Object.prototype.toString` for `toString`. */ const ownValue = (target, key)=>Object.hasOwn(target, key) ? target[key] : undefined;
+/**
+ * Gives each of `keys`, names `Object.prototype` has such as `toString` or `constructor`, that `target` doesn't hold
+ * an own `undefined`, so reading one left out gives `undefined` rather than the inherited member.
+ */ function shadowInherited(target, keys) {
+    for (const key of keys)if (!Object.hasOwn(target, key)) setOwn(target, key, undefined);
 }
 
-export { describeValue, isConstructible, isConstructor, setOwn, withArticle };
+export { describeValue, isConstructible, isConstructor, ownValue, setOwn, shadowInherited, withArticle };

package/dist/types/common/index.d.cts

@@ -1,11 +1,11 @@
 import { ColorResolvable, Interaction, Message, Locale } from 'discord.js';
-import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-Dlf0ZZtS.cjs';
+import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-CqXImwF_.cjs';
 import { Token, ProviderToken, FactoryProvider, DeepReadonly, MeoCordTheme } from '../interface/index.cjs';
-export { e as CommandNotFoundError, f as CooldownError, g as CooldownScope, h as CooldownStoreError, E as ExecutionContext, i as ExecutionContextType, G as GuardDeniedError, I as InstallContext, j as MemoryCooldownStore, k as MessageUsageError, l as MessageUsageIssue, m as MetadataDecorator, R as ResponseCall, n as ResponseEditFlags, o as ResponseEditPayload, p as ResponseErrorOptions, q as ResponseFlags, r as ResponseLockOptions, s as ResponsePayload, t as ResponsePhase, u as ResponseSendOptions, v as ResponseState, U as UserError, w as UserErrorOptions, V as ValidationError, x as ValidationIssue, y as cooldownMessage, z as cooldownStoreMessage, A as createMetadata, B as getInstallContext, H as respond } from '../index-Dlf0ZZtS.cjs';
-export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-Bh1U13yy.cjs';
-import { T as Translator } from '../translator-Bg7hwxDF.cjs';
-export { C as CatalogDefinition, a as CatalogShape, L as LocaleCatalog, b as LocalizationKey, M as MessageKey, c as MessageParams, P as PluralCategory, d as PluralMessage, S as StringMessageKey, e as Translate, f as TranslatorOptions, g as createTranslator, h as defineCatalog } from '../translator-Bg7hwxDF.cjs';
-export { T as ThemeCache } from '../theme-resolvers-CyEz9pnv.cjs';
+export { e as CommandNotFoundError, f as CooldownError, g as CooldownScope, h as CooldownStoreError, E as ExecutionContext, i as ExecutionContextType, G as GuardDeniedError, I as InstallContext, j as MemoryCooldownStore, k as MessageUsageError, l as MessageUsageIssue, m as MetadataDecorator, R as ResponseCall, n as ResponseEditFlags, o as ResponseEditPayload, p as ResponseErrorOptions, q as ResponseFlags, r as ResponseLockOptions, s as ResponsePayload, t as ResponsePhase, u as ResponseSendOptions, v as ResponseState, U as UserError, w as UserErrorOptions, V as ValidationError, x as ValidationIssue, y as cooldownMessage, z as cooldownStoreMessage, A as createMetadata, B as getInstallContext, H as respond } from '../index-CqXImwF_.cjs';
+export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-IQrK-MN2.cjs';
+import { T as Translator } from '../translator-iJhDlgwL.cjs';
+export { C as CatalogDefinition, a as CatalogShape, L as LocaleCatalog, b as LocalizationKey, M as MessageKey, c as MessageParams, P as PluralCategory, d as PluralMessage, S as StringMessageKey, e as Translate, f as TranslatorOptions, g as createTranslator, h as defineCatalog } from '../translator-iJhDlgwL.cjs';
+export { T as ThemeCache } from '../theme-resolvers-AtgeaYqF.cjs';
 import '@rsbuild/core';
 import '../controller.enum-DTDn69N9.cjs';
 
@@ -532,7 +532,10 @@ declare function translateError(error: unknown, t: Translator<any>, target: Inte
  *
  * Use it where a bot logs a startup failure, so an error MeoCord explained is not logged twice: an app
  * `MeoCordFactory.create()` refuses, such as two handlers for one command, or Discord refusing the bot token or a
- * privileged intent at login. The error is otherwise unchanged.
+ * privileged intent at login. A built bot has `process.exitCode` set for such an error already, and a start that a stop
+ * ended, which is explained too, leaves it as it was, so the process exits 0. Outside a build, as a script run by hand,
+ * `MeoCordFactory.create()` sets no code for an app it refuses, so a catch that returns early for an explained error,
+ * as below, sets `process.exitCode` itself there. The error is otherwise unchanged.
  *
  * @param error - An error `MeoCordFactory.create()` threw or `app.start()` rejected with.
  * @returns `true` when MeoCord explained the error.
@@ -548,9 +551,10 @@ declare function translateError(error: unknown, t: Translator<any>, target: Inte
  *   await app.start()
  * }
  *
- * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged
+ * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged, with the exit code set
  * bootstrap().catch(error => {
- *   if (!isExplainedError(error)) logger.error('Error during startup:', error)
+ *   if (isExplainedError(error)) return
+ *   logger.error('Error during startup:', error)
  *   process.exitCode = 1
  * })
  * ```

package/dist/types/common/index.d.ts

@@ -1,11 +1,11 @@
 import { ColorResolvable, Interaction, Message, Locale } from 'discord.js';
-import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-DKJclIi-.js';
+import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-Brkd6QGL.js';
 import { Token, ProviderToken, FactoryProvider, DeepReadonly, MeoCordTheme } from '../interface/index.js';
-export { e as CommandNotFoundError, f as CooldownError, g as CooldownScope, h as CooldownStoreError, E as ExecutionContext, i as ExecutionContextType, G as GuardDeniedError, I as InstallContext, j as MemoryCooldownStore, k as MessageUsageError, l as MessageUsageIssue, m as MetadataDecorator, R as ResponseCall, n as ResponseEditFlags, o as ResponseEditPayload, p as ResponseErrorOptions, q as ResponseFlags, r as ResponseLockOptions, s as ResponsePayload, t as ResponsePhase, u as ResponseSendOptions, v as ResponseState, U as UserError, w as UserErrorOptions, V as ValidationError, x as ValidationIssue, y as cooldownMessage, z as cooldownStoreMessage, A as createMetadata, B as getInstallContext, H as respond } from '../index-DKJclIi-.js';
-export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-Bh1U13yy.js';
-import { T as Translator } from '../translator-CeP4bCzp.js';
-export { C as CatalogDefinition, a as CatalogShape, L as LocaleCatalog, b as LocalizationKey, M as MessageKey, c as MessageParams, P as PluralCategory, d as PluralMessage, S as StringMessageKey, e as Translate, f as TranslatorOptions, g as createTranslator, h as defineCatalog } from '../translator-CeP4bCzp.js';
-export { T as ThemeCache } from '../theme-resolvers-DA204O-q.js';
+export { e as CommandNotFoundError, f as CooldownError, g as CooldownScope, h as CooldownStoreError, E as ExecutionContext, i as ExecutionContextType, G as GuardDeniedError, I as InstallContext, j as MemoryCooldownStore, k as MessageUsageError, l as MessageUsageIssue, m as MetadataDecorator, R as ResponseCall, n as ResponseEditFlags, o as ResponseEditPayload, p as ResponseErrorOptions, q as ResponseFlags, r as ResponseLockOptions, s as ResponsePayload, t as ResponsePhase, u as ResponseSendOptions, v as ResponseState, U as UserError, w as UserErrorOptions, V as ValidationError, x as ValidationIssue, y as cooldownMessage, z as cooldownStoreMessage, A as createMetadata, B as getInstallContext, H as respond } from '../index-Brkd6QGL.js';
+export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-bI-okq7g.js';
+import { T as Translator } from '../translator-D8aydlCE.js';
+export { C as CatalogDefinition, a as CatalogShape, L as LocaleCatalog, b as LocalizationKey, M as MessageKey, c as MessageParams, P as PluralCategory, d as PluralMessage, S as StringMessageKey, e as Translate, f as TranslatorOptions, g as createTranslator, h as defineCatalog } from '../translator-D8aydlCE.js';
+export { T as ThemeCache } from '../theme-resolvers-BgqysV8d.js';
 import '@rsbuild/core';
 import '../controller.enum-DTDn69N9.js';
 
@@ -532,7 +532,10 @@ declare function translateError(error: unknown, t: Translator<any>, target: Inte
  *
  * Use it where a bot logs a startup failure, so an error MeoCord explained is not logged twice: an app
  * `MeoCordFactory.create()` refuses, such as two handlers for one command, or Discord refusing the bot token or a
- * privileged intent at login. The error is otherwise unchanged.
+ * privileged intent at login. A built bot has `process.exitCode` set for such an error already, and a start that a stop
+ * ended, which is explained too, leaves it as it was, so the process exits 0. Outside a build, as a script run by hand,
+ * `MeoCordFactory.create()` sets no code for an app it refuses, so a catch that returns early for an explained error,
+ * as below, sets `process.exitCode` itself there. The error is otherwise unchanged.
  *
  * @param error - An error `MeoCordFactory.create()` threw or `app.start()` rejected with.
  * @returns `true` when MeoCord explained the error.
@@ -548,9 +551,10 @@ declare function translateError(error: unknown, t: Translator<any>, target: Inte
  *   await app.start()
  * }
  *
- * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged
+ * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged, with the exit code set
  * bootstrap().catch(error => {
- *   if (!isExplainedError(error)) logger.error('Error during startup:', error)
+ *   if (isExplainedError(error)) return
+ *   logger.error('Error during startup:', error)
  *   process.exitCode = 1
  * })
  * ```

package/dist/types/core/index.d.cts

@@ -1,5 +1,5 @@
 import { ServiceIdentifier } from 'inversify';
-import { J as MeoCordApplication } from '../index-Dlf0ZZtS.cjs';
+import { J as MeoCordApplication } from '../index-CqXImwF_.cjs';
 import { MetadataDecorator } from '../common/index.cjs';
 import { MessageScope, MessageCommandOptions, MessageHelp } from '../interface/index.cjs';
 import { RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Message, Client } from 'discord.js';
@@ -172,7 +172,10 @@ interface MessageHandlerEntry extends HandlerEntryBase {
     aliases: readonly string[];
     /** What the command does, from its `description` option. */
     description: string | undefined;
-    /** Where the command works: its `scope` option, narrowed to servers by a `member`, `role` or `channel` param or flag. */
+    /**
+     * Where the command works: its `scope` option, narrowed to servers by a `member`, `role` or `channel` param, or
+     * required flag.
+     */
     scope: MessageScope;
     /** Whether its `hidden` option leaves it out of help's lists, including a parent's list of subcommands. */
     hidden: boolean;
@@ -269,16 +272,19 @@ declare class HandlerRegistry {
     private readonly classes;
     private readonly messages;
     private readonly translator;
+    private readonly controllers;
     private entries?;
-    /** Built from `classes` for a registry no dispatcher shares its routes with. */
+    /** Built from the controllers for a registry no dispatcher shares its routes with yet. */
     private messageRoutes?;
     /**
-     * @param classes - The app's classes to read handlers from. The factory fills the list
-     *   once the app is bound; entries are read on the first {@link list}.
+     * @param classes - The app's classes to read handlers from, controllers and services alike. The factory fills the
+     *   list once the app is bound; entries are read on the first {@link list}.
      * @param messages - The app's `messages` options, whose `caseSensitive` message entries' `matches` follows.
      * @param translator - The app's translator, read when {@link messageHelp} words its labels; none for English.
+     * @param controllers - The app's controllers, the classes dispatch routes messages to, which {@link messageHelp}
+     *   lists; `classes` when not given.
      */
-    constructor(classes: readonly HandlerClass[], messages?: MessageCommandOptions, translator?: () => Translator<any> | undefined);
+    constructor(classes: readonly HandlerClass[], messages?: MessageCommandOptions, translator?: () => Translator<any> | undefined, controllers?: readonly HandlerClass[]);
     /**
      * Lists the registered handlers.
      *
@@ -364,6 +370,10 @@ type JsonObject<T> = {
  *
  * A `BigInt` cannot be written, so it is `never`.
  *
+ * An object arrives with its own enumerable fields only. A class's getters are left out, yet stay in this type, as
+ * TypeScript can't tell a getter from a field: return a plain object, or give the class a `toJSON`, for a value
+ * with getters.
+ *
  * @typeParam T - The value before it is sent.
  * @group Types
  * @see {@link ShardContext.call}
@@ -446,11 +456,11 @@ declare class ShardContext {
      *
      * With process sharding that is one result per shard; with one process, a single result listing every
      * shard. The arguments and the result pass as JSON in every mode, one process and tests included, so a
-     * `Date` arrives as a string and a `Map` as `{}` wherever it runs, and a value JSON cannot carry, such as a
-     * `BigInt`, fails the call. A method whose params JSON would change, such as one taking a `Date`, cannot be called:
-     * the argument is refused, naming what to declare instead. An `undefined` argument arrives as `undefined`. A process
-     * that throws, lacks the service, or does not answer within 10 seconds gives an error result instead of failing the
-     * others.
+     * `Date` arrives as a string, a `Map` as `{}` and a class instance as its own fields, without its getters, wherever
+     * it runs, and a value JSON cannot carry, such as a `BigInt`, fails the call. A method whose params JSON would
+     * change, such as one taking a `Date`, cannot be called: the argument is refused, naming what to declare instead. An
+     * `undefined` argument arrives as `undefined`. A process that throws, lacks the service, or does not answer within
+     * 10 seconds gives an error result instead of failing the others.
      *
      * @param service - The controller, the service, or a class a provider stands in for; each process resolves its own
      *   instance.

package/dist/types/core/index.d.ts

@@ -1,5 +1,5 @@
 import { ServiceIdentifier } from 'inversify';
-import { J as MeoCordApplication } from '../index-DKJclIi-.js';
+import { J as MeoCordApplication } from '../index-Brkd6QGL.js';
 import { MetadataDecorator } from '../common/index.js';
 import { MessageScope, MessageCommandOptions, MessageHelp } from '../interface/index.js';
 import { RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Message, Client } from 'discord.js';
@@ -172,7 +172,10 @@ interface MessageHandlerEntry extends HandlerEntryBase {
     aliases: readonly string[];
     /** What the command does, from its `description` option. */
     description: string | undefined;
-    /** Where the command works: its `scope` option, narrowed to servers by a `member`, `role` or `channel` param or flag. */
+    /**
+     * Where the command works: its `scope` option, narrowed to servers by a `member`, `role` or `channel` param, or
+     * required flag.
+     */
     scope: MessageScope;
     /** Whether its `hidden` option leaves it out of help's lists, including a parent's list of subcommands. */
     hidden: boolean;
@@ -269,16 +272,19 @@ declare class HandlerRegistry {
     private readonly classes;
     private readonly messages;
     private readonly translator;
+    private readonly controllers;
     private entries?;
-    /** Built from `classes` for a registry no dispatcher shares its routes with. */
+    /** Built from the controllers for a registry no dispatcher shares its routes with yet. */
     private messageRoutes?;
     /**
-     * @param classes - The app's classes to read handlers from. The factory fills the list
-     *   once the app is bound; entries are read on the first {@link list}.
+     * @param classes - The app's classes to read handlers from, controllers and services alike. The factory fills the
+     *   list once the app is bound; entries are read on the first {@link list}.
      * @param messages - The app's `messages` options, whose `caseSensitive` message entries' `matches` follows.
      * @param translator - The app's translator, read when {@link messageHelp} words its labels; none for English.
+     * @param controllers - The app's controllers, the classes dispatch routes messages to, which {@link messageHelp}
+     *   lists; `classes` when not given.
      */
-    constructor(classes: readonly HandlerClass[], messages?: MessageCommandOptions, translator?: () => Translator<any> | undefined);
+    constructor(classes: readonly HandlerClass[], messages?: MessageCommandOptions, translator?: () => Translator<any> | undefined, controllers?: readonly HandlerClass[]);
     /**
      * Lists the registered handlers.
      *
@@ -364,6 +370,10 @@ type JsonObject<T> = {
  *
  * A `BigInt` cannot be written, so it is `never`.
  *
+ * An object arrives with its own enumerable fields only. A class's getters are left out, yet stay in this type, as
+ * TypeScript can't tell a getter from a field: return a plain object, or give the class a `toJSON`, for a value
+ * with getters.
+ *
  * @typeParam T - The value before it is sent.
  * @group Types
  * @see {@link ShardContext.call}
@@ -446,11 +456,11 @@ declare class ShardContext {
      *
      * With process sharding that is one result per shard; with one process, a single result listing every
      * shard. The arguments and the result pass as JSON in every mode, one process and tests included, so a
-     * `Date` arrives as a string and a `Map` as `{}` wherever it runs, and a value JSON cannot carry, such as a
-     * `BigInt`, fails the call. A method whose params JSON would change, such as one taking a `Date`, cannot be called:
-     * the argument is refused, naming what to declare instead. An `undefined` argument arrives as `undefined`. A process
-     * that throws, lacks the service, or does not answer within 10 seconds gives an error result instead of failing the
-     * others.
+     * `Date` arrives as a string, a `Map` as `{}` and a class instance as its own fields, without its getters, wherever
+     * it runs, and a value JSON cannot carry, such as a `BigInt`, fails the call. A method whose params JSON would
+     * change, such as one taking a `Date`, cannot be called: the argument is refused, naming what to declare instead. An
+     * `undefined` argument arrives as `undefined`. A process that throws, lacks the service, or does not answer within
+     * 10 seconds gives an error result instead of failing the others.
      *
      * @param service - The controller, the service, or a class a provider stands in for; each process resolves its own
      *   instance.

package/dist/types/decorator/index.d.cts

@@ -1,12 +1,68 @@
 import { CooldownStore } from '../common/index.cjs';
 import { BuildableCommandType, CommandBuilderOptions, CommandBuilderBase, PIPED_BRAND, CommandBuilderConstructor, CommandInteractionType, MessageHandlerOptions, CheckedParams, ReactionHandlerSettings, ReactionEvent, ControllerOptions, StageParams, GuardOptions, GuardInterface, InterceptorOptions, InterceptorInterface, ExceptionFilter, Provider, CooldownStoreFailure, ResponsePresenter, MessageCommandOptions, DispatchObserver, RootTheme, ThemeResolvers, ThemeResolver, PipeInterface, StandardSchemaV1, ValidatePipes, ValidateOptions, InferSchemaOutput, CooldownOptions, ProviderToken, ObserverOptions, ThemeOverride } from '../interface/index.cjs';
-import { AutocompleteInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientEvents, ClientOptions, ActivityOptions } from 'discord.js';
+import { ClientEvents, AutocompleteInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, OmitPartialGroupDMChannel, Message, MessageReaction, PartialMessageReaction, ClientOptions, ActivityOptions } from 'discord.js';
 import { CommandType } from '../enum/index.cjs';
 import { Route, RouteParams, RouteValues, RouteValue } from '../common/index.cjs';
 import { ServiceIdentifier } from 'inversify';
 import { Translator } from '../common/index.cjs';
 import '@rsbuild/core';
 
+/**
+ * Handles a discord.js client event every time it is emitted, on a controller or a service.
+ *
+ * Use it for gateway events MeoCord has no handler type for, such as a member joining or a channel being
+ * created. For commands, components, messages and reactions, use {@link Command}, `@MessageHandler` or
+ * `@ReactionHandler`, which route them.
+ *
+ * @remarks
+ * The handler's parameters are typed from discord.js's `ClientEvents`. It runs through the pipeline, so the app's
+ * global guards apply to it, and its class's and its own, and an error it throws is logged without stopping the bot. Handling `interactionCreate`
+ * or `messageCreate` here runs alongside MeoCord's own dispatch of them.
+ *
+ * @param event - The client event to handle, such as `'guildMemberAdd'`.
+ *
+ * @example
+ * ```ts
+ * @On('guildMemberAdd')
+ * async greet(member: GuildMember) {
+ *   await member.send(`Welcome to ${member.guild.name}!`)
+ * }
+ * ```
+ *
+ * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
+ * @group Decorators
+ * @category Handlers
+ * @see {@link Once}
+ * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
+ */
+declare function On<E extends keyof ClientEvents>(event: E): <F extends (...args: ClientEvents[E]) => unknown>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<F>) => void;
+/**
+ * Handles a discord.js client event the first time it is emitted only, on a controller or a service.
+ *
+ * Use it for one-off work on an event, such as warming a cache once the client is ready. For every emission,
+ * use {@link On}; for work at startup and shutdown, a service's `onReady` and `onShutdown` hooks.
+ *
+ * @param event - The client event to handle, such as `'clientReady'`.
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * export class CacheWarmer {
+ *   @Once('clientReady')
+ *   async warm(client: Client<true>) {
+ *     await client.guilds.fetch()
+ *   }
+ * }
+ * ```
+ *
+ * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
+ * @group Decorators
+ * @category Handlers
+ * @see {@link On}
+ * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
+ */
+declare function Once<E extends keyof ClientEvents>(event: E): <F extends (...args: ClientEvents[E]) => unknown>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<F>) => void;
+
 /**
  * Marks a class as a service, which controllers and other services inject by its type.
  *
@@ -424,62 +480,6 @@ declare function Autocomplete<_R = unknown>(commandPath: string, optionName?: st
  */
 declare function Controller(options?: ControllerOptions): (target: abstract new (...args: any[]) => unknown, propertyKey?: string | symbol) => void;
 
-/**
- * Handles a discord.js client event every time it is emitted, on a controller or a service.
- *
- * Use it for gateway events MeoCord has no handler type for, such as a member joining or a channel being
- * created. For commands, components, messages and reactions, use {@link Command}, `@MessageHandler` or
- * `@ReactionHandler`, which route them.
- *
- * @remarks
- * The handler's parameters are typed from discord.js's `ClientEvents`. It runs through the pipeline, so the app's
- * global guards apply to it, and its class's and its own, and an error it throws is logged without stopping the bot. Handling `interactionCreate`
- * or `messageCreate` here runs alongside MeoCord's own dispatch of them.
- *
- * @param event - The client event to handle, such as `'guildMemberAdd'`.
- *
- * @example
- * ```ts
- * @On('guildMemberAdd')
- * async greet(member: GuildMember) {
- *   await member.send(`Welcome to ${member.guild.name}!`)
- * }
- * ```
- *
- * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
- * @group Decorators
- * @category Handlers
- * @see {@link Once}
- * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
- */
-declare function On<E extends keyof ClientEvents>(event: E): <F extends (...args: ClientEvents[E]) => unknown>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<F>) => void;
-/**
- * Handles a discord.js client event the first time it is emitted only, on a controller or a service.
- *
- * Use it for one-off work on an event, such as warming a cache once the client is ready. For every emission,
- * use {@link On}; for work at startup and shutdown, a service's `onReady` and `onShutdown` hooks.
- *
- * @param event - The client event to handle, such as `'clientReady'`.
- *
- * @example
- * ```ts
- * @Service()
- * export class CacheWarmer {
- *   @Once('clientReady')
- *   async warm(client: Client<true>) {
- *     await client.guilds.fetch()
- *   }
- * }
- * ```
- *
- * @pipeline handler with the guards, interceptors and filters that apply to events: the app's global ones, its class's and its own
- * @group Decorators
- * @category Handlers
- * @see {@link On}
- * @see {@link https://meocord.dev/docs/4.2/gateway-events | Gateway events}
- */
-declare function Once<E extends keyof ClientEvents>(event: E): <F extends (...args: ClientEvents[E]) => unknown>(target: object, propertyKey: string, _descriptor: TypedPropertyDescriptor<F>) => void;
-
 /**
  * One entry of `@UseGuard`, `@UseInterceptor`, `@UseFilter`, `@UsePipe` or `@MeoCord`'s lists, checked
  * against the class it provides: `params` against the params the class declares. An entry typed only as
@@ -735,8 +735,8 @@ declare function UseFilter<const T extends readonly unknown[]>(...filters: {
  * @see {@link MeoCordConfig}
  */
 interface MeoCordOptions<G extends readonly unknown[] = readonly unknown[], I extends readonly unknown[] = readonly unknown[], F extends readonly unknown[] = readonly unknown[]> {
-    /** Controllers to register. */
-    controllers: ServiceIdentifier[];
+    /** Controllers to register: their classes. */
+    controllers: (abstract new (...args: any[]) => any)[];
     /**
      * Options for the discord.js `Client`, such as its intents and partials. The shards it runs as are set in
      * `meocord.config.ts`, under `sharding`.
@@ -835,10 +835,10 @@ interface MeoCordOptions<G extends readonly unknown[] = readonly unknown[], I ex
     /**
      * Themes by where a call comes from: `guild` for a server's, over the handler's, and `user` for a user's, over the
      * server's, in a server or a DM. Each returns part of a theme or `undefined`, at once or as a promise, and is looked
-     * up while `@Defer` acknowledges, before the guards. A result that is not a valid theme is left out, with a warning
-     * once per server or user; a resolver that fails or passes its timeout leaves its theme out of the call, logged once
-     * until it answers again. A class implementing {@link ThemeResolver} does the same with the app's services, resolved
-     * from its container.
+     * up while `@Defer` acknowledges, before the guards. A result that is not a valid theme, as is one that cannot be
+     * read, such as an object with a cycle or a getter that throws, is left out, with a warning once per server or user;
+     * a resolver that fails or passes its timeout leaves its theme out of the call, logged once until it answers again.
+     * A class implementing {@link ThemeResolver} does the same with the app's services, resolved from its container.
      */
     themeFor?: ThemeResolvers | (new (...args: any[]) => ThemeResolver);
     /**