meocord 4.1.2 → 4.2.1

package/dist/esm/testing/response.js

@@ -42,7 +42,7 @@ const VISIBLE = new Set([
  * @group Testing
  * @category Inspection
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */ function getResponse(interaction) {
     const state = existingResponse(interaction);
     // A mock records every answer it gets; respond()'s edits through the channel are its own, so they are merged in

package/dist/esm/testing/routing.js

@@ -1,4 +1,4 @@
-import { findComponentRouteConflicts, buildComponentRoutes, matchComponentRoute } from '../core/component-routes.js';
+import { findComponentRouteConflicts, buildComponentRoutes, matchComponentRoute, readCustomId } from '../core/component-routes.js';
 import { isCustomIdRouted } from '../util/interaction.util.js';
 import { staticMessageStarts, matchMessageRoute, buildMessageRoutes, fitsScope } from '../core/message-routes.js';
 import { needsGuild } from '../core/message-params.js';
@@ -47,7 +47,7 @@ import { META } from '../util/metadata-keys.js';
  * @group Testing
  * @category Inspection
  * @see {@link findRouteConflicts}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function resolveRoute(app, input) {
     if ('content' in input) {
         const { messages = {} } = appOptionsOf(app);
@@ -73,7 +73,10 @@ import { META } from '../util/metadata-keys.js';
     const { route, params, text } = matched;
     const method = route.meta.methodName;
     const typed = Object.keys(route.types).length > 0;
-    return {
+    // The routes ranked behind it that the customId matches too, which dispatch never reaches for it
+    const behind = routes.slice(routes.indexOf(route) + 1);
+    const alsoMatches = behind.filter((other)=>other.meta.type === input.type && readCustomId(other.pattern, other.meta.regex, input.customId)).map((other)=>other.pattern);
+    const resolved = {
         controller: route.controllerClass,
         method,
         handler: route.controllerClass.prototype[method],
@@ -82,28 +85,34 @@ import { META } from '../util/metadata-keys.js';
             values: params
         }
     };
+    return alsoMatches.length > 0 ? readableOnly(resolved, {
+        alsoMatches
+    }) : resolved;
 }
 /**
- * Finds component patterns that can match the same `customId`, which MeoCord otherwise only warns about at startup.
+ * Finds component patterns that rank equally and can match the same `customId`, which MeoCord otherwise only warns
+ * about at startup.
  *
- * Use it in a test to keep the warning from reaching production: two patterns that trade a literal for a parameter
- * in opposite places both take one id, and neither is more specific. Patterns are compared within a component type.
+ * Use it in a test to keep the warning from reaching production. Patterns rank segment by segment, a literal before a
+ * param and then the narrower type, so two collide only with the same literals and equally narrow params at each
+ * position, such as `{action:close|reopen}` and `{step:close|confirm}`, which both take `close`; the one listed
+ * first runs. Patterns are compared within a component type.
  *
  * @param app - The application class decorated with `@MeoCord`.
- * @returns Each pair of patterns that can match the same `customId`, with its component type.
+ * @returns Each pair of patterns that rank equally and can match the same `customId`, with its component type.
  *
  * @example
  * ```ts
  * import { expect } from 'vitest'
  *
  * @Controller()
- * class CardController {
- *   @Command('card/{id}/open', CommandType.BUTTON)
- *   async open(interaction: ButtonInteraction) { await respond(interaction).send('Opened.') }
- *   @Command('card/new/{kind}', CommandType.BUTTON)
- *   async create(interaction: ButtonInteraction) { await respond(interaction).send('Created.') }
+ * class TicketController {
+ *   @Command('ticket/{action:close|reopen}', CommandType.BUTTON)
+ *   async act(interaction: ButtonInteraction) { await respond(interaction).send('Done.') }
+ *   @Command('ticket/{step:close|confirm}', CommandType.BUTTON)
+ *   async step(interaction: ButtonInteraction) { await respond(interaction).send('Next.') }
  * }
- * @MeoCord({ controllers: [CardController], clientOptions: { intents: [] } })
+ * @MeoCord({ controllers: [TicketController], clientOptions: { intents: [] } })
  * class App {}
  * expect(findRouteConflicts(App)).toHaveLength(1)
  * ```
@@ -112,7 +121,23 @@ import { META } from '../util/metadata-keys.js';
  * @category Inspection
  * @see {@link resolveRoute}
  */ function findRouteConflicts(app) {
-    return findComponentRouteConflicts(buildComponentRoutes(controllersOf(app)));
+    return findComponentRouteConflicts(buildComponentRoutes(controllersOf(app))).map(({ type, patterns, runs })=>readableOnly({
+            type: type,
+            patterns
+        }, {
+            runs
+        }));
+}
+/**
+ * `target` with `fields` added as properties a test reads but `toEqual` and its kin, which compare enumerable keys,
+ * don't see, so an assertion written for the fields it had before still holds.
+ */ function readableOnly(target, fields) {
+    for (const [key, value] of Object.entries(fields))Object.defineProperty(target, key, {
+        value,
+        enumerable: false,
+        configurable: true
+    });
+    return target;
 }
 
 export { findRouteConflicts, resolveRoute };

package/dist/esm/testing/snowflake.js

@@ -1,8 +1,15 @@
+import { shared } from '../util/shared-state.util.js';
+
 /**
  * The id of the bot every mock client is logged in as, so a test can mention it. Fixed, and below the
  * ids other mocks take, so it is the same on every run and in any test order, and no mock shares it.
  */ const MOCK_BOT_ID = '1300000000000000000';
-/** The last id a mock was given; ids count up from a real snowflake, so each mock's is its own. */ let lastSnowflake = 1400000000000000000n;
-/** A snowflake-shaped id nothing else a mock holds in this run has, for a mock or the media it resolves. */ const nextSnowflake = ()=>String(++lastSnowflake);
+/**
+ * The last id a mock was given, for both builds of this meocord version; ids count up from a real snowflake, so each
+ * mock's is its own.
+ */ const ids = shared('mockIds', ()=>({
+        last: 1400000000000000000n
+    }));
+/** A snowflake-shaped id nothing else a mock holds in this run has, for a mock or the media it resolves. */ const nextSnowflake = ()=>String(++ids.last);
 
 export { MOCK_BOT_ID, nextSnowflake };

package/dist/esm/testing/startup-errors.js

@@ -0,0 +1,26 @@
+import { setStartupErrorsMode } from '../util/refusal.util.js';
+
+/**
+ * Has decorators keep the startup errors they find, as a bot built with `startupErrors: 'all'` does, so a testing
+ * module reports every one at once.
+ *
+ * Call it once in the test runner's setup file, before any test imports a controller: a decorator runs when its class
+ * is defined, as its file is imported. A decorator given what it cannot use then throws nothing as the file loads, and
+ * `MeoCordTestingModule.create(...).compile()` logs every startup error of the classes it runs, each with its handler
+ * and file, then throws the first. Without it, a decorator throws its error as its class is defined.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * reportAllStartupErrors()
+ * ```
+ *
+ * @group Testing
+ * @category Module
+ * @see {@link MeoCordTestingModule}
+ * @see {@link https://meocord.dev/docs/4.2/configuration | Configuration}
+ */ function reportAllStartupErrors() {
+    setStartupErrorsMode('all');
+}
+
+export { reportAllStartupErrors };

package/dist/esm/testing/strict-mocks.js

@@ -0,0 +1,65 @@
+import { shared } from '../util/shared-state.util.js';
+
+// Whether useStrictMocks() is on, and whether a mock was made before it could be, for both builds of this version
+const settings = shared('strictMocks', ()=>({
+        strict: false,
+        mockMade: false
+    }));
+/** Whether mocks compute discord.js's state, as {@link useStrictMocks} turns on. */ const strictMocks = ()=>settings.strict;
+/** Notes that a mock was made, which useStrictMocks() must come before. */ function noteMockMade() {
+    settings.mockMade = true;
+}
+/**
+ * Has every mock from `meocord/testing` compute the values discord.js computes, where it reads a placeholder otherwise.
+ *
+ * Call it once in the test runner's setup file. A message's `editable`, `deletable`, `pinnable`, `crosspostable`,
+ * `bulkDeletable`, `hasThread` and `partial`, a member's `manageable`, `kickable`, `bannable` and `moderatable`, a
+ * role's `editable`, a channel's and a thread's `viewable`, `manageable`, `deletable`, `joinable` and the rest, a voice
+ * channel's `full`, and `partial` on users, channels and reactions then run discord.js's own getters against the mock,
+ * and `message.thread` is `null` when the channel caches no thread under the message's id. So do a message's
+ * `editedAt`, a member's `presence`, a server's `verified` and `systemChannel` and a channel's `parent`, each `null` or
+ * `false` until the test gives what it is computed from. A reaction's `me` is `false`, a message's
+ * `mentions.repliedUser` and a modal's `message` are `null`, and a reaction has a whole message of its own, so
+ * MeoCord's dispatcher fetches neither. No placeholder warning is logged.
+ *
+ * @remarks
+ * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in the
+ * server's member cache from the start, @everyone has the permissions Discord gives it in a new server, and a channel
+ * or thread made without a server has one of its own, a thread with a text channel as its parent. A message has empty
+ * `content`, a thread is neither archived nor locked, and a reaction's `count` is 1. A user, server or channel made
+ * with a generated id was created when the mock was made, as a message is. An interaction's `memberPermissions` apply
+ * its channel's overwrites, a thread's parent's for a thread, to its member's permissions. An interaction is in its
+ * message's channel and server, a guild's or a member's server, or, given a `guildId` alone, a server the bot isn't in.
+ * A message the bot sends is its `client.user`'s, and one it sends in a DM is in that DM. Give the bot's member a role
+ * to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the computed
+ * one. An interaction's answer that discord.js would refuse, such as a second `reply()` after one a test set with
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. The next major version (5.0)
+ * computes these values, and refuses those answers, without the call.
+ *
+ * `invoke` also refuses a call that gives a handler fewer arguments than it declares where it builds none, such as a
+ * reaction handler given its reaction without its `ReactionEvent`; without strict mocks, it warns once and calls it.
+ *
+ * `compile()` also refuses an `overrideGuard`, `overrideInterceptor` or `overrideFilter` stub without the stage's
+ * method, `canActivate`, `intercept` or `catch`; without strict mocks, it warns and builds the module.
+ *
+ * @throws Error when a mock already exists, which was made without it.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * useStrictMocks()
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link useMockFn}
+ * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
+ */ function useStrictMocks() {
+    if (settings.strict) return;
+    if (settings.mockMade) {
+        throw new Error('useStrictMocks() goes before any mock is made: a mock made before it reads placeholders, and the two kinds would ' + "mix. Call it once, in the test runner's setup file.");
+    }
+    settings.strict = true;
+}
+
+export { noteMockMade, strictMocks, useStrictMocks };

package/dist/esm/testing/theme.js

@@ -35,7 +35,7 @@ function mockTheme(overrides, where) {
  * @group Testing
  * @category Mocks
  * @see {@link withTheme}
- * @see {@link https://meocord.dev/docs/4.1/theming | Theming}
+ * @see {@link https://meocord.dev/docs/4.2/theming | Theming}
  */ function createMockTheme(...[overrides]) {
     return mockTheme(overrides, 'createMockTheme');
 }

package/dist/esm/util/bundle-entry.util.js

@@ -2,6 +2,7 @@ import { existsSync, realpathSync } from 'node:fs';
 
 /** Where the built bundle's pre-entry records the bundle's own path. */ const BUNDLE_ENTRY_KEY = Symbol.for('meocord.bundleEntry');
 /** Where the built bundle's pre-entry records the mode the bundle was built in. */ const BUILD_MODE_KEY = Symbol.for('meocord.buildMode');
+/** Where the built bot's pre-entry records `startupErrors` from its config, before the application's modules load. */ const STARTUP_ERRORS_KEY = Symbol.for('meocord.startupErrorsMode');
 /**
  * The file a shard process runs: the built bundle, as its pre-entry recorded it, else the script this
  * process was started with; undefined when there is none, as for code run with `node -e` outside a built bundle.
@@ -19,4 +20,4 @@ import { existsSync, realpathSync } from 'node:fs';
     return typeof recorded === 'string' ? recorded : undefined;
 }
 
-export { BUILD_MODE_KEY, BUNDLE_ENTRY_KEY, buildMode, bundleEntry, isBuiltApplication };
+export { BUILD_MODE_KEY, BUNDLE_ENTRY_KEY, STARTUP_ERRORS_KEY, buildMode, bundleEntry, isBuiltApplication };

package/dist/esm/util/common.util.js

@@ -19,28 +19,48 @@ import chalk from 'chalk';
     console.error(chalk.red(`Error finding package directory for ${moduleName}: Module ${moduleName} not found in node_modules.`));
     return null;
 };
+/**
+ * Loads `meocord.config.ts` and checks its shape, as a command that builds and a watch-mode reload both do, printing
+ * the warnings for options it does not know.
+ *
+ * @returns The config, or the report of why it cannot be used: missing, failing to load, or with options of the wrong
+ *   type, each of them listed. A config that fails to load also gives the reason alone, as `loadError`.
+ */ function checkSourceConfig() {
+    const meocordConfigPath = path.resolve(process.cwd(), 'meocord.config.ts');
+    if (!fs.existsSync(meocordConfigPath)) return {
+        problem: 'Configuration file "meocord.config.ts" is missing!'
+    };
+    const loaded = readMeoCordSourceConfig();
+    if ('error' in loaded) {
+        return {
+            problem: `meocord.config.ts could not be loaded, so nothing was built or started:\n  ${loaded.error}`,
+            loadError: loaded.error
+        };
+    }
+    const problem = shapeProblem(loaded.config);
+    return problem ? {
+        problem
+    } : {
+        config: loaded.config
+    };
+}
+/** Prints why a config cannot be used, as {@link checkSourceConfig} reports it. */ function reportConfigProblem(problem) {
+    console.error(chalk.red(problem));
+}
 /**
  * Loads `meocord.config.ts` and checks its shape, exiting when it is missing, fails to load, or has
  * options of the wrong type; options it does not know are reported and left alone.
  *
  * @returns The config, which a build compiles and the bot then runs with.
  */ async function compileAndValidateConfig() {
-    const meocordConfigPath = path.resolve(process.cwd(), 'meocord.config.ts');
-    if (!fs.existsSync(meocordConfigPath)) {
-        console.error(chalk.red('Configuration file "meocord.config.ts" is missing!'));
+    const checked = checkSourceConfig();
+    if ('problem' in checked) {
+        reportConfigProblem(checked.problem);
         await wait(100);
         process.exit(1);
         return;
     }
-    const loaded = readMeoCordSourceConfig();
-    if ('error' in loaded) {
-        console.error(chalk.red(`meocord.config.ts could not be loaded, so nothing was built or started:\n  ${loaded.error}`));
-        await wait(100);
-        process.exit(1);
-        return;
-    }
-    await assertConfigShape(loaded.config);
-    return loaded.config;
+    return checked.config;
 }
 /**
  * Checks the configuration a command that skips the build runs with: the compiled config when a build
@@ -63,13 +83,18 @@ import chalk from 'chalk';
     return compileAndValidateConfig();
 }
 /** Exits with every problem when a configuration has options of the wrong type, and warns about unknown ones. */ async function assertConfigShape(config) {
-    const { errors, warnings } = configProblems(config);
-    for (const warning of warnings)console.warn(chalk.yellow(`meocord.config.ts: ${warning}`));
-    if (errors.length === 0) return;
-    console.error(chalk.red(`meocord.config.ts has ${errors.length} problem(s):\n${errors.map((error)=>`  - ${error}`).join('\n')}`));
+    const problem = shapeProblem(config);
+    if (!problem) return;
+    console.error(chalk.red(problem));
     await wait(100);
     process.exit(1);
 }
+/** Every option of the wrong type in a configuration, as one report, or undefined; options it does not know are warned about. */ function shapeProblem(config) {
+    const { errors, warnings } = configProblems(config);
+    for (const warning of warnings)console.warn(chalk.yellow(`meocord.config.ts: ${warning}`));
+    if (errors.length === 0) return undefined;
+    return `meocord.config.ts has ${errors.length} problem(s):\n${errors.map((error)=>`  - ${error}`).join('\n')}`;
+}
 /**
  * Exits unless the config {@link compileAndValidateConfig} or {@link validateRunConfig} returned has a Discord token.
  * Starting or registering needs one and building does not, so a new app builds before it has a token.
@@ -80,10 +105,13 @@ import chalk from 'chalk';
         process.exit(1);
     }
 }
-/** Sets `NODE_ENV` to `mode` unless it is already set. */ function setEnvironment(mode) {
-    if (!process.env.NODE_ENV) {
+/**
+ * Sets `NODE_ENV` for a command run in `mode`, before its config loads: development whatever the shell holds, so `--dev`
+ * reads the development files and registers as development, and production unless the shell set a mode of its own.
+ */ function setEnvironment(mode) {
+    if (mode === 'development' || !process.env.NODE_ENV) {
         process.env.NODE_ENV = mode;
     }
 }
 
-export { assertConfigShape, compileAndValidateConfig, findModulePackageDir, setEnvironment, validateDiscordToken, validateRunConfig };
+export { assertConfigShape, checkSourceConfig, compileAndValidateConfig, findModulePackageDir, reportConfigProblem, setEnvironment, validateDiscordToken, validateRunConfig };

package/dist/esm/util/dev-runner.util.js

@@ -19,8 +19,8 @@ const slots = globalThis;
  * on Windows a signal ends a process outright, skipping its `onShutdown` hooks. The bundle's pre-entry calls it first,
  * so a stop is heard however early it comes; until an app or shard manager says how it stops, the process exits at
  * once, as SIGTERM's default would.
- */ function listenForDevRunnerStop() {
-    if (!underDevRunner() || slots[LISTENING]) return;
+ */ function listenForDevRunnerStop(shard = isShardProcess(process.env)) {
+    if (!underDevRunner(shard) || slots[LISTENING]) return;
     slots[LISTENING] = true;
     process.on('message', (message)=>{
         if (!isDevRunnerCommand(message)) return;
@@ -31,19 +31,19 @@ const slots = globalThis;
     // A 'message' listener keeps the process alive for its channel; what the bot does decides that, as without one
     process.channel?.unref();
 }
-/** Has a stop from `meocord start --dev` run `stop`, as SIGINT and SIGTERM do. */ function onDevRunnerStop(stop) {
-    listenForDevRunnerStop();
+/** Has a stop from `meocord start --dev` run `stop`, as SIGINT and SIGTERM do, in a process whose role is `shard`. */ function onDevRunnerStop(stop, shard) {
+    listenForDevRunnerStop(shard);
     slots[STOP] = stop;
 }
-/** Whether `meocord start --dev` runs this process and listens on its channel. */ function underDevRunner() {
-    return process.env[DEV_RUNNER_ENV] === '1' && !!process.send && !isShardProcess();
+/** Whether `meocord start --dev` runs this process, a shard or not as `shard` says, and listens on its channel. */ function underDevRunner(shard) {
+    return process.env[DEV_RUNNER_ENV] === '1' && !!process.send && !shard;
 }
 /**
  * Tells `meocord start --dev`, when it runs this process, whether the bot could log in, and waits until it is sent, or
  * until the dev runner is taken to be gone. A caller sets the exit code before sending, so it holds however the send
  * ends. A shard tells its manager instead, which tells the dev runner in turn.
- */ async function tellDevRunner(message) {
-    if (underDevRunner()) await sendToParent(message);
+ */ async function tellDevRunner(message, shard) {
+    if (underDevRunner(shard)) await sendToParent(message);
 }
 
 export { DEV_RUNNER_ENV, isDevRunnerCommand, isDevRunnerMessage, listenForDevRunnerStop, onDevRunnerStop, tellDevRunner, underDevRunner };

package/dist/esm/util/generator-cli.util.js

@@ -7,16 +7,15 @@ import '../core/theme-validation.js';
 import '../common/decorator.js';
 import 'reflect-metadata';
 import 'discord.js';
-import '../common/translator.js';
-import '../common/response/send-failure.js';
-import './interaction.util.js';
-import '../common/response/flags.js';
-import '../common/response/components.js';
+import '../common/response/response-state.js';
+import '../common/errors.js';
 import 'node:crypto';
 import '../decorator/controller.decorator.js';
 import '../core/scalar-types.js';
 import 'node:fs';
 import 'node:url';
+import '../common/translator.js';
+import '../common/meocord-text.js';
 import { kebabCase, startCase, camelCase } from 'lodash-es';
 import { fileURLToPath } from 'url';
 

package/dist/esm/util/interaction.util.js

@@ -1,7 +1,7 @@
-import { ApplicationCommandOptionType, ModalSubmitInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, RoleSelectMenuInteraction, UserSelectMenuInteraction, StringSelectMenuInteraction, ButtonInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, ChatInputCommandInteraction, MessageComponentInteraction } from 'discord.js';
+import { ApplicationCommandOptionType, MessageComponentInteraction, ModalSubmitInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, RoleSelectMenuInteraction, UserSelectMenuInteraction, StringSelectMenuInteraction, ButtonInteraction, PrimaryEntryPointCommandInteraction, ContextMenuCommandInteraction, ChatInputCommandInteraction } from 'discord.js';
 import { CommandType } from '../enum/controller.enum.js';
 import { quoteForLog } from './user-text.util.js';
-import { withArticle } from './value.util.js';
+import { setOwn, withArticle } from './value.util.js';
 
 /**
  * The discord.js interaction class each command type handles, shared by `@Command`, the dispatcher and the testing
@@ -99,7 +99,7 @@ import { withArticle } from './value.util.js';
                 walk(option.options ?? []);
                 continue;
             }
-            params[option.name] = resolveOptionValue(option);
+            setOwn(params, option.name, resolveOptionValue(option));
         }
     };
     walk(data);

package/dist/esm/util/meocord-config-loader.util.js

@@ -38,12 +38,20 @@ let problem;
         const reason = (problem.error instanceof Error ? problem.error.message : String(problem.error)).replace(/\.$/, '');
         const missing = missingPackage(problem.error);
         const neededBy = missing?.importer ? `, which ${missing.importer} imports,` : '';
-        const fix = missing ? `Install ${missing.name}${neededBy} in the project` : 'Fix meocord.config.ts';
-        return `MeoCord config at ${problem.path} failed to load: ${reason}. ${fix}, then run \`meocord build\`.`;
+        const fix = missing ? `Install ${missing.name}${neededBy} in the project, then run \`meocord build\`.` : fixedInConfig(problem.error) ? 'Fix meocord.config.ts, then run `meocord build`.' : 'It threw as it loaded: check the environment it reads, such as its .env files.';
+        return `MeoCord config at ${problem.path} failed to load: ${reason}. ${fix}`;
     }
     const where = problem?.path ?? 'meocord.config.mjs';
     return `MeoCord config not found at ${where} (working directory ${process.cwd()}). Run \`meocord build\`, and start the bot from the dist it writes.`;
 }
+/**
+ * Whether the config's file or imports are at fault, which a rebuild after fixing it mends: it could not be read as a
+ * module, or imports a file that isn't there. Otherwise its code threw as it ran.
+ */ function fixedInConfig(error) {
+    const code = error?.code;
+    if (error instanceof SyntaxError || code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true;
+    return typeof code === 'string' && code.startsWith('ERR_REQUIRE_');
+}
 /**
  * The package a module-not-found error names, when it is a package rather than a file: `dotenv` for `dotenv/config`,
  * `@scope/name` for `@scope/name/sub`, with the installed package that imports it, if one does. Undefined for any other

package/dist/esm/util/meocord-config-validation.util.js

@@ -46,6 +46,7 @@ const oneOf = (...allowed)=>(value, key)=>allowed.includes(value) ? undefined :
         optionalExternals: optional(stringList('package names')),
         rsbuild: optional(func),
         sourceMappedStacks: optional(boolean),
+        startupErrors: optional(oneOf('first', 'all')),
         shutdownTimeout: optional((value, key)=>{
             const problem = shutdownTimeoutProblem(value);
             return problem && `${key} ${problem}`;
@@ -65,14 +66,12 @@ const oneOf = (...allowed)=>(value, key)=>allowed.includes(value) ? undefined :
         errors: [],
         warnings: []
     };
-    // jiti's interop proxy lists only `default` among its keys, while reading through to it.
-    const loaded = config?.default ?? config;
-    if (typeof loaded !== 'object' || loaded === null) {
-        problems.errors.push(`it must export an object as its default export (got ${describe(loaded)})`);
+    if (typeof config !== 'object' || config === null) {
+        problems.errors.push(`it must export an object as its default export (got ${describe(config)})`);
         return problems;
     }
     const shape = configShape(problems);
-    for (const [name, value] of Object.entries(loaded)){
+    for (const [name, value] of Object.entries(config)){
         const check = shape[name];
         if (!check) {
             problems.warnings.push(`${name} is not a MeoCord option, so it has no effect.`);

package/dist/esm/util/meocord-source-config.util.js

@@ -1,7 +1,8 @@
 import path from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync } from 'fs';
 import { createJiti } from 'jiti';
-import { parseJsonc } from './json.util.js';
+import { comparablePath, framePath } from './source-path.util.js';
+import { projectPaths } from './tsconfig-paths.util.js';
 
 /**
  * Loads `meocord.config.ts` from source on every call, so a build always uses the current config
@@ -25,31 +26,75 @@ import { parseJsonc } from './json.util.js';
         config: undefined
     };
     try {
-        const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
-        const aliases = {};
-        if (existsSync(tsConfigPath)) {
-            const tsConfig = parseJsonc(readFileSync(tsConfigPath, 'utf-8'));
-            const paths = tsConfig?.compilerOptions?.paths;
-            if (paths) {
-                for (const [key, values] of Object.entries(paths)){
-                    const aliasKey = key.replace('/*', '');
-                    aliases[aliasKey] = path.resolve(process.cwd(), values[0].replace('/*', ''));
-                }
-            }
-        }
+        const aliases = jitiAliases(projectPaths() ?? {});
+        // The module as written, so an ES module with no default export is told apart from a CommonJS one
         const jiti = createJiti(import.meta.url, {
-            interopDefault: true,
+            interopDefault: false,
             alias: aliases,
             moduleCache: false
         });
-        return {
-            config: jiti(configPath)
-        };
+        return configOf(jiti(configPath));
     } catch (error) {
         return {
-            error: error instanceof Error ? error.message : String(error)
+            error: loadError(error, process.cwd())
         };
     }
 }
+/**
+ * The config a loaded module gives: an ES module's default export, or what a CommonJS module assigns to
+ * `module.exports`. An ES module with no default export has none.
+ */ function configOf(loaded) {
+    const module = loaded;
+    if (module?.__esModule !== true) return {
+        config: loaded
+    };
+    if ('default' in module) return {
+        config: module.default
+    };
+    // A module that exports nothing, as an empty file, is an empty config, whose values come from the environment
+    const names = Object.keys(module);
+    if (names.length === 0) return {
+        config: {}
+    };
+    return {
+        error: `it must export an object as its default export, and exports only ${names.join(', ')}`
+    };
+}
+/**
+ * Why the config failed to load, with the first place in the project it failed at when the message does not name one,
+ * as for an error the config throws: jiti's message names the file, line and column of a syntax error.
+ */ function loadError(error, root) {
+    const message = error instanceof Error ? error.message : String(error);
+    const frame = error instanceof Error ? projectFrame(error.stack, root) : undefined;
+    return frame && !message.includes(frame) ? `${message}\n    at ${frame}` : message;
+}
+// A stack frame's location, `file:line:column`, alone or in parentheses after the function: a path or a file:// URL
+const FRAME_LOCATION = /\(?((?:file:\/\/)?(?:\/?[A-Za-z]:)?[\\/][^()]+?):(\d+):(\d+)\)?$/;
+/**
+ * The first stack frame in a file of the project's own, as `file:line:column` from the project. On Windows a frame's
+ * file can be a file:// URL, or written with forward slashes or a lower-case drive, so each is compared as a path.
+ */ function projectFrame(stack, root, windows = process.platform === 'win32') {
+    const paths = windows ? path.win32 : path.posix;
+    const base = comparablePath(paths.join(paths.resolve(root), paths.sep), windows);
+    for (const line of stack?.split('\n').slice(1) ?? []){
+        const frame = FRAME_LOCATION.exec(line.trim());
+        if (!frame) continue;
+        const [, location, row, column] = frame;
+        const file = paths.resolve(framePath(location, windows));
+        if (!comparablePath(file, windows).startsWith(base) || file.split(paths.sep).includes('node_modules')) continue;
+        return `${paths.relative(root, file).split(paths.sep).join('/')}:${row}:${column}`;
+    }
+    return undefined;
+}
+/**
+ * jiti's aliases for tsconfig `paths`: each alias, and its first target, without a trailing `/*`, or `\*` in a Windows
+ * path, as the build reads the same paths.
+ */ function jitiAliases(paths) {
+    const unstarred = (text)=>text.replace(/[\\/]\*$/, '');
+    return Object.fromEntries(Object.entries(paths).map(([alias, [target]])=>[
+            unstarred(alias),
+            unstarred(target)
+        ]));
+}
 
-export { loadMeoCordSourceConfig, readMeoCordSourceConfig };
+export { jitiAliases, loadMeoCordSourceConfig, projectFrame, readMeoCordSourceConfig };

package/dist/esm/util/metadata-keys.js

@@ -24,6 +24,7 @@ import { MetadataKey } from '../enum/metadata-key.enum.js';
     /** How many guard wrappers `@UseGuard` and `@Controller` put around one method. */ guardWrappers: 'meocord:guard-wrappers',
     /** The prototype whose method a class-level `@UseGuard` re-declared on a subclass. */ inheritedFrom: 'meocord:inherited-from',
     /** `false` when `@Controller({ inheritStages: false })` stops class stages at this class. */ inheritStages: 'meocord:inherit-stages',
+    /** `true` when `@Controller({ inheritedRoutes: 'replace' })` drops the routes this class's re-decorated methods inherit. */ replacesInheritedRoutes: 'meocord:replaces-inherited-routes',
     /** A controller's class-level `@Cooldown`s. */ classCooldowns: 'meocord:class-cooldowns',
     /** A method's `@Cooldown`s, in declaration order. */ methodCooldowns: 'meocord:method-cooldowns',
     /** The error types a filter's `@Catch` names; empty to catch everything. */ catchTypes: 'meocord:catch-types',

package/dist/esm/util/method-wrapper.util.js

@@ -0,0 +1,16 @@
+/**
+ * Gives a decorator's `wrapper` the `length` and `name` of the method it replaces, so whatever reads the handler, such
+ * as `invoke` counting the arguments it takes, sees the method as it was declared.
+ */ function wrapsMethod(wrapper, original) {
+    Object.defineProperty(wrapper, 'length', {
+        value: original.length,
+        configurable: true
+    });
+    Object.defineProperty(wrapper, 'name', {
+        value: original.name,
+        configurable: true
+    });
+    return wrapper;
+}
+
+export { wrapsMethod };