meocord 4.2.0 → 4.2.1

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/strict-mocks.js

@@ -1,26 +1,46 @@
-// Whether useStrictMocks() is on, and whether a mock was made before it could be
-let strict = false;
-let mockMade = false;
-/** Whether mocks compute discord.js's state, as {@link useStrictMocks} turns on. */ const strictMocks = ()=>strict;
+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() {
-    mockMade = true;
+    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, 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. No placeholder warning is logged.
+ * 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. 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. The next major version (5.0) computes these values without the call.
+ * 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.
  *
@@ -35,11 +55,11 @@ let mockMade = false;
  * @see {@link useMockFn}
  * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
  */ function useStrictMocks() {
-    if (strict) return;
-    if (mockMade) {
+    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.");
     }
-    strict = true;
+    settings.strict = true;
 }
 
 export { noteMockMade, strictMocks, useStrictMocks };

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, 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

@@ -66,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/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 };

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/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 };