meocord 4.2.1 → 4.2.3

package/dist/esm/build/native-addons.js

@@ -1,6 +1,7 @@
-import { existsSync, realpathSync, cpSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, realpathSync, cpSync, readdirSync } from 'fs';
 import path from 'path';
-import { currentPlatform } from '../util/platform.util.js';
+import { currentPlatform, LIBC_PLATFORM } from '../util/platform.util.js';
+import { readJsonFile } from '../util/json.util.js';
 
 /**
  * The package a resolved module file belongs to, and the directory it was installed in.
@@ -85,7 +86,7 @@ import { currentPlatform } from '../util/platform.util.js';
 }
 /** A package's declared dependencies, runtime and optional, or none if it cannot be read. */ function readDependencies(dir) {
     try {
-        const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const pkg = readJsonFile(path.join(dir, 'package.json'));
         return {
             dependencies: Object.keys(pkg.dependencies ?? {}),
             optional: Object.keys(pkg.optionalDependencies ?? {})
@@ -160,12 +161,31 @@ import { currentPlatform } from '../util/platform.util.js';
  * native package it keeps out is recorded in `found`, so the build can copy it into the output.
  */ function createNativeExternals(root) {
     const found = new Map();
+    const otherCopies = new Map();
     const plain = new Set();
+    // Where each importing directory finds a native package, read once per directory
+    const resolved = new Map();
+    const resolveFrom = (name, from)=>{
+        const key = `${name}\0${from}`;
+        if (!resolved.has(key)) resolved.set(key, resolvePackageDir(name, from, root));
+        return resolved.get(key);
+    };
     const externals = ({ request, context }, callback)=>{
         const name = request ? packageNameOfRequest(request) : undefined;
         if (!name || plain.has(name)) return callback();
-        if (found.has(name)) return callback(undefined, request);
-        const dir = resolvePackageDir(name, context ?? root, root);
+        const dir = resolveFrom(name, context ?? root);
+        const known = found.get(name);
+        if (known) {
+            // The bundle loads one copy of it for every importer, so code that needs another installed copy gets this one
+            const others = otherCopies.get(name) ?? [];
+            if (dir && !samePackageDir(dir, known.dir) && !others.some((other)=>samePackageDir(other, dir))) {
+                otherCopies.set(name, [
+                    ...others,
+                    dir
+                ]);
+            }
+            return callback(undefined, request);
+        }
         const carrier = dir ? nativeCarrier(dir, name, root) : undefined;
         if (!dir || !carrier) {
             plain.add(name);
@@ -179,34 +199,70 @@ import { currentPlatform } from '../util/platform.util.js';
     };
     return {
         externals,
-        found
+        found,
+        otherCopies
+    };
+}
+/** Whether two directories are one installed package, as pnpm links one from its store under several names. */ function samePackageDir(a, b) {
+    const real = (dir)=>{
+        try {
+            return realpathSync(dir);
+        } catch  {
+            return dir;
+        }
+    };
+    return real(a) === real(b);
+}
+/**
+ * The warning for a native package bundled code imports from more than one installed copy: each copy's version and
+ * place, and that the one packed is what every importer loads.
+ */ function otherCopiesWarning(name, packed, others, root) {
+    const where = (dir)=>{
+        let version = 'an unknown version';
+        try {
+            version = String(readJsonFile(path.join(dir, 'package.json')).version ?? version);
+        } catch  {
+        // Unreadable: named by its place alone
+        }
+        return `${version} in ${path.relative(root, dir) || '.'}`;
     };
+    return `${name} is installed more than once for bundled code: ${[
+        packed,
+        ...others
+    ].map(where).join(', ')}. A self-contained ` + `build packs one copy of a native package, ${where(packed)}, and every importer loads it, so code that needs another ` + `version gets this one. Install one version of ${name}, for example with \`npm dedupe\` or an \`overrides\` entry. ` + 'The next major version (5.0) stops the build here.';
 }
+/** The sole entry of an `os`, `cpu` or `libc` list that admits every value. */ const ANY_PLATFORM = 'any';
 /**
- * Whether a value passes a package.json `os`, `cpu` or `libc` list, the way npm reads one: a `!`
- * entry excludes its value, and a list with plain entries admits only those.
- */ function allowedBy(list, value) {
-    if (!Array.isArray(list) || list.length === 0) return true;
-    const entries = list.filter((entry)=>typeof entry === 'string');
-    if (entries.includes(`!${value}`)) return false;
-    const admitted = entries.filter((entry)=>!entry.startsWith('!'));
-    return admitted.length === 0 || admitted.includes(value);
+ * Whether a value passes a package.json `os`, `cpu` or `libc` field, the way npm reads one (npm-install-checks'
+ * `checkList`): a string is a list of one, `['any']` admits every value, a `!` entry excludes its value, and a list with
+ * plain entries admits only those.
+ */ function allowedBy(field, value) {
+    if (!field || typeof field !== 'string' && !Array.isArray(field)) return true;
+    const list = typeof field === 'string' ? [
+        field
+    ] : field.filter((entry)=>typeof entry === 'string');
+    if (list.length === 1 && list[0] === ANY_PLATFORM) return true;
+    const excluded = list.filter((entry)=>entry.startsWith('!'));
+    if (excluded.includes(`!${value}`)) return false;
+    return excluded.length === list.length || list.includes(value);
 }
 /**
  * Whether an installed package is built for the platform, going by the `os`, `cpu` and `libc` its
  * package.json declares. A package that declares none of them runs anywhere.
  *
- * `libc` is compared only when the build platform's C library is known, so a runtime that cannot
- * report it keeps the package rather than dropping it on a guess.
+ * `libc` is compared only when the build platform's C library is known, so a Linux runtime that
+ * cannot report it keeps the package rather than dropping it on a guess. A platform with no C
+ * library to choose, such as macOS or Windows, takes no package that names one, as npm reads it.
  */ function isBuiltFor(dir, platform) {
     let pkg;
     try {
-        pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        pkg = readJsonFile(path.join(dir, 'package.json'));
     } catch  {
         return true;
     }
     if (!allowedBy(pkg.os, platform.platform) || !allowedBy(pkg.cpu, platform.arch)) return false;
-    return !platform.libc || allowedBy(pkg.libc, platform.libc);
+    if (platform.libc) return allowedBy(pkg.libc, platform.libc);
+    return platform.platform === LIBC_PLATFORM || !pkg.libc;
 }
 /**
  * Copies packages and their runtime dependencies into `<outDir>/node_modules`, skipping `@types` and other platforms'
@@ -287,4 +343,4 @@ import { currentPlatform } from '../util/platform.util.js';
     throw new Error(`bundleDependencies bundled ${found.size === 1 ? 'a package that loads' : 'packages that load'} a native addon:\n` + `${lines.join('\n')}\n` + 'A native addon is a compiled binary for one platform and cannot travel inside the bundle. The build ' + 'would run on this machine and fail in production the first time the addon loads. Keep ' + `${found.size === 1 ? 'it' : 'them'} out of the bundle and install ${found.size === 1 ? 'it' : 'them'} ` + `on the server:\n\n  externals: [${names}]`);
 }
 
-export { assertNoBundledNativeAddons, bundledModuleFiles, copyPackagesInto, createNativeExternals, findBundledNativeAddons, installedPackages, isBuiltFor, nativeCarrier, packageFromPath, packageNameOfRequest };
+export { assertNoBundledNativeAddons, bundledModuleFiles, copyPackagesInto, createNativeExternals, findBundledNativeAddons, installedPackages, isBuiltFor, nativeCarrier, otherCopiesWarning, packageFromPath, packageNameOfRequest };

package/dist/esm/build/rsbuild-config.js

@@ -2,8 +2,9 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { OptionalProbesPlugin } from './optional-probes.js';
 import { RunnableBundlePlugin } from './runnable-bundle.js';
-import { typeExternals } from './typed-externals.js';
+import { typeExternals, externalMatcher } from './typed-externals.js';
 import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
+import { WEBPACK_HOOK_REFUSAL } from '../util/meocord-config-validation.util.js';
 
 /**
  * The module bundled ahead of the application's entry to load `dist/meocord.config.mjs` first. Shipped
@@ -33,7 +34,8 @@ import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
  * The `optionalExternals` also listed in `externals`, where an ESM import of each runs as its importer loads and
  * throws when the package is missing, defeating the point of listing it as optional; a require stays one either way.
  */ function optionalExternalConflicts(optionalExternals = [], externals = []) {
-    return optionalExternals.filter((name)=>externals.some((external)=>typeof external === 'string' ? external === name : external.test(name)));
+    const matchers = externals.map(externalMatcher);
+    return optionalExternals.filter((name)=>matchers.some((matches)=>matches(name)));
 }
 /**
  * The prefix an asset import is joined to at runtime: the output directory, with forward slashes.
@@ -117,6 +119,12 @@ import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
                 ]));
                 // Says a missing package a dependency only probes for is harmless, and how to silence it
                 chain.plugin('meocord-optional-probes').use(OptionalProbesPlugin);
+                // Project references off, where Rsbuild sets 'auto': with them, Rspack resolves the root project's own files
+                // without its paths and baseUrl, which tsc applies, so a bot that references another project couldn't build. A
+                // file inside a referenced project then resolves through the root config's paths, not its own
+                if (chain.resolve.get('tsConfig')) chain.resolve.tsConfig({
+                    configFile: tsconfigPath
+                });
             },
             swc: {
                 jsc: {
@@ -231,7 +239,7 @@ import { prepareModifiedTsConfig } from '../util/tsconfig.util.js';
  * the default export's properties, but `in` and `Object.keys` only see `default`.
  */ function assertNoWebpackHook(config) {
     if (config?.webpack === undefined) return;
-    throw new Error('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.');
+    throw new Error(WEBPACK_HOOK_REFUSAL);
 }
 
 export { CONFIG_PRE_ENTRY, DISCORD_OPTIONAL_NATIVES, assertNoWebpackHook, assetPrefixFor, createRsbuildConfig, optionalExternalConflicts, optionalExternalNames };

package/dist/esm/build/typed-externals.js

@@ -6,6 +6,19 @@
  */ function externalType(request, dependencyType) {
     return `${dependencyType === 'commonjs' ? 'node-commonjs' : 'import'} ${request}`;
 }
+/**
+ * Whether a request matches an `externals` entry: a name it equals, or a pattern. A pattern is tested through a copy of
+ * its own, from the start of each request: with the `g` or `y` flag, `test` would otherwise resume where the last match
+ * ended and miss the next request for the same package. A `y` pattern still matches only at the start, as Rsbuild
+ * tests it.
+ */ function externalMatcher(entry) {
+    if (typeof entry === 'string') return (request)=>request === entry;
+    const pattern = new RegExp(entry);
+    return (request)=>{
+        pattern.lastIndex = 0;
+        return pattern.test(request);
+    };
+}
 /** Whether an external's result names its own type, as `node-commonjs zlib-sync` does. */ const typed = (result)=>/\s/.test(result);
 /**
  * The externals with every untyped entry given its type by {@link externalType}: a string or pattern, as `autoExternal`
@@ -13,7 +26,7 @@
  */ function typeExternals(items) {
     return items.map((item)=>{
         if (typeof item === 'string' || item instanceof RegExp) {
-            const matches = (request)=>typeof item === 'string' ? request === item : item.test(request);
+            const matches = externalMatcher(item);
             return (data, callback)=>{
                 const { request, dependencyType } = data;
                 if (request && matches(request)) return callback(null, externalType(request, dependencyType));
@@ -33,4 +46,4 @@
     });
 }
 
-export { externalType, typeExternals };
+export { externalMatcher, externalType, typeExternals };

package/dist/esm/common/cooldown-store.js

@@ -1,14 +1,29 @@
-/**
- * How many calls a cooldown allows, and in how long a window.
- *
- * @group Types
- */ /** `verdict` with `release` added as a non-enumerable property, as the built-in stores give it. */ function withRelease(verdict, release) {
+import { sharedKey } from '../util/shared-state.util.js';
+
+/** `verdict` with `release` added as a non-enumerable property, as the built-in stores give it. */ function withRelease(verdict, release) {
     return Object.defineProperty(verdict, 'release', {
         value: release,
         enumerable: false,
         configurable: true
     });
 }
+/**
+ * `verdict` with `retryTimestamp` added as a non-enumerable property, unless it holds the field already, so a refusal
+ * that gains it compares and serialises as it did.
+ */ function withRetryTimestamp(verdict, retryTimestamp) {
+    if (retryTimestamp === undefined || Object.hasOwn(verdict, 'retryTimestamp')) return verdict;
+    return Object.defineProperty(verdict, 'retryTimestamp', {
+        value: retryTimestamp,
+        enumerable: false,
+        configurable: true
+    });
+}
+/** A batch verdict for one key, as the built-in stores' `consume` gives it: `allowed`, `retryAfterMs`, and the wait's end. */ function singleVerdict({ allowed, retryAfterMs, retryTimestamp }) {
+    return withRetryTimestamp({
+        allowed,
+        retryAfterMs
+    }, retryTimestamp);
+}
 /**
  * Where `@Cooldown` counts calls.
  *
@@ -59,10 +74,11 @@
    */ async consumeMany(entries) {
         for (const [index, { key, limit }] of entries.entries()){
             const verdict = await this.consume(key, limit);
-            if (!verdict.allowed) return {
+            // The wait's end by name, as a built-in store's consume gives it non-enumerable, which a spread leaves out
+            if (!verdict.allowed) return withRetryTimestamp({
                 ...verdict,
                 blocked: index
-            };
+            }, verdict.retryTimestamp);
         }
         return {
             allowed: true,
@@ -88,6 +104,18 @@
         });
     }
 }
+// CooldownStore's own consumeMany and peekMany carry a mark both builds share, so a check can tell a store's
+// override from either build's default, as a store that extends one build's class can be checked by the other's
+const DEFAULT_BATCH_METHOD = sharedKey('cooldown-store:default-batch-method');
+for (const method of [
+    CooldownStore.prototype.consumeMany,
+    CooldownStore.prototype.peekMany
+]){
+    Object.defineProperty(method, DEFAULT_BATCH_METHOD, {
+        value: true
+    });
+}
+/** Whether `method` is CooldownStore's own consumeMany or peekMany, from either build of this version. */ const isDefaultBatchMethod = (method)=>typeof method === 'function' && DEFAULT_BATCH_METHOD in method;
 /**
  * Of several refusals, the one a caller waits on: the call runs only once every entry allows it, so the
  * longest wait. Undefined when nothing refused.
@@ -178,16 +206,12 @@
  * @see {@link CooldownStore}
  */ class MemoryCooldownStore extends CooldownStore {
     async consume(key, limit) {
-        const { allowed, retryAfterMs } = await this.consumeMany([
+        return singleVerdict(await this.consumeMany([
             {
                 key,
                 limit
             }
-        ]);
-        return {
-            allowed,
-            retryAfterMs
-        };
+        ]));
     }
     /**
    * Checks every entry, and records the call against all of them only if all allow it.
@@ -274,4 +298,4 @@
     }
 }
 
-export { CooldownStore, MemoryCooldownStore, forgetRecorded, longestRefusal, recordedOf, withRelease };
+export { CooldownStore, MemoryCooldownStore, forgetRecorded, isDefaultBatchMethod, longestRefusal, recordedOf, singleVerdict, withRelease };

package/dist/esm/common/deprecation.js

@@ -1,4 +1,7 @@
-const warned = new Set();
+import { shared } from '../util/shared-state.util.js';
+
+// One per process for this meocord version, so a warning both builds give prints once
+const warned = shared('deprecationWarnings', ()=>new Set());
 /** Warns once per run that `old` goes in 5.0, naming what to use instead. */ function warnDeprecated(logger, old, replacement) {
     warnOnce(logger, `${old} is deprecated and will be removed in the next major version (5.0). Use ${replacement} instead.`);
 }

package/dist/esm/common/execution-context.js

@@ -38,8 +38,10 @@ import { useTheme } from '../core/theme-scope.js';
     /**
    * The response state of the interaction being handled, the same one `respond(interaction)` returns,
    * or `undefined` for anything that cannot be answered: a message, a reaction, an event or
-   * autocomplete.
+   * autocomplete. An `@On('interactionCreate')` handler's call has none either, as MeoCord answers that interaction
+   * through the handler it dispatches it to.
    */ get response() {
+        if (this.getType() === 'event') return undefined;
         const interaction = this.getInteraction();
         return interaction?.isRepliable() ? respond(interaction) : undefined;
     }

package/dist/esm/common/explained-error.js

@@ -12,7 +12,10 @@ const EXPLAINED = Symbol.for('meocord.explained');
  *
  * Use it where a bot logs a startup failure, so an error MeoCord explained is not logged twice: an app
  * `MeoCordFactory.create()` refuses, such as two handlers for one command, or Discord refusing the bot token or a
- * privileged intent at login. The error is otherwise unchanged.
+ * privileged intent at login. A built bot has `process.exitCode` set for such an error already, and a start that a stop
+ * ended, which is explained too, leaves it as it was, so the process exits 0. Outside a build, as a script run by hand,
+ * `MeoCordFactory.create()` sets no code for an app it refuses, so a catch that returns early for an explained error,
+ * as below, sets `process.exitCode` itself there. The error is otherwise unchanged.
  *
  * @param error - An error `MeoCordFactory.create()` threw or `app.start()` rejected with.
  * @returns `true` when MeoCord explained the error.
@@ -28,9 +31,10 @@ const EXPLAINED = Symbol.for('meocord.explained');
  *   await app.start()
  * }
  *
- * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged
+ * // An error MeoCord explained, such as an app it refuses or a token Discord refused, is already logged, with the exit code set
  * bootstrap().catch(error => {
- *   if (!isExplainedError(error)) logger.error('Error during startup:', error)
+ *   if (isExplainedError(error)) return
+ *   logger.error('Error during startup:', error)
  *   process.exitCode = 1
  * })
  * ```

package/dist/esm/common/log-level.js

@@ -1,5 +1,6 @@
 import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
 import { isBuiltApplication } from '../util/bundle-entry.util.js';
+import { shared } from '../util/shared-state.util.js';
 
 /** The environment variable that sets the level for one run, over `logLevel` in meocord.config.ts. */ const LOG_LEVEL_ENV = 'MEOCORD_LOG_LEVEL';
 /** Each level's rank: a line prints when its rank is at least the level's. `silent` outranks every line. */ const LOG_LEVEL_RANK = {
@@ -10,32 +11,35 @@ import { isBuiltApplication } from '../util/bundle-entry.util.js';
     silent: 4
 };
 const isLogLevel = (value)=>typeof value === 'string' && Object.hasOwn(LOG_LEVEL_RANK, value);
-let threshold;
-let rejectedEnv;
+// One per process for this meocord version, so both builds print at one level and warn about a bad variable once
+const level = shared('logLevel', ()=>({
+        threshold: undefined,
+        rejectedEnv: undefined
+    }));
 /**
  * The rank a line needs to print. Resolved on first use and kept, so logging reads neither the
  * environment nor the config again: `MEOCORD_LOG_LEVEL`, then `logLevel`, then `debug` in development
  * and `log` otherwise. `logLevel` applies to the built bot only; the CLI and tests would otherwise read
  * it from whatever `dist` a previous build left.
  */ function logThreshold() {
-    if (threshold === undefined) {
+    if (level.threshold === undefined) {
         // The config first: loading it runs its dotenv call, which may set the variable
         const configured = isBuiltApplication() ? loadMeoCordConfig()?.logLevel : undefined;
         const raw = process.env[LOG_LEVEL_ENV];
         // An environment variable is often written in capitals, DEBUG for debug
         const fromEnv = raw?.toLowerCase();
-        rejectedEnv = raw && !isLogLevel(fromEnv) ? raw : undefined;
-        const level = isLogLevel(fromEnv) ? fromEnv : isLogLevel(configured) ? configured : process.env.NODE_ENV === 'development' ? 'debug' : 'log';
-        threshold = LOG_LEVEL_RANK[level];
+        level.rejectedEnv = raw && !isLogLevel(fromEnv) ? raw : undefined;
+        const chosen = isLogLevel(fromEnv) ? fromEnv : isLogLevel(configured) ? configured : process.env.NODE_ENV === 'development' ? 'debug' : 'log';
+        level.threshold = LOG_LEVEL_RANK[chosen];
     }
-    return threshold;
+    return level.threshold;
 }
 /**
  * An unknown `MEOCORD_LOG_LEVEL` the last resolution ignored, handed out once so the logger can warn
  * about it; undefined afterwards.
  */ function takeRejectedLogLevel() {
-    const rejected = rejectedEnv;
-    rejectedEnv = undefined;
+    const rejected = level.rejectedEnv;
+    level.rejectedEnv = undefined;
     return rejected;
 }
 

package/dist/esm/common/logger.js

@@ -5,7 +5,8 @@ import timezone from 'dayjs/plugin/timezone.js';
 import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
 import { isBuiltApplication } from '../util/bundle-entry.util.js';
 import chalk, { chalkStderr } from 'chalk';
-import { logThreshold, LOG_LEVEL_ENV, LOG_LEVEL_RANK, takeRejectedLogLevel } from './log-level.js';
+import { logThreshold, takeRejectedLogLevel, LOG_LEVEL_ENV, LOG_LEVEL_RANK } from './log-level.js';
+import { shared } from '../util/shared-state.util.js';
 
 dayjs.extend(utc);
 dayjs.extend(timezone);
@@ -31,7 +32,8 @@ const tagColours = TAG_COLOURS;
  * The shortest value registered: a bot's credential is far longer, and a short value, such as a test's placeholder,
  * would replace ordinary words in every line.
  */ const MIN_HIDDEN_LENGTH = 16;
-const hiddenValues = new Set();
+// One per process for this meocord version, so a value hidden through one build stays out of the other's lines
+const hiddenValues = shared('hiddenValues', ()=>new Set());
 /**
  * Keeps `value`, such as the bot's credential, out of every line Logger prints from now on, whatever object, string
  * or error carries it: trimmed, and without the `Bot ` or `Bearer ` prefix discord.js strips.

package/dist/esm/common/meocord-text.js

@@ -7,8 +7,9 @@ const ENGLISH = 'en-US';
 /**
  * The message a text is in for `locale`, and whether it is the app's: the app's catalogs down the locale's chain, with
  * MeoCord's English as the English catalog. An English request reads it after the app's English catalogs and before a
- * default in another language; any other request reads it last.
- */ function findText(translator, locale, key) {
+ * default in another language; any other request reads it last. A message whose form for `count` is empty, as tools
+ * export an untranslated string, counts as missing, as it does for the app's own texts.
+ */ function findText(translator, locale, key, count) {
     const english = ()=>{
         const message = lookup(MEOCORD_MESSAGES, key);
         return message === undefined ? undefined : {
@@ -23,7 +24,10 @@ const ENGLISH = 'en-US';
         const beforeDefault = englishFirst && served === translator.defaultLocale ? english() : undefined;
         if (beforeDefault) return beforeDefault;
         const message = lookup(translator[CATALOGS][served], key);
-        if (message !== undefined) return {
+        if (message !== undefined && pluralForm({
+            message,
+            locale: served
+        }, count) !== '') return {
             message,
             locale: served,
             own: true
@@ -44,9 +48,9 @@ const lists = new Map();
  * that has it; any other list is joined with its `joiner`, a comma unless given, as Intl's `unit` lists join with
  * nothing in zh-CN and with a space in ja.
  */ function renderText(translator, locale, text) {
-    const found = findText(translator, locale, text.key);
-    if (!found) return text.fallback ?? text.key;
     const params = text.params ?? {};
+    const found = findText(translator, locale, text.key, params.count);
+    if (!found) return text.fallback ?? text.key;
     return fillPlaceholders(pluralForm(found, params.count), (name, whole)=>{
         if (!Object.hasOwn(params, name)) return whole;
         const value = params[name];
@@ -72,7 +76,8 @@ const translators = shared('clientTranslators', ()=>new WeakMap());
 /** A text for an interaction, in its user's language through its app's translator. */ function textFor(interaction, text) {
     return renderText(translatorOfClient(interaction.client), interactionLocale(interaction), text);
 }
-const issueTexts = new WeakMap();
+// One per process for this meocord version, so an issue made by one build is translated by the other
+const issueTexts = shared('issueTexts', ()=>new WeakMap());
 /** An issue of a usage error, whose message is the text in English, keeping the text to translate it later. */ function usageIssue(text, param) {
     const issue = {
         ...param !== undefined && {

package/dist/esm/common/redis-cooldown-store.js

@@ -1,5 +1,5 @@
 import { randomUUID, createHash } from 'node:crypto';
-import { CooldownStore, withRelease, longestRefusal } from './cooldown-store.js';
+import { CooldownStore, singleVerdict, withRelease, longestRefusal } from './cooldown-store.js';
 import { Logger } from './logger.js';
 
 const logger = new Logger('RedisCooldownStore');
@@ -138,16 +138,12 @@ const DEFAULT_PREFIX = 'meocord:cooldown:';
    * @param limit - The calls allowed, and the window they are counted over.
    * @returns Whether this call was recorded, and if not, how long until one can be.
    */ async consume(key, limit) {
-        const { allowed, retryAfterMs } = await this.consumeMany([
+        return singleVerdict(await this.consumeMany([
             {
                 key,
                 limit
             }
-        ]);
-        return {
-            allowed,
-            retryAfterMs
-        };
+        ]));
     }
     /**
    * Records a call against every entry if all allow it, as one script: one round trip, however many

package/dist/esm/common/response/flags.js

@@ -31,5 +31,21 @@ const { Ephemeral, SuppressEmbeds, SuppressNotifications, IsComponentsV2 } = Mes
 /** The names of the flags set in a value, for warnings. */ function flagNames(flags) {
     return new MessageFlagsBitField(flags).toArray();
 }
+/** Each call as a warning names it, its article included. */ const STEP_NAMES = {
+    deferReply: 'a deferred reply',
+    reply: 'a reply',
+    update: 'an update',
+    edit: 'an edit',
+    followUp: 'a follow-up'
+};
+/** What an update or an edit does with `Ephemeral` instead, and how to answer only the member. */ const PRIVATE_HINT = {
+    update: 'An update changes the message the member clicked, for everyone; to answer only them, use respond(interaction).followUp() with MessageFlags.Ephemeral.',
+    edit: 'An edit keeps the message as public or private as it was; to answer only the member, use respond(interaction).followUp() with MessageFlags.Ephemeral.'
+};
+/** The development warning for the flags a call dropped, with how to answer privately when `Ephemeral` is one of them. */ function droppedFlagsWarning(step, dropped) {
+    const text = `Dropped flags ${flagNames(dropped).join(', ')}, which ${STEP_NAMES[step]} cannot take.`;
+    const hint = hasEphemeral(dropped) ? PRIVATE_HINT[step] : undefined;
+    return hint ? `${text} ${hint}` : text;
+}
 
-export { flagNames, hasComponentsV2, hasEphemeral, resolveFlags };
+export { droppedFlagsWarning, flagNames, hasComponentsV2, hasEphemeral, resolveFlags };

package/dist/esm/common/response/install-context.js

@@ -1,4 +1,4 @@
-import { ApplicationIntegrationType, InteractionContextType } from 'discord.js';
+import { InteractionContextType, ApplicationIntegrationType } from 'discord.js';
 
 /**
  * Reports where an interaction happened and whether the bot is present there.
@@ -26,36 +26,47 @@ import { ApplicationIntegrationType, InteractionContextType } from 'discord.js';
  *
  * @group Utilities
  */ function getInstallContext(interaction) {
-    const owners = interaction.authorizingIntegrationOwners ?? {};
-    const guildInstalled = owners[ApplicationIntegrationType.GuildInstall] !== undefined;
-    const userInstalled = owners[ApplicationIntegrationType.UserInstall] !== undefined;
+    const botInstalled = isBotInstalled(interaction);
     switch(interaction.context){
         case InteractionContextType.BotDM:
             return {
                 where: 'bot-dm',
-                botInstalled: true
+                botInstalled
             };
         case InteractionContextType.PrivateChannel:
             return {
                 where: 'private-channel',
-                botInstalled: false
+                botInstalled
             };
         case InteractionContextType.Guild:
-            // With no owners reported, the interaction came through the bot, as every interaction did before user installs.
             return {
                 where: 'guild',
-                botInstalled: guildInstalled || !userInstalled
+                botInstalled
             };
         default:
-            // Discord omits the context for interactions it created before contexts existed, which reached only the bot.
-            return interaction.guildId ? {
-                where: 'guild',
-                botInstalled: true
-            } : {
-                where: 'bot-dm',
-                botInstalled: true
+            return {
+                where: interaction.guildId ? 'guild' : 'bot-dm',
+                botInstalled
             };
     }
 }
+/**
+ * Whether the bot is present where an interaction happened, as {@link getInstallContext} reports it, read from Discord's
+ * `context` and the integrations that authorized it alone: no `guildId`, which only `where` needs.
+ */ function isBotInstalled(interaction) {
+    switch(interaction.context){
+        case InteractionContextType.PrivateChannel:
+            return false;
+        case InteractionContextType.Guild:
+            {
+                const owners = interaction.authorizingIntegrationOwners ?? {};
+                // With no owners reported, the interaction came through the bot, as every interaction did before user installs
+                return owners[ApplicationIntegrationType.GuildInstall] !== undefined || owners[ApplicationIntegrationType.UserInstall] === undefined;
+            }
+        default:
+            // A DM with the bot, or an interaction from before contexts existed, which reached only the bot
+            return true;
+    }
+}
 
-export { getInstallContext };
+export { getInstallContext, isBotInstalled };

package/dist/esm/common/response/presenter.js

@@ -24,8 +24,12 @@ import { shared } from '../../util/shared-state.util.js';
 /** The id MeoCord gives the containers it renders, so a view left behind can be found again. */ const RENDERED_CONTAINER_ID = 0x4d43;
 // Shared by both builds of this version, so either answers with the app's presenter
 const presenters = shared('clientPresenters', ()=>new WeakMap());
-/** Sets the presenter for the interactions a client receives. */ function setPresenter(client, presenter) {
-    presenters.set(client, presenter);
+/** Sets the presenter for the interactions a client receives; without one, they take the default. */ function setPresenter(client, presenter) {
+    if (presenter) presenters.set(client, presenter);
+    else presenters.delete(client);
+}
+/** The presenter set on a client, if any. */ function clientPresenter(client) {
+    return presenters.get(client);
 }
 /** The presenter for an interaction's client, or the default one. */ function presenterFor(client) {
     return client && presenters.get(client) || defaultPresenter;
@@ -185,4 +189,4 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
     };
 }
 
-export { ATTACHMENT_LIMIT, DEFAULT_ATTACHMENT_SIZE_LIMIT, REFUSED_AS_TOO_LARGE, RENDERED_CONTAINER_ID, TEXT_LIMITS, attachmentsOf, defaultPresenter, filesProblem, fitText, isTooLarge, presentedMessage, presenterFor, renderContainer, renderEmbed, setPresenter, withSendableFiles, withoutFiles };
+export { ATTACHMENT_LIMIT, DEFAULT_ATTACHMENT_SIZE_LIMIT, REFUSED_AS_TOO_LARGE, RENDERED_CONTAINER_ID, TEXT_LIMITS, attachmentsOf, clientPresenter, defaultPresenter, filesProblem, fitText, isTooLarge, presentedMessage, presenterFor, renderContainer, renderEmbed, setPresenter, withSendableFiles, withoutFiles };