meocord 4.2.1 → 4.2.3

package/dist/esm/testing/response-log.js

@@ -0,0 +1,8 @@
+import { sharedName } from '../util/shared-state.util.js';
+
+/**
+ * Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order, under a key
+ * both builds of this meocord version read.
+ */ const RESPONSE_LOG = Symbol.for(sharedName('responseLog'));
+
+export { RESPONSE_LOG };

package/dist/esm/testing/response.js

@@ -1,7 +1,7 @@
 import { DiscordAPIError } from 'discord.js';
 import { existingResponse } from '../common/response/response-state.js';
 import { callOrder } from '../common/response/call-order.js';
-import { RESPONSE_LOG } from './mock-interaction.js';
+import { RESPONSE_LOG } from './response-log.js';
 
 const VISIBLE = new Set([
     'reply',
@@ -14,9 +14,10 @@ const VISIBLE = new Set([
  * Reports how an interaction was answered: where its answer stands, and every answer call it got, in order.
  *
  * Use it after `invoke` or `dispatch` to check what the member sees. A mock interaction records each `reply`,
- * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, whether the handler
- * made it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a
- * reaction, read the mock's own methods.
+ * `deferReply`, `editReply`, `followUp`, `deleteReply`, `update`, `deferUpdate` and `showModal`, and under
+ * `useStrictMocks()` each `launchActivity`, `sendPremiumRequired` and autocomplete `respond` too, whether the handler made
+ * it through `respond()` or with discord.js directly, so both are reported, each once. For a message or a reaction, read
+ * the mock's own methods.
  *
  * @param interaction - The interaction a handler answered.
  * @returns The state, whether anything the member can see was sent, and the calls, in order.
@@ -61,7 +62,8 @@ const VISIBLE = new Set([
         sent,
         calls: calls
     };
-    const answered = interaction.isRepliable() ? interaction.replied : false;
+    // An autocomplete's choices are its answer, as observers read it, where its mock records them, under strict mocks
+    const answered = interaction.isRepliable() ? interaction.replied : Boolean(log) && interaction.isAutocomplete() && interaction.responded;
     const deferred = interaction.isRepliable() ? interaction.deferred : false;
     return {
         state: answered ? 'replied' : deferred ? 'deferred' : 'unanswered',

package/dist/esm/testing/routing.js

@@ -1,10 +1,30 @@
 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';
+import { staticMessageStarts, buildMessageRoutes, matchMessageRoute, fitsScope } from '../core/message-routes.js';
+import { takesGuildParam, needsGuild, isGuildType } from '../core/message-params.js';
+import { warnOnce } from '../common/deprecation.js';
+import { Logger } from '../common/logger.js';
+import { strictMocks } from './strict-mocks.js';
 import { META } from '../util/metadata-keys.js';
+import { describeValue } from '../util/value.util.js';
 
+const logger = new Logger('resolveRoute');
+/** Why an app import reads `undefined`, for its refusal. */ const CIRCULAR_IMPORT_HINT = ' An app import that reads undefined is often a circular import.';
+/** Why an app is an object, for its refusal. */ const MODULE_HINT = ' An object here is often a module namespace, as `import * as App` gives: pass the class it exports.';
+/** An app that isn't a class, as its refusal names it: the value, and its likely cause where there is one. */ function notAClass(app) {
+    const hint = app === undefined ? CIRCULAR_IMPORT_HINT : typeof app === 'object' && app !== null ? MODULE_HINT : '';
+    return {
+        name: describeValue(app),
+        hint
+    };
+}
+/** Whether a message gives a route's `member`, `role` or `channel` flag, which dispatch refuses in a DM. */ const givesGuildFlag = (route, params)=>route.flags.some((flag)=>flag.type !== undefined && isGuildType(flag.type) && Object.hasOwn(params, flag.flag));
 /** The options `@MeoCord` declares on an application class. */ function appOptionsOf(app) {
+    // An app that isn't a class at all, as a circular import gives, has no metadata to read
+    if (typeof app !== 'function') {
+        const { name, hint } = notAClass(app);
+        throw new TypeError(`${name} is not decorated with @MeoCord().${hint}`);
+    }
     const options = Reflect.getMetadata(META.appOptions, app);
     if (!options) throw new TypeError(`${app.name || 'The given class'} is not decorated with @MeoCord().`);
     return options;
@@ -52,11 +72,33 @@ import { META } from '../util/metadata-keys.js';
     if ('content' in input) {
         const { messages = {} } = appOptionsOf(app);
         const starts = staticMessageStarts(app, messages, input);
-        const matched = matchMessageRoute(buildMessageRoutes(controllersOf(app), messages), input.content, starts);
+        const routes = buildMessageRoutes(controllersOf(app), messages);
+        let matched = matchMessageRoute(routes, input.content, starts);
+        const named = (route)=>`${route.controllerClass.name}.${String(route.method)}`;
+        // Without `dm`: under strict mocks, read as sent in a server, as dispatch routes such a message whatever the
+        // controllers' order; otherwise as from anywhere, warning where that answers differently
+        if (starts.inGuild === undefined) {
+            const inServer = matchMessageRoute(routes, input.content, {
+                ...starts,
+                inGuild: true
+            });
+            if (strictMocks()) matched = inServer && fitsScope(inServer.route.scope, true) ? inServer : undefined;
+            else if (matched && inServer && matched.route !== inServer.route && !fitsScope(matched.route.scope, true)) {
+                warnOnce(logger, `resolveRoute resolved a message without dm to ${named(matched.route)}, which works in a DM alone, where dispatch runs ` + `${named(inServer.route)} for a message sent in a server. Pass dm: true for a DM. Under useStrictMocks() it resolves to ` + `${named(inServer.route)}.`);
+            } else if (matched && !fitsScope(matched.route.scope, true)) {
+                // Only a handler that works in a DM alone takes it, which dispatch runs in a DM only
+                warnOnce(logger, `resolveRoute found only ${named(matched.route)}, which works in a DM alone, for a message without dm; dispatch runs it ` + 'only in a DM. Pass dm: true. Under useStrictMocks() this resolves to undefined.');
+            }
+        }
         if (!matched) return undefined;
         const { route, params } = matched;
-        // Dispatch answers a route that does not work in a DM with its usage, and never runs it
-        if (starts.inGuild === false && (!fitsScope(route.scope, false) || needsGuild(route))) return undefined;
+        // Dispatch never runs a route that does not work in a DM; one sent with a prefix or mention is told it works in a server only
+        if (starts.inGuild === false && (!fitsScope(route.scope, false) || takesGuildParam(route))) return undefined;
+        // Nor one with a required flag only a server has, or given one: refused under strict mocks, warned about otherwise
+        if (starts.inGuild === false && (needsGuild(route) || givesGuildFlag(route, params))) {
+            if (strictMocks()) return undefined;
+            warnOnce(logger, `resolveRoute resolved a DM to ${named(route)}, which dispatch answers "This command ` + 'works in a server only.": a member, role or channel flag is found only in a server. Under useStrictMocks() this ' + 'resolves to undefined.');
+        }
         return {
             controller: route.controllerClass,
             method: route.method,
@@ -140,4 +182,4 @@ import { META } from '../util/metadata-keys.js';
     return target;
 }
 
-export { findRouteConflicts, resolveRoute };
+export { findRouteConflicts, notAClass, resolveRoute };

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

@@ -19,8 +19,9 @@ const settings = shared('strictMocks', ()=>({
  * 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.
+ * `mentions.repliedUser` and a modal's `message` are `null`, an interaction's `ephemeral` is `null` until `reply()` or
+ * `deferReply()` decides it, 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
@@ -33,11 +34,14 @@ const settings = shared('strictMocks', ()=>({
  * 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.
+ * `mockResolvedValue`, is refused too, where without it the mock runs it and warns. An answer marks the interaction
+ * `replied`, `deferred` or `responded` once it resolves, as discord.js does, so code that doesn't await one fails as it
+ * would on a bot, within one run of the test's code. 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.
+ * It refuses an autocomplete that dispatch gives to another `@Autocomplete` handler, or to none, the same way.
  *
  * `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.

package/dist/esm/testing/theme.js

@@ -1,8 +1,9 @@
 import { assertValidTheme } from '../core/theme-validation.js';
 import { defaultTheme, runWithTheme, mergeTheme, copyLayer } from '../core/theme-scope.js';
+import { shared } from '../util/shared-state.util.js';
 
-// Themes createMockTheme made, which withTheme uses as they are
-const mocks = new WeakSet();
+// Themes createMockTheme made through either build of this version, which withTheme uses as they are
+const mocks = shared('mockThemes', ()=>new WeakSet());
 function mockTheme(overrides, where) {
     if (overrides === undefined) return defaultTheme();
     assertValidTheme(overrides, where);

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

@@ -23,21 +23,29 @@ import chalk from 'chalk';
  * 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.
  *
+ * @param options.building - Whether the command builds, which refuses a `webpack` hook; one that runs without building
+ *   only warns about it.
  * @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() {
+ */ function checkSourceConfig({ building = true } = {}) {
     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();
+    // Named as itself; with no loadError, watch mode reports it as a problem, not as the config failing to compile
+    if ('error' in loaded && loaded.file === 'tsconfig.json') {
+        return {
+            problem: `tsconfig.json could not be read, so nothing was built or started:\n  ${loaded.error}`
+        };
+    }
     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);
+    const problem = shapeProblem(loaded.config, building);
     return problem ? {
         problem
     } : {
@@ -51,9 +59,12 @@ import chalk from 'chalk';
  * 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.
  *
+ * @param options.building - Whether the command builds, as {@link checkSourceConfig} takes it.
  * @returns The config, which a build compiles and the bot then runs with.
- */ async function compileAndValidateConfig() {
-    const checked = checkSourceConfig();
+ */ async function compileAndValidateConfig({ building = true } = {}) {
+    const checked = checkSourceConfig({
+        building
+    });
     if ('problem' in checked) {
         reportConfigProblem(checked.problem);
         await wait(100);
@@ -80,17 +91,27 @@ import chalk from 'chalk';
         process.exit(1);
         return;
     }
-    return compileAndValidateConfig();
+    return compileAndValidateConfig({
+        building: false
+    });
 }
-/** Exits with every problem when a configuration has options of the wrong type, and warns about unknown ones. */ async function assertConfigShape(config) {
-    const problem = shapeProblem(config);
+/**
+ * Exits with every problem when a configuration a command runs with, without building, has options of the wrong type,
+ * and warns about unknown ones.
+ */ async function assertConfigShape(config) {
+    const problem = shapeProblem(config, false);
     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);
+/**
+ * Every option of the wrong type in a configuration, as one report, or undefined; options it does not know are warned
+ * about. A `webpack` hook is refused only for a command that builds, as the build refuses it.
+ */ function shapeProblem(config, building = true) {
+    const { errors, warnings } = configProblems(config, {
+        building
+    });
     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')}`;

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

@@ -2,20 +2,22 @@ import fs from 'fs';
 import path from 'path';
 import { execFile } from 'child_process';
 import { Logger } from '../common/logger.js';
-import '../core/theme-scope.js';
-import '../core/theme-validation.js';
+import '../common/theme.js';
 import '../common/decorator.js';
 import 'reflect-metadata';
 import 'discord.js';
+import '../common/deprecation.js';
 import '../common/response/response-state.js';
+import '../core/theme-scope.js';
 import '../common/errors.js';
+import '../common/cooldown-store.js';
 import 'node:crypto';
 import '../decorator/controller.decorator.js';
 import '../core/scalar-types.js';
-import 'node:fs';
-import 'node:url';
+import './refusal.util.js';
 import '../common/translator.js';
 import '../common/meocord-text.js';
+import '../core/theme-resolvers.js';
 import { kebabCase, startCase, camelCase } from 'lodash-es';
 import { fileURLToPath } from 'url';
 

package/dist/esm/util/inherited-env.util.js

@@ -34,16 +34,11 @@ import { listed } from './user-text.util.js';
     const productionFiles = envFiles('production');
     // In Bun's order, a later file winning, as the config's dotenv also settles them
     const production = Object.assign({}, ...productionFiles.map((file)=>read(root, file)));
-    const development = new Map();
-    for (const file of envFiles(env.NODE_ENV).filter((file)=>!productionFiles.includes(file))){
-        for (const [key, value] of Object.entries(read(root, file)))development.set(key, {
-            value,
-            file
-        });
-    }
+    const files = envFiles(env.NODE_ENV);
+    // Listed file by file, in Bun's order
     const loaded = [
-        ...development
-    ].filter(([key, { value }])=>env[key] === value && production[key] !== value);
+        ...bunLoadedValues(env, root, files)
+    ].filter(([key, { value, file }])=>!productionFiles.includes(file) && env[key] === value && production[key] !== value).sort(([, a], [, b])=>files.indexOf(a.file) - files.indexOf(b.file));
     if (loaded.length === 0) return none;
     return {
         files: [
@@ -61,13 +56,77 @@ import { listed } from './user-text.util.js';
  * The environment a bot started in `root` inherits: `env` without the values its .env files gave it. Neither dotenv nor
  * Bun replaces a variable already set, so an inherited copy would keep a value a file no longer holds; the bot reads the
  * files itself as it starts. A variable the shell sets to another value is kept.
- */ function inheritedEnvironment(env, root) {
+ */ function inheritedEnvironment(env, root, bun = process.versions.bun !== undefined) {
+    const files = envFiles(env.NODE_ENV);
     const fromFiles = new Map();
-    for (const file of envFiles(env.NODE_ENV)){
-        for (const [key, value] of Object.entries(read(root, file)))fromFiles.set(key, (fromFiles.get(key) ?? new Set()).add(value));
-    }
+    const add = (key, value)=>fromFiles.set(key, (fromFiles.get(key) ?? new Set()).add(value));
+    // As dotenv sets them, and, when the CLI runs on Bun, as Bun set them before any code ran
+    for (const file of files)for (const [key, value] of Object.entries(read(root, file)))add(key, value);
+    if (bun) for (const [key, { value }] of bunLoadedValues(env, root, files))add(key, value);
     return Object.fromEntries(Object.entries(env).filter(([key, value])=>value === undefined || !fromFiles.get(key)?.has(value)));
 }
+/**
+ * The value Bun gives each variable the .env files set, and the file it comes from: Bun loads them before any code
+ * runs, the file that wins in `files` first, sets only a variable not already set, and expands `$NAME`, `${NAME}` and
+ * `${NAME:-default}` line by line from what is set so far, a later line of the same file giving its text as written.
+ * A variable the shell set keeps the shell's value, which `env` holds, so it differs from the one given here.
+ */ function bunLoadedValues(env, root, files) {
+    // Each variable's first line in Bun's order: the one Bun loads it from
+    const lines = [];
+    const first = new Map();
+    for (const file of [
+        ...files
+    ].reverse()){
+        const own = read(root, file);
+        for (const [key, text] of Object.entries(own)){
+            if (!first.has(key)) first.set(key, lines.length);
+            lines.push({
+                key,
+                text,
+                file,
+                own
+            });
+        }
+    }
+    const values = new Map();
+    const fromShell = new Map();
+    // A variable the shell set holds a value its line doesn't give; one its own line refers to back counts as from it
+    const shellSet = (key)=>{
+        if (!fromShell.has(key)) {
+            fromShell.set(key, false);
+            fromShell.set(key, env[key] !== undefined && env[key] !== valueAt(first.get(key)));
+        }
+        return fromShell.get(key);
+    };
+    const valueAt = (index)=>{
+        if (!values.has(index)) {
+            const { text, file, own } = lines[index];
+            const lookup = (name)=>{
+                const at = first.get(name);
+                if (at === undefined || shellSet(name) || at < index) return env[name] ?? '';
+                // Not loaded yet: its text as written in this file, or unset until a later file loads it
+                return lines[at].file === file ? own[name] : '';
+            };
+            values.set(index, expandAsBun(text, lookup));
+        }
+        return values.get(index);
+    };
+    return new Map([
+        ...first
+    ].map(([key, index])=>[
+            key,
+            {
+                value: valueAt(index),
+                file: lines[index].file
+            }
+        ]));
+}
+/** A `$NAME` or `${NAME}` reference, with `${NAME:-default}`'s default, or a `\$` Bun reads as a dollar sign. */ const BUN_REFERENCE = /\\\$|\$\{([A-Za-z0-9_]+)(?::-([^}]*))?\}|\$([A-Za-z0-9_]+)/g;
+/** A .env value as Bun expands it, each reference read through `lookup`; any other `$` stays as it is. */ const expandAsBun = (text, lookup)=>text.replace(BUN_REFERENCE, (match, braced, fallback, bare)=>{
+        if (match === '\\$') return '$';
+        const value = lookup(braced ?? bare);
+        return fallback !== undefined && value === '' ? fallback : value;
+    });
 /** A .env file's values, or none when it is not there to read. */ function read(root, file) {
     let text;
     try {

package/dist/esm/util/json.util.js

@@ -1,3 +1,7 @@
+import { readFileSync } from 'node:fs';
+
+/** The byte order mark an editor may write at the start of a UTF-8 file, which `JSON.parse` refuses. */ const BYTE_ORDER_MARK = '\uFEFF';
+/** The text without a leading byte order mark, as Node and tsc read a JSON file. */ const withoutByteOrderMark = (text)=>text.startsWith(BYTE_ORDER_MARK) ? text.slice(BYTE_ORDER_MARK.length) : text;
 /**
  * Removes the comments and trailing commas `tsconfig.json` allows, leaving strings untouched, so an
  * `https://` URL or a `/*` glob inside one survives.
@@ -37,8 +41,11 @@
     }
     return result;
 }
-/** Parses JSON with the comments and trailing commas `tsconfig.json` allows. */ function parseJsonc(text) {
-    return JSON.parse(stripJsonc(text));
+/** Parses JSON with the comments and trailing commas `tsconfig.json` allows, and a leading byte order mark. */ function parseJsonc(text) {
+    return JSON.parse(stripJsonc(withoutByteOrderMark(text)));
+}
+/** Reads a JSON file, such as a `package.json`, as Node reads one: UTF-8, with a leading byte order mark ignored. */ function readJsonFile(file) {
+    return JSON.parse(withoutByteOrderMark(readFileSync(file, 'utf8')));
 }
 
-export { parseJsonc, stripJsonc };
+export { parseJsonc, readJsonFile, stripJsonc };

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

@@ -3,6 +3,7 @@ import { findModulePackageDir } from './common.util.js';
 import path from 'node:path';
 import fs__default from 'node:fs';
 import wait from './wait.util.js';
+import { readJsonFile } from './json.util.js';
 import chalk from 'chalk';
 
 function configureCommandHelp(command) {
@@ -120,10 +121,10 @@ function configureCommandHelp(command) {
             throw new Error('Cannot locate the "MeoCord" package directory.');
         }
         // Read and parse the root package.json
-        const { dependencies } = JSON.parse(fs__default.readFileSync(packageJsonPath, 'utf-8'));
+        const { dependencies } = readJsonFile(packageJsonPath);
         // Read and parse the MeoCord package.json
         const internalPackageJsonPath = path.join(meocordPath, 'package.json');
-        const { name: internalPackageName } = JSON.parse(fs__default.readFileSync(internalPackageJsonPath, 'utf-8'));
+        const { name: internalPackageName } = readJsonFile(internalPackageJsonPath);
         // Validate that MeoCord is listed as a dependency in the root package.json
         if (!dependencies?.[internalPackageName]) {
             throw new Error('The package.json does not list "MeoCord" as a dependency. Ensure you are in the root directory.');

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

@@ -49,9 +49,22 @@ let problem;
  * 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;
+    if (unparsable(error) || code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return true;
     return typeof code === 'string' && code.startsWith('ERR_REQUIRE_');
 }
+/** The name of Bun's error for a module it could not parse; several of them come together in an AggregateError. */ const BUN_PARSE_ERROR = 'BuildMessage';
+/**
+ * Whether a module could not be parsed, so none of its code ran: on Node, a SyntaxError thrown from compiling it, whose
+ * first frame is Node's own; on Bun, its parse error. A SyntaxError the config's code throws as it runs, from
+ * `JSON.parse` or `new RegExp` on an environment value, is not one.
+ */ function unparsable(error) {
+    const bunParseError = (each)=>each?.name === BUN_PARSE_ERROR;
+    if (bunParseError(error)) return true;
+    if (error instanceof AggregateError) return error.errors.length > 0 && error.errors.every(bunParseError);
+    if (!(error instanceof SyntaxError)) return false;
+    const firstFrame = error.stack?.split('\n').find((line)=>line.trimStart().startsWith('at '));
+    return firstFrame === undefined || /[( ]node:/.test(firstFrame);
+}
 /**
  * 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

@@ -1,6 +1,9 @@
 import { shutdownTimeoutProblem } from './shutdown-timeout.util.js';
+import { quoteForLog } from './user-text.util.js';
 
-const describe = (value)=>typeof value === 'string' ? `'${value}'` : typeof value === 'number' || typeof value === 'boolean' ? String(value) : Array.isArray(value) ? 'an array' : value === null ? 'null' : typeof value;
+/** Why a config that still declares a `webpack` hook, which MeoCord does not run, is refused. */ const WEBPACK_HOOK_REFUSAL = 'meocord.config.ts still declares a `webpack` hook, which MeoCord no longer runs. ' + 'Rename it to `rsbuild` and reshape its body for Rsbuild: images, fonts, svg and media ' + 'need no rules any more, `output.filename` accepts a function for custom asset paths, ' + 'and raw rules go through `tools.rspack`. See the 4.0.0 release notes.';
+// A string as other messages quote user text, so a line break in it can't start a line of its own
+const describe = (value)=>typeof value === 'string' ? quoteForLog(value) : typeof value === 'number' || typeof value === 'boolean' ? String(value) : Array.isArray(value) ? 'an array' : value === null ? 'null' : typeof value;
 const optional = (check)=>(value, key)=>value === undefined ? undefined : check(value, key);
 const string = (value, key)=>typeof value === 'string' ? undefined : `${key} must be a string (got ${describe(value)})`;
 const boolean = (value, key)=>typeof value === 'boolean' ? undefined : `${key} must be true or false (got ${describe(value)})`;
@@ -60,8 +63,10 @@ const oneOf = (...allowed)=>(value, key)=>allowed.includes(value) ? undefined :
  * Checks a loaded configuration's shape, so a wrong type fails at once with what to fix instead of
  * surfacing later as an odd build or runtime error.
  *
+ * @param options.building - Whether the command builds, which refuses a `webpack` hook; one that only runs a build
+ *   made before is warned that the hook has no effect.
  * @returns Every error and warning found; the command should stop when there are errors.
- */ function configProblems(config) {
+ */ function configProblems(config, { building = true } = {}) {
     const problems = {
         errors: [],
         warnings: []
@@ -72,6 +77,11 @@ const oneOf = (...allowed)=>(value, key)=>allowed.includes(value) ? undefined :
     }
     const shape = configShape(problems);
     for (const [name, value] of Object.entries(config)){
+        // A webpack hook: a build refuses it, so there it's that error, not an option with no effect
+        if (name === 'webpack' && building) {
+            problems.errors.push(WEBPACK_HOOK_REFUSAL);
+            continue;
+        }
         const check = shape[name];
         if (!check) {
             problems.warnings.push(`${name} is not a MeoCord option, so it has no effect.`);
@@ -83,4 +93,4 @@ const oneOf = (...allowed)=>(value, key)=>allowed.includes(value) ? undefined :
     return problems;
 }
 
-export { configProblems };
+export { WEBPACK_HOOK_REFUSAL, configProblems };

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

@@ -10,7 +10,7 @@ import { projectPaths } from './tsconfig-paths.util.js';
  */ function loadMeoCordSourceConfig() {
     const result = readMeoCordSourceConfig();
     if ('error' in result) {
-        console.error(`[MeoCord] Failed to load config: ${result.error}`);
+        console.error(result.file === 'tsconfig.json' ? `[MeoCord] Failed to read tsconfig.json: ${result.error}` : `[MeoCord] Failed to load config: ${result.error}`);
         return undefined;
     }
     return result.config;
@@ -19,14 +19,24 @@ import { projectPaths } from './tsconfig-paths.util.js';
  * Loads `meocord.config.ts` from source, reporting a failure instead of logging it, for the CLI to stop
  * on. jiti's message names the file, line and column of a syntax error.
  *
- * @returns The config (undefined when the file does not exist), or the reason it could not be loaded.
+ * @returns The config (undefined when the file does not exist), or the reason it could not be loaded, naming
+ *   `tsconfig.json` as the file at fault when it was that file, whose `paths` the config is loaded with.
  */ function readMeoCordSourceConfig() {
     const configPath = path.resolve(process.cwd(), 'meocord.config.ts');
     if (!existsSync(configPath)) return {
         config: undefined
     };
+    // Read first, so a tsconfig.json that can't be read is reported as its own, not as the config failing to load
+    let aliases;
+    try {
+        aliases = jitiAliases(projectPaths() ?? {});
+    } catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            file: 'tsconfig.json'
+        };
+    }
     try {
-        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: false,

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

@@ -5,8 +5,9 @@ import { isBuiltApplication, bundleEntry } from './bundle-entry.util.js';
 /**
  * File written beside a bundle that carries native addons, naming the platform it was built for.
  */ const PLATFORM_MANIFEST = 'meocord.platform.json';
+/** The one operating system whose binaries are built against a C library of its choosing, glibc or musl. */ const LIBC_PLATFORM = 'linux';
 /** The C library this process runs against, when the runtime can say. */ function detectLibc() {
-    if (process.platform !== 'linux') return undefined;
+    if (process.platform !== LIBC_PLATFORM) return undefined;
     try {
         const report = process.report?.getReport?.();
         if (!report?.header) return undefined;
@@ -66,4 +67,4 @@ import { isBuiltApplication, bundleEntry } from './bundle-entry.util.js';
     return process.argv[1] ? path.dirname(process.argv[1]) : undefined;
 }
 
-export { PLATFORM_MANIFEST, currentPlatform, describePlatform, isSamePlatform, platformMismatch, writePlatformManifest };
+export { LIBC_PLATFORM, PLATFORM_MANIFEST, currentPlatform, describePlatform, isSamePlatform, platformMismatch, writePlatformManifest };

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

@@ -1,15 +1,22 @@
 import path from 'path';
-import { warnDeprecatedBehaviour } from '../common/deprecation.js';
+import { warnOnce, warnDeprecatedBehaviour } from '../common/deprecation.js';
 import { isExplainedError } from '../common/explained-error.js';
 import { Logger } from '../common/logger.js';
 import { isBuiltApplication, STARTUP_ERRORS_KEY } from './bundle-entry.util.js';
 import { comparablePath, framePath } from './source-path.util.js';
+import { shared } from './shared-state.util.js';
 
 const REFUSAL = Symbol.for('meocord.refusal');
-/** Whether this process reports refusals yet; see `reportRefusals`. */ let reporting = false;
-/** Refusals someone else reports, and ends the process for, which `reportRefusals` leaves to them. */ const handedOff = new WeakSet();
+/**
+ * One per process for this meocord version, so the two builds report a refusal once: whether this process reports
+ * refusals yet (see `reportRefusals`), and the refusals someone else reports, and ends the process for, which it leaves
+ * to them.
+ */ const refusals = shared('refusalReporting', ()=>({
+        reporting: false,
+        handedOff: new WeakSet()
+    }));
 /** Leaves a refusal to whoever reports it instead, such as a shard's manager: going uncaught, it is neither logged nor exits. */ function handOffRefusal(error) {
-    handedOff.add(error);
+    refusals.handedOff.add(error);
 }
 /**
  * Marks an error MeoCord raises for code it refuses as the application loads, such as a decorator given what it
@@ -20,18 +27,29 @@ const REFUSAL = Symbol.for('meocord.refusal');
         enumerable: false
     });
     // Before the error is thrown, so a built application reports it however the throw ends
-    if (!reporting && isBuiltApplication()) reportRefusals();
+    if (!refusals.reporting && isBuiltApplication()) reportRefusals();
     return error;
 }
-/** What a decorator is applied to, as a refusal names it: `Class.method` on a method, `Class` on a class. */ function decoratedName(target, propertyKey) {
+/** The name of the class a member decorator is applied in: a static member's target is the class itself. */ function ownerName(target) {
+    return (typeof target === 'function' ? target : target.constructor).name;
+}
+/**
+ * What a decorator is applied to, as a refusal names it: `Class.method` on a method, a static one included, `Class` on
+ * a class.
+ */ function decoratedName(target, propertyKey) {
     if (propertyKey === undefined) return target.name || 'a class';
-    return `${target.constructor.name}.${String(propertyKey)}`;
+    return `${ownerName(target)}.${String(propertyKey)}`;
 }
 /**
  * Refuses a decorator that goes only on a method, or on a member, where it is applied to a class, directly or through
- * `applyDecorators`, rather than store what nothing reads or fail on the method it lacks.
+ * `applyDecorators`, rather than store what nothing reads or fail on the method it lacks. On a static member, where
+ * nothing reads it either, it warns; the next major version (5.0) refuses it there too.
  */ function refuseOnClass(decorator, target, propertyKey, place = 'a method') {
     if (propertyKey === undefined) throw refuse(new Error(`${decoratedName(target)}: ${decorator} goes on ${place}, not on a class.`));
+    if (typeof target === 'function') {
+        const where = place === 'a method' ? 'an instance method, not a static one; it never runs' : 'an instance member, not a static one, where nothing reads it';
+        warnOnce(new Logger(decorator.slice(1)), `${decoratedName(target, propertyKey)}: ${decorator} goes on ${where}. The next major version (5.0) refuses it.`);
+    }
 }
 /** Refuses a decorator that goes only on a class where it is applied to a method, directly or through `applyDecorators`. */ function refuseOnMethod(decorator, target, propertyKey) {
     if (propertyKey !== undefined) throw refuse(new Error(`${decoratedName(target, propertyKey)}: ${decorator} goes on a class, not on a method.`));
@@ -214,9 +232,9 @@ function keepOrThrow(error, target, propertyKey) {
  * report. Installed by the first refusal in a built application. Bun has no monitor event for a rejection, so there a
  * listener reports a refused rejection and rejects any other again without itself, unless the app listens itself.
  */ function reportRefusals(log = (text)=>new Logger('MeoCord').error(text), exit = (code)=>process.exit(code), { bun = process.versions.bun !== undefined, reject = (reason)=>void Promise.reject(reason) } = {}) {
-    reporting = true;
+    refusals.reporting = true;
     const report = (error)=>{
-        if (handedOff.has(error)) return;
+        if (refusals.handedOff.has(error)) return;
         if (!isExplainedError(error)) log(describeRefusal(error, process.cwd()));
         exit(1);
     };
@@ -235,4 +253,4 @@ function keepOrThrow(error, target, propertyKey) {
     process.on('unhandledRejection', onRejection);
 }
 
-export { allDeclaredErrors, collectStartupErrors, declarationOf, declaredErrorsOf, declaring, decoratedName, deprecatedOnMethod, describeRefusal, handOffRefusal, isRefusal, keepsDeclaredErrors, logStartupErrors, refuse, refuseOnClass, refuseOnMethod, reportRefusals, setStartupErrorsMode, sourceFileOf, startupError, startupErrorsOf, stopOnStartupErrors };
+export { allDeclaredErrors, collectStartupErrors, declarationOf, declaredErrorsOf, declaring, decoratedName, deprecatedOnMethod, describeRefusal, handOffRefusal, isRefusal, keepsDeclaredErrors, logStartupErrors, ownerName, refuse, refuseOnClass, refuseOnMethod, reportRefusals, setStartupErrorsMode, sourceFileOf, startupError, startupErrorsOf, stopOnStartupErrors };