meocord 4.1.2 → 4.2.1

package/dist/esm/util/platform.util.js

@@ -1,6 +1,5 @@
 import { writeFileSync, existsSync, readFileSync } from 'fs';
 import path from 'path';
-import { refuse } from './refusal.util.js';
 import { isBuiltApplication, bundleEntry } from './bundle-entry.util.js';
 
 /**
@@ -42,23 +41,24 @@ import { isBuiltApplication, bundleEntry } from './bundle-entry.util.js';
     writeFileSync(path.join(distDir, PLATFORM_MANIFEST), `${JSON.stringify(currentPlatform(), null, 2)}\n`);
 }
 /**
- * Stops a bundle from starting on a platform its native addons were not built for, with one clear
- * message instead of a linker error on the first command that loads an addon.
+ * Why a bundle cannot start on this platform, naming both, or `undefined` when it can: its manifest names the platform
+ * its native addons were built for. The pre-entry checks it before any package loads, where a native addon built for
+ * another platform would otherwise fail with an error of its own.
  * @param distDir - Directory holding the manifest. Defaults to the built bundle's directory, which a process manager's
  *   wrapper in `argv[1]` would hide, and else to the entry script's.
- */ function assertBuiltForThisPlatform(distDir = defaultDistDir()) {
-    if (!distDir) return;
+ */ function platformMismatch(distDir = defaultDistDir()) {
+    if (!distDir) return undefined;
     const manifest = path.join(distDir, PLATFORM_MANIFEST);
-    if (!existsSync(manifest)) return;
+    if (!existsSync(manifest)) return undefined;
     let built;
     try {
         built = JSON.parse(readFileSync(manifest, 'utf8'));
     } catch  {
-        return;
+        return undefined;
     }
     const running = currentPlatform();
-    if (isSamePlatform(built, running)) return;
-    throw refuse(new Error(`${path.basename(distDir)}: this build carries native addons compiled for ${describePlatform(built)}, but is ` + `running on ${describePlatform(running)}. Compiled binaries only load on the platform they were built for. ` + 'Build on the same platform you deploy to -- for a container, run `meocord build` inside the image.'));
+    if (isSamePlatform(built, running)) return undefined;
+    return `${path.basename(distDir)}: this build carries native addons compiled for ${describePlatform(built)}, but is ` + `running on ${describePlatform(running)}. Compiled binaries only load on the platform they were built for. ` + 'Build on the same platform you deploy to -- for a container, run `meocord build` inside the image.';
 }
 /** The built bundle's directory, or the entry script's outside a built bot. */ function defaultDistDir() {
     const entry = isBuiltApplication() ? bundleEntry() : undefined;
@@ -66,4 +66,4 @@ import { isBuiltApplication, bundleEntry } from './bundle-entry.util.js';
     return process.argv[1] ? path.dirname(process.argv[1]) : undefined;
 }
 
-export { PLATFORM_MANIFEST, assertBuiltForThisPlatform, currentPlatform, describePlatform, isSamePlatform, writePlatformManifest };
+export { PLATFORM_MANIFEST, currentPlatform, describePlatform, isSamePlatform, platformMismatch, writePlatformManifest };

package/dist/esm/util/refusal.util.js

@@ -2,7 +2,7 @@ import path from 'path';
 import { warnDeprecatedBehaviour } from '../common/deprecation.js';
 import { isExplainedError } from '../common/explained-error.js';
 import { Logger } from '../common/logger.js';
-import { isBuiltApplication } from './bundle-entry.util.js';
+import { isBuiltApplication, STARTUP_ERRORS_KEY } from './bundle-entry.util.js';
 import { comparablePath, framePath } from './source-path.util.js';
 
 const REFUSAL = Symbol.for('meocord.refusal');
@@ -51,10 +51,10 @@ const REFUSAL = Symbol.for('meocord.refusal');
 // A stack frame's function and file: `at fn (file:line:col)` or `at file:line:col`, the file possibly a file:// URL
 const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
 /**
- * A refusal as the application reports it: the message, and the first file of the application's own source the stack
- * passes through, other than its entry, which only loads the rest. The file alone: a line from a development build's
- * source map can be off, and a compiler's decorate helper can be placed in any file, so those frames are skipped.
- */ function describeRefusal(error, root, windows = process.platform === 'win32') {
+ * The first file of the application's own source an error's stack passes through, other than its entry, which only
+ * loads the rest, relative to `root`. The file alone: a line from a development build's source map can be off, and a
+ * compiler's decorate helper can be placed in any file, so those frames are skipped.
+ */ function sourceFileOf(error, root, windows = process.platform === 'win32') {
     const paths = windows ? path.win32 : path.posix;
     const source = comparablePath(paths.join(root, 'src') + paths.sep, windows);
     const entry = comparablePath(paths.join(root, 'src', 'main.ts'), windows);
@@ -65,9 +65,149 @@ const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
         const file = paths.normalize(framePath(name, windows));
         const compared = comparablePath(file, windows);
         if (!compared.startsWith(source) || compared === entry || compared.includes(dependencies)) continue;
-        return `${error.message}\n    in ${paths.relative(root, file).split(paths.sep).join('/')}`;
+        return paths.relative(root, file).split(paths.sep).join('/');
+    }
+    return undefined;
+}
+/**
+ * A refusal as the application reports it: the message, led by the declaration it is about where the message does not
+ * name it, and the file of the application's source it comes from; see {@link sourceFileOf}.
+ */ function describeRefusal(error, root, windows = process.platform === 'win32') {
+    const declaration = declarationOf(error);
+    const message = declaration && !error.message.startsWith(declaration) ? `${declaration}: ${error.message}` : error.message;
+    const file = sourceFileOf(error, root, windows);
+    return file ? `${message}\n    in ${file}` : message;
+}
+// ---------------------------------------------------------------------------
+// Startup errors: those create() and a testing module's compile() find, and those decorators find at import
+// ---------------------------------------------------------------------------
+const STARTUP_ERRORS = Symbol.for('meocord.startupErrors');
+const DECLARED = Symbol.for('meocord.declaredStartupErrors');
+const ALL_DECLARED = Symbol.for('meocord.allDeclaredStartupErrors');
+// The startup errors kept while checks run under collectStartupErrors; undefined outside them
+let kept;
+/**
+ * Reports an error a startup check finds. Outside {@link collectStartupErrors} it is thrown, as a refusal; inside, it
+ * is kept, and the check goes on to find the rest.
+ */ function startupError(error) {
+    refuse(error);
+    if (!kept) throw error;
+    // Two checks of one mistake, such as a class needing a translator, name it once
+    if (!kept.some((other)=>other.message === error.message)) kept.push(error);
+}
+/**
+ * Runs startup checks, and once they are done throws the first error they found, unchanged, with every one found on it
+ * for {@link startupErrorsOf}. An error that ends the checks after one was found is left out, as one the found error
+ * caused; one that ends them before any was found is thrown as it is.
+ */ function collectStartupErrors(checks) {
+    const outer = kept;
+    const found = [];
+    kept = found;
+    let result;
+    try {
+        result = checks();
+    } catch (error) {
+        if (found.length === 0) throw error;
+        if (isRefusal(error) && !found.includes(error)) found.push(error);
+        throw firstOf(found);
+    } finally{
+        kept = outer;
+    }
+    if (found.length > 0) throw firstOf(found);
+    return result;
+}
+/**
+ * Ends the checks under way with the errors found so far, before a step that is no check, such as binding or a warning:
+ * a run with one error stops where it stopped when the first error was thrown, and the errors of one pass of the
+ * checks are still reported together.
+ */ function stopOnStartupErrors() {
+    if (kept && kept.length > 0) throw kept[0];
+}
+function firstOf(errors) {
+    const [first] = errors;
+    Object.defineProperty(first, STARTUP_ERRORS, {
+        value: errors,
+        configurable: true
+    });
+    return first;
+}
+/** Every startup error found together with `error`, the first of them; `error` alone when it was the only one. */ function startupErrorsOf(error) {
+    return error[STARTUP_ERRORS] ?? [
+        error
+    ];
+}
+/**
+ * Logs each startup error found with `error` as the application reports a refusal, and how many there were, when there
+ * was more than one; a lone error is left to whoever reports it now.
+ */ function logStartupErrors(error, log, ending) {
+    const errors = startupErrorsOf(error);
+    if (errors.length < 2) return false;
+    for (const each of errors)log(describeRefusal(each, process.cwd()));
+    log(`MeoCord found ${errors.length} startup errors; ${ending}.`);
+    return true;
+}
+/** Sets how decorators report startup errors from here on, before the application's modules load. */ function setStartupErrorsMode(mode) {
+    globalThis[STARTUP_ERRORS_KEY] = mode;
+}
+/** Whether decorators keep their startup errors for create(), as `startupErrors: 'all'` has them. */ const keepsDeclaredErrors = ()=>globalThis[STARTUP_ERRORS_KEY] === 'all';
+/** The declaration a decorator's startup error is about, `Class.method` or `Class`. */ function declarationOf(error) {
+    return error.declaration;
+}
+/**
+ * A decorator that names, on each startup error it throws, the declaration it was applied to, `Class.method` or
+ * `Class`, as `declaration`, and the source file it is declared in, as `file`: the same error, thrown at the same
+ * moment, with its message unchanged. With `startupErrors: 'all'` the error is kept on the class instead, for create()
+ * to report with the rest, and the decorator applies nothing more.
+ */ function declaring(decorate) {
+    return function(target, propertyKey, ...rest) {
+        try {
+            return decorate.call(this, target, propertyKey, ...rest);
+        } catch (error) {
+            if (!isRefusal(error)) throw error;
+            keepOrThrow(error, target, propertyKey);
+            return undefined;
+        }
+    };
+}
+function keepOrThrow(error, target, propertyKey) {
+    var _globalThis, _ALL_DECLARED;
+    // A decorator applied through another, such as applyDecorators, names the declaration once, where it was first thrown
+    if (declarationOf(error) === undefined) {
+        Object.defineProperty(error, 'declaration', {
+            value: decoratedName(target, propertyKey),
+            configurable: true
+        });
+        Object.defineProperty(error, 'file', {
+            get: ()=>sourceFileOf(error, process.cwd()),
+            configurable: true
+        });
     }
-    return error.message;
+    if (!keepsDeclaredErrors()) throw error;
+    const owner = typeof target === 'function' ? target : target.constructor;
+    if (!Object.prototype.hasOwnProperty.call(owner, DECLARED)) Object.defineProperty(owner, DECLARED, {
+        value: []
+    });
+    const declared = owner[DECLARED];
+    if (!declared.includes(error)) declared.push(error);
+    const all = (_globalThis = globalThis)[_ALL_DECLARED = ALL_DECLARED] ?? (_globalThis[_ALL_DECLARED] = []);
+    if (!all.includes(error)) all.push(error);
+}
+/** The startup errors decorators kept on `classes` and the classes they extend, each once, in the order they were found. */ function declaredErrorsOf(classes) {
+    const found = new Set();
+    for (const cls of classes){
+        for(let current = cls; typeof current === 'function' && current !== Function.prototype; current = Object.getPrototypeOf(current)){
+            if (Object.prototype.hasOwnProperty.call(current, DECLARED)) for (const error of current[DECLARED])found.add(error);
+        }
+    }
+    const order = allDeclaredErrors();
+    return [
+        ...found
+    ].sort((a, b)=>order.indexOf(a) - order.indexOf(b));
+}
+/** Every startup error decorators kept in this process, in the order they were found. */ function allDeclaredErrors() {
+    return [
+        ...globalThis[ALL_DECLARED] ?? []
+    ];
 }
 /**
  * Reports a refusal nothing catches as one line, with its source file, and exits 1; other errors keep the runtime's
@@ -95,4 +235,4 @@ const FRAME = /^\s*at (?:(.*?) \()?(.+?):\d+:\d+\)?$/;
     process.on('unhandledRejection', onRejection);
 }
 
-export { decoratedName, deprecatedOnMethod, describeRefusal, handOffRefusal, isRefusal, refuse, refuseOnClass, refuseOnMethod, reportRefusals };
+export { allDeclaredErrors, collectStartupErrors, declarationOf, declaredErrorsOf, declaring, decoratedName, deprecatedOnMethod, describeRefusal, handOffRefusal, isRefusal, keepsDeclaredErrors, logStartupErrors, refuse, refuseOnClass, refuseOnMethod, reportRefusals, setStartupErrorsMode, sourceFileOf, startupError, startupErrorsOf, stopOnStartupErrors };

package/dist/esm/util/shard-process.util.js

@@ -1,5 +1,8 @@
 /** Set by discord.js in every process its ShardingManager spawns. */ const SHARDING_MANAGER_ENV = 'SHARDING_MANAGER';
-/** Whether this process was spawned as a shard by a sharding manager. */ function isShardProcess(env = process.env) {
+/**
+ * Whether a process with `env` was spawned as a shard by a sharding manager. Read before anything builds a
+ * `ShardingManager`, whose constructor writes the variable into its own process too.
+ */ function isShardProcess(env) {
     return env[SHARDING_MANAGER_ENV] !== undefined;
 }
 

package/dist/esm/util/sharding-mode.util.js

@@ -1,6 +1,4 @@
 import { refuse } from './refusal.util.js';
-import { isShardProcess } from './shard-process.util.js';
-export { SHARDING_MANAGER_ENV } from './shard-process.util.js';
 
 /** Whether a shard's manager is gone: the IPC channel it asks a shard to stop through is closed. */ function managerGone(proc = process) {
     return proc.connected === false;
@@ -10,10 +8,10 @@ export { SHARDING_MANAGER_ENV } from './shard-process.util.js';
     return env.NODE_ENV !== 'development' || config.sharding.development === true;
 }
 /**
- * The role of this process: a shard when a manager spawned it, the manager when process sharding is on,
- * and otherwise a single process running every shard it has.
- */ function shardingRole(config, env = process.env) {
-    if (isShardProcess(env)) return 'shard';
+ * The role of this process: a shard when a manager spawned it, as `shard` says, the manager when process sharding is
+ * on, and otherwise a single process running every shard it has.
+ */ function shardingRole(config, shard, env = process.env) {
+    if (shard) return 'shard';
     return processShardingEnabled(config, env) ? 'manager' : 'single';
 }
 /**
@@ -52,4 +50,4 @@ export { SHARDING_MANAGER_ENV } from './shard-process.util.js';
     return clientOptions;
 }
 
-export { clientOptionsWithSharding, isShardProcess, managerGone, processShardingEnabled, shardingRole };
+export { clientOptionsWithSharding, managerGone, processShardingEnabled, shardingRole };

package/dist/esm/util/shared-state.util.js

@@ -0,0 +1,21 @@
+import packageJson from '../package.json.js';
+
+/**
+ * The name of a key the ES module and CommonJS builds of this meocord version share, and no other version has, for
+ * `Symbol.for`: a process that loads both builds of one install keeps one state under it, and two installed versions
+ * keep theirs apart. `Symbol.for(sharedName(...))` written out types as a `unique symbol`.
+ */ const sharedName = (name)=>`meocord@${packageJson.version}:${name}`;
+/** The key named {@link sharedName}. */ function sharedKey(name) {
+    return Symbol.for(sharedName(name));
+}
+/** The state both builds of this version keep on `globalThis` under `name`, made by whichever asks first. */ function shared(name, make) {
+    const key = sharedKey(name);
+    const store = globalThis;
+    if (!Object.hasOwn(store, key)) Object.defineProperty(store, key, {
+        value: make(),
+        configurable: true
+    });
+    return store[key];
+}
+
+export { shared, sharedKey, sharedName };

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

@@ -0,0 +1,29 @@
+import { existsSync } from 'fs';
+import path from 'path';
+import { parseTsconfig, createPathsMatcher } from 'get-tsconfig';
+
+// Stands in for a pattern's `*` while its targets are worked out, then is put back
+const STAR = '__meocord_paths_star__';
+/**
+ * The project's tsconfig `paths`, each target an absolute path, as `tsc` reads them: through `extends`, from `baseUrl`,
+ * and with `${configDir}`. Read with get-tsconfig, whatever TypeScript the project installed. Undefined when there are
+ * none.
+ */ 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;
+    // The matcher resolves each target from the file that declares it, or from baseUrl, as tsc does
+    const match = createPathsMatcher(tsconfig);
+    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)=>[
+            alias,
+            match(alias.replace('*', STAR)).map((target)=>path.resolve(target).replace(STAR, '*'))
+        ]));
+}
+
+export { projectPaths };

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

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, writeFileSync, mkdtempSync, rmSync, readlinkS
 import { tmpdir, hostname } from 'os';
 import { createRequire } from 'module';
 import { parseJsonc } from './json.util.js';
+import { projectPaths } from './tsconfig-paths.util.js';
 
 /**
  * An `extends` made to work from another directory: a relative path made absolute, and a package
@@ -89,10 +90,11 @@ function isRunning(pid) {
 }
 /**
  * Writes a copy of the project's tsconfig.json for the bundler and returns its path: comments and trailing commas
- * removed, paths made absolute (a `paths` target from `baseUrl` when set), `noEmit` dropped. One file per call in this
+ * 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.
  * @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)) {
@@ -109,12 +111,15 @@ function isRunning(pid) {
     // The copy lives in the temp directory, so every path in it is made absolute from the project
     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));
+        if (Array.isArray(parsedConfig?.[key])) {
+            parsedConfig[key] = parsedConfig[key].map((p)=>path.resolve(cwd, p.replaceAll('${configDir}', cwd)));
+        }
     }
     // Process compilerOptions
     if (parsedConfig?.compilerOptions) {
@@ -133,19 +138,14 @@ function isRunning(pid) {
         if (Array.isArray(parsedConfig.compilerOptions.typeRoots)) {
             parsedConfig.compilerOptions.typeRoots = parsedConfig.compilerOptions.typeRoots.map((p)=>path.resolve(cwd, p));
         }
-        // A `paths` target is relative to baseUrl when there is one, made absolute above, and else to the project. Only
-        // this file's own baseUrl counts: one inherited through `extends` isn't applied, so paths are the project's own.
-        if (parsedConfig.compilerOptions.paths) {
-            const base = parsedConfig.compilerOptions.baseUrl ?? cwd;
-            Object.keys(parsedConfig.compilerOptions.paths).forEach((alias)=>{
-                parsedConfig.compilerOptions.paths[alias] = parsedConfig.compilerOptions.paths[alias].map((p)=>path.resolve(base, p));
-            });
-        }
         // Remove `noEmit` option if it exists
         if ('noEmit' in parsedConfig.compilerOptions) {
             delete parsedConfig.compilerOptions.noEmit;
         }
     }
+    // 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));
     return tempTsConfigPath;

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

@@ -8,5 +8,16 @@ import { quoteForLog } from './user-text.util.js';
     return typeof value === 'object' ? 'an object' : `a ${typeof value}`;
 }
 /** 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.
+ */ function setOwn(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    });
+}
 
-export { describeValue, isConstructor, withArticle };
+export { describeValue, isConstructor, setOwn, 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-DEP0NYrU.cjs';
+import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-Dlf0ZZtS.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-DEP0NYrU.cjs';
-export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-C-aMI7Sl.cjs';
-import { T as Translator } from '../translator-B4mc1lzJ.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-B4mc1lzJ.cjs';
-export { T as ThemeCache } from '../theme-resolvers-COHdX5g6.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';
 import '@rsbuild/core';
 import '../controller.enum-DTDn69N9.cjs';
 
@@ -169,7 +169,7 @@ declare class Theme {
  *
  * @group Utilities
  * @see {@link createMetadata}
- * @see {@link https://meocord.dev/docs/4.1/custom-decorators | Custom decorators}
+ * @see {@link https://meocord.dev/docs/4.2/custom-decorators | Custom decorators}
  */
 declare function applyDecorators(...decorators: (ClassDecorator | MethodDecorator)[]): ClassDecorator & MethodDecorator;
 /**
@@ -523,7 +523,7 @@ declare class ShardedCooldownStore extends CooldownStore {
  * @group Utilities
  * @category Localisation
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */
 declare function translateError(error: unknown, t: Translator<any>, target: Interaction | Message | Locale | `${Locale}`): string;
 

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-D7n0FBMm.js';
+import { C as CooldownStore, a as CooldownLimit, b as CooldownVerdict, c as CooldownEntry, d as CooldownBatchVerdict } from '../index-DKJclIi-.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-D7n0FBMm.js';
-export { R as Route, a as RouteParams, b as RouteValue, c as RouteValues, r as route } from '../route-C-aMI7Sl.js';
-import { T as Translator } from '../translator-J6tIUfdp.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-J6tIUfdp.js';
-export { T as ThemeCache } from '../theme-resolvers-DedxyscT.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';
 import '@rsbuild/core';
 import '../controller.enum-DTDn69N9.js';
 
@@ -169,7 +169,7 @@ declare class Theme {
  *
  * @group Utilities
  * @see {@link createMetadata}
- * @see {@link https://meocord.dev/docs/4.1/custom-decorators | Custom decorators}
+ * @see {@link https://meocord.dev/docs/4.2/custom-decorators | Custom decorators}
  */
 declare function applyDecorators(...decorators: (ClassDecorator | MethodDecorator)[]): ClassDecorator & MethodDecorator;
 /**
@@ -523,7 +523,7 @@ declare class ShardedCooldownStore extends CooldownStore {
  * @group Utilities
  * @category Localisation
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */
 declare function translateError(error: unknown, t: Translator<any>, target: Interaction | Message | Locale | `${Locale}`): string;
 

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

@@ -1,5 +1,5 @@
 import { ServiceIdentifier } from 'inversify';
-import { J as MeoCordApplication } from '../index-DEP0NYrU.cjs';
+import { J as MeoCordApplication } from '../index-Dlf0ZZtS.cjs';
 import { MetadataDecorator } from '../common/index.cjs';
 import { MessageScope, MessageCommandOptions, MessageHelp } from '../interface/index.cjs';
 import { RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Message, Client } from 'discord.js';
@@ -44,11 +44,14 @@ declare class MeoCordFactory {
      * @returns The application, which `start()` logs in.
      * @throws Error when the class has no `@MeoCord`, when the compiled config is missing beside the bundle or fails to
      *   load, naming the file and the reason, with what to do about it, when a provider cannot
-     *   be bound, such as one for a token MeoCord binds itself, when two handlers take one command, or two builder
+     *   be bound, such as one for a token MeoCord binds itself (a provider for `ThemeCache` or `ExecutionContext` is warned
+     *   about instead, and refused from the next major version, 5.0), when two handlers take one command, or two builder
      *   classes build one, naming both, and for any other mistake it refuses as the app loads, such as two component
-     *   patterns that match the same customIds. In a built application it is logged first, with where in the source it
-     *   comes from, so `isExplainedError()` tells a caller not to log it again; in a shard of process sharding, the
-     *   manager logs it.
+     *   patterns that match the same customIds. Each check reports every error it finds, and the first is thrown,
+     *   unchanged. When there are several, each is logged first, with where in the source it comes from; a lone one is
+     *   logged in a built application. Either way `isExplainedError()` then tells a caller not to log it again; in a
+     *   shard of process sharding, the manager logs it. With `startupErrors: 'all'` in `meocord.config.ts`, the errors
+     *   decorators kept are among them.
      */
     static create(target: ServiceIdentifier): MeoCordApplication;
     private static createApplication;
@@ -260,7 +263,7 @@ interface HandlerFilter<K extends HandlerKind = HandlerKind> {
  *
  * @group Controllers
  * @see {@link HandlerEntry}
- * @see {@link https://meocord.dev/docs/4.1/handler-discovery | Handler discovery}
+ * @see {@link https://meocord.dev/docs/4.2/handler-discovery | Handler discovery}
  */
 declare class HandlerRegistry {
     private readonly classes;
@@ -416,7 +419,7 @@ type MethodResult<T, M extends keyof T> = T[M] extends (...args: any[]) => infer
  *
  * @group Controllers
  * @see {@link ShardCallResult}
- * @see {@link https://meocord.dev/docs/4.1/sharding | Sharding}
+ * @see {@link https://meocord.dev/docs/4.2/sharding | Sharding}
  */
 declare class ShardContext {
     private readonly client;

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

@@ -1,5 +1,5 @@
 import { ServiceIdentifier } from 'inversify';
-import { J as MeoCordApplication } from '../index-D7n0FBMm.js';
+import { J as MeoCordApplication } from '../index-DKJclIi-.js';
 import { MetadataDecorator } from '../common/index.js';
 import { MessageScope, MessageCommandOptions, MessageHelp } from '../interface/index.js';
 import { RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Message, Client } from 'discord.js';
@@ -44,11 +44,14 @@ declare class MeoCordFactory {
      * @returns The application, which `start()` logs in.
      * @throws Error when the class has no `@MeoCord`, when the compiled config is missing beside the bundle or fails to
      *   load, naming the file and the reason, with what to do about it, when a provider cannot
-     *   be bound, such as one for a token MeoCord binds itself, when two handlers take one command, or two builder
+     *   be bound, such as one for a token MeoCord binds itself (a provider for `ThemeCache` or `ExecutionContext` is warned
+     *   about instead, and refused from the next major version, 5.0), when two handlers take one command, or two builder
      *   classes build one, naming both, and for any other mistake it refuses as the app loads, such as two component
-     *   patterns that match the same customIds. In a built application it is logged first, with where in the source it
-     *   comes from, so `isExplainedError()` tells a caller not to log it again; in a shard of process sharding, the
-     *   manager logs it.
+     *   patterns that match the same customIds. Each check reports every error it finds, and the first is thrown,
+     *   unchanged. When there are several, each is logged first, with where in the source it comes from; a lone one is
+     *   logged in a built application. Either way `isExplainedError()` then tells a caller not to log it again; in a
+     *   shard of process sharding, the manager logs it. With `startupErrors: 'all'` in `meocord.config.ts`, the errors
+     *   decorators kept are among them.
      */
     static create(target: ServiceIdentifier): MeoCordApplication;
     private static createApplication;
@@ -260,7 +263,7 @@ interface HandlerFilter<K extends HandlerKind = HandlerKind> {
  *
  * @group Controllers
  * @see {@link HandlerEntry}
- * @see {@link https://meocord.dev/docs/4.1/handler-discovery | Handler discovery}
+ * @see {@link https://meocord.dev/docs/4.2/handler-discovery | Handler discovery}
  */
 declare class HandlerRegistry {
     private readonly classes;
@@ -416,7 +419,7 @@ type MethodResult<T, M extends keyof T> = T[M] extends (...args: any[]) => infer
  *
  * @group Controllers
  * @see {@link ShardCallResult}
- * @see {@link https://meocord.dev/docs/4.1/sharding | Sharding}
+ * @see {@link https://meocord.dev/docs/4.2/sharding | Sharding}
  */
 declare class ShardContext {
     private readonly client;