meocord 4.2.0 → 4.2.2

package/dist/esm/common/response/call-order.js

@@ -1,10 +1,15 @@
-let last = 0;
-const order = new WeakMap();
+import { shared } from '../../util/shared-state.util.js';
+
+// One count for both builds of this version, so calls either makes merge in the order made
+const calls = shared('callOrder', ()=>({
+        last: 0,
+        order: new WeakMap()
+    }));
 /** Marks a Discord call as made now, so calls recorded in different places can be merged in the order made. */ function stampCall(call) {
-    order.set(call, ++last);
+    calls.order.set(call, ++calls.last);
 }
 /** When a call stamped by {@link stampCall} was made, relative to the others. */ function callOrder(call) {
-    return order.get(call) ?? 0;
+    return calls.order.get(call) ?? 0;
 }
 
 export { callOrder, stampCall };

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

@@ -1,5 +1,6 @@
 import { EmbedBuilder, ContainerBuilder, resolveColor, TextDisplayBuilder, SectionBuilder, ThumbnailBuilder, MediaGalleryBuilder, FileBuilder, ComponentType, AttachmentBuilder } from 'discord.js';
 import { renderText, translatorOfClient } from '../meocord-text.js';
+import { shared } from '../../util/shared-state.util.js';
 
 /** One of the presenter's texts, in the context's locale through the app's translator; English for a context without one. */ const text = ({ interaction, locale }, key)=>renderText(translatorOfClient(interaction?.client), locale, {
         key
@@ -21,16 +22,41 @@ import { renderText, translatorOfClient } from '../meocord-text.js';
         })
 };
 /** The id MeoCord gives the containers it renders, so a view left behind can be found again. */ const RENDERED_CONTAINER_ID = 0x4d43;
-const presenters = new WeakMap();
+// 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);
 }
 /** The presenter for an interaction's client, or the default one. */ function presenterFor(client) {
     return client && presenters.get(client) || defaultPresenter;
 }
-function textOf(view) {
-    return view.emoji ? `${view.emoji} ${view.text}` : view.text;
+/** Discord's limits on a message's text, counted by `String.length` as discord.js's builders count them. */ const TEXT_LIMITS = {
+    embed: 4096,
+    v2: 4000,
+    content: 2000
+};
+/** `text` cut to `limit` characters ending in `…`, on a code point boundary so no surrogate pair is split. */ function fitText(text, limit) {
+    if (text.length <= limit) return text;
+    let cut = text.slice(0, Math.max(0, limit - 1));
+    const last = cut.charCodeAt(cut.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff) cut = cut.slice(0, -1);
+    return `${cut}…`;
+}
+/**
+ * An error's message as a presenter is given it: fitted to `limit`, and, when empty or only whitespace, which Discord
+ * refuses as a text, MeoCord's generic error text, so a presenter that writes it as its text always renders.
+ */ function presentedMessage(message, limit, generic) {
+    return fitText(message.trim() === '' ? generic() : message, limit);
+}
+/**
+ * The view's text after what MeoCord puts before it, its emoji and a Text Display's title line. When only those take
+ * the two past `limit`, the text is cut so they fit; a text past `limit` by itself is left, a view MeoCord can't render.
+ */ function textAfter(prefix, view, limit) {
+    const total = prefix.length + view.text.length;
+    if (total <= limit || view.text.length > limit || prefix.length >= limit) return prefix + view.text;
+    return prefix + fitText(view.text, limit - prefix.length);
 }
+const emojiOf = (view)=>view.emoji ? `${view.emoji} ` : '';
 /** Discord's limit of attachments on one message. */ const ATTACHMENT_LIMIT = 10;
 /** The most items Discord shows in one media gallery. */ const MEDIA_GALLERY_LIMIT = 10;
 /**
@@ -114,7 +140,7 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
     return (view.files ?? []).filter((file)=>!shown.has(`attachment://${nameOf(file)}`));
 }
 /** A view as an embed: its image, or else its first image file not its thumbnail, as the embed's image. */ function renderEmbed(view) {
-    const embed = new EmbedBuilder().setDescription(textOf(view));
+    const embed = new EmbedBuilder().setDescription(textAfter(emojiOf(view), view, TEXT_LIMITS.embed));
     if (view.title) embed.setTitle(view.title);
     if (view.color !== undefined) embed.setColor(view.color);
     const image = view.image ?? unshownFiles(view).map(nameOf).find((name)=>IMAGE.test(name));
@@ -125,7 +151,8 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
 /** A view as a Components V2 container, carrying MeoCord's id. */ function renderContainer(view) {
     const container = new ContainerBuilder().setId(RENDERED_CONTAINER_ID);
     if (view.color !== undefined) container.setAccentColor(resolveColor(view.color));
-    const text = new TextDisplayBuilder().setContent(view.title ? `### ${view.title}\n${textOf(view)}` : textOf(view));
+    const titleLine = view.title ? `### ${view.title}\n` : '';
+    const text = new TextDisplayBuilder().setContent(textAfter(titleLine + emojiOf(view), view, TEXT_LIMITS.v2));
     if (view.thumbnail) {
         container.addSectionComponents(new SectionBuilder().addTextDisplayComponents(text).setThumbnailAccessory(new ThumbnailBuilder().setURL(urlOf(view, view.thumbnail))));
     } else container.addTextDisplayComponents(text);
@@ -158,4 +185,4 @@ const IMAGE = /\.(png|jpe?g|gif|webp)$/i;
     };
 }
 
-export { ATTACHMENT_LIMIT, DEFAULT_ATTACHMENT_SIZE_LIMIT, REFUSED_AS_TOO_LARGE, RENDERED_CONTAINER_ID, attachmentsOf, defaultPresenter, filesProblem, isTooLarge, presenterFor, renderContainer, renderEmbed, setPresenter, withSendableFiles, withoutFiles };
+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 };

package/dist/esm/common/response/response-state.js

@@ -8,12 +8,13 @@ import { describeInteraction } from '../../util/interaction.util.js';
 import { getInstallContext } from './install-context.js';
 import { resolveFlags, flagNames, hasEphemeral, hasComponentsV2 } from './flags.js';
 import { rewriteAttachmentUrls, keptAttachmentNames } from './attachments.js';
-import { renderEmbed, isTooLarge, REFUSED_AS_TOO_LARGE, withoutFiles, renderContainer, attachmentsOf, withSendableFiles, presenterFor, defaultPresenter, DEFAULT_ATTACHMENT_SIZE_LIMIT } from './presenter.js';
+import { renderEmbed, isTooLarge, REFUSED_AS_TOO_LARGE, withoutFiles, renderContainer, attachmentsOf, withSendableFiles, presenterFor, presentedMessage, TEXT_LIMITS, defaultPresenter, DEFAULT_ATTACHMENT_SIZE_LIMIT } from './presenter.js';
 import { sameEmbed, withoutRenderedViews, lockComponents, countComponents, V2_COMPONENT_LIMIT, EMBED_LIMIT } from './components.js';
 import { stampCall } from './call-order.js';
 import { isUserOutcome } from '../user-outcome.js';
 import { themeForInteraction } from '../../core/theme-scope.js';
 import { LOADING_DRAW_TIMEOUT_MS } from '../../core/theme-resolvers.js';
+import { shared } from '../../util/shared-state.util.js';
 
 const ALREADY_ACKNOWLEDGED = 40060;
 /** Discord's code for an interaction it no longer knows, such as one past its three seconds unacknowledged. */ const UNKNOWN_INTERACTION = 10062;
@@ -55,7 +56,8 @@ function toBody(payload) {
  */ function editedSince(stamp, ours) {
     return typeof stamp === 'number' && ours !== undefined && stamp > ours;
 }
-const messageLocks = new Map();
+// Both builds of this meocord version keep one, so a message one locks, the other sees locked
+const messageLocks = shared('messageLocks', ()=>new Map());
 /** How long a locked message is remembered once no call holds it. */ const LOCK_MEMORY_MS = 60000;
 /**
  * A body with the theme's primary colour where the app left one unset: an embed with no `color`, and a
@@ -117,9 +119,12 @@ function toJson(value) {
         return this.phase;
     }
     get message() {
+        // A deleted answer, or a follow-up in its place, leaves the component's own message behind
+        if (this.answer.kind !== 'original') return this.lastMessage;
         return this.lastMessage ?? ('message' in this.interaction ? this.interaction.message ?? undefined : undefined);
     }
     get original() {
+        // Each component is a top-level component's API JSON, as `toJSON()` gave it; the lock reads them as plain JSON
         return this.snapshot;
     }
     /** The Discord calls made through this state, for tests. */ get history() {
@@ -409,15 +414,15 @@ function toJson(value) {
         });
     }
     /**
-   * Undoes `@Defer`'s acknowledgement after a guard denied the call silently: a command's deferred
-   * reply is deleted while nothing was sent into it; a component's invisible acknowledgement needs
-   * nothing. Never throws.
+   * Ends a call a guard denied silently. A component still unanswered is acknowledged invisibly, with or without
+   * `@Defer`, since Discord tells the user an unanswered call failed; so is a command `@Defer`'s 'auto' timer was
+   * waiting on, whose deferred reply is then deleted, as `@Defer`'s is while nothing was sent into it. Never throws.
    */ abandon() {
         const waiting = this.timer !== undefined;
         this.cancelScheduled();
         return this.queued(async ()=>{
-            // Denied before the 'auto' timer: acknowledged here, since Discord tells the user an unanswered call failed
-            if (waiting) await this.acknowledgeUnanswered({
+            // A command's acknowledgement shows "thinking…", so one is made only for the timer that would have made it
+            if (waiting || !answersWithOwnMessage(this.interaction)) await this.acknowledgeUnanswered({
                 ephemeral: true
             });
             this.sync();
@@ -451,9 +456,11 @@ function toJson(value) {
         this.sync();
         const body = await this.themed(payload, options);
         if (this.phase === 'unanswered') return this.reply(body);
-        if (this.phase === 'deferred' && answersWithOwnMessage(this.interaction)) {
+        // Once the answer is deleted, the next message sent is the answer
+        if (this.answer.kind === 'deleted') return this.answerWith(body);
+        if (this.phase === 'deferred' && answersWithOwnMessage(this.interaction) && this.answer.kind === 'original') {
             // Discord makes a follow-up to a deferred, unsent reply that reply, ignoring its flags: a private one
-            // would be shown to everyone on a public deferral, so that deferral is deleted first.
+            // would be shown to everyone on a public deferral, so that deferral is deleted, and the follow-up is the answer.
             const requested = Number(MessageFlagsBitField.resolve(body.flags ?? 0));
             if (!hasEphemeral(requested)) return this.editMessage(body);
             // A private deferral is already what the flag asks for, which an edit cannot take
@@ -463,7 +470,11 @@ function toJson(value) {
             });
             await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
             this.phase = 'replied';
+            return this.answerWith(body);
         }
+        return (await this.sendFollowUp(body)).message;
+    }
+    /** Sends a follow-up, with the flags it was sent with. */ async sendFollowUp(body) {
         const flags = this.withSuppression(this.flagsFor('followUp', body.flags, false));
         const sent = forMode(body, hasComponentsV2(flags));
         const message = await this.call('followUp', {
@@ -473,6 +484,20 @@ function toJson(value) {
                 ...sent,
                 flags
             }));
+        return {
+            message: message,
+            flags
+        };
+    }
+    /** Sends a follow-up that becomes the answer, which later edits and `delete()` act on by its id. */ async answerWith(body) {
+        const { message, flags } = await this.sendFollowUp(body);
+        // Its privacy as sent, not as read back from the message
+        this.answer = {
+            kind: 'followUp',
+            id: message.id,
+            ephemeral: hasEphemeral(flags)
+        };
+        this.lastMessage = message;
         return message;
     }
     delete() {
@@ -480,7 +505,22 @@ function toJson(value) {
             this.sync();
             if (this.phase === 'unanswered') throw new Error('There is no answer to delete: the interaction has not been answered.');
             this.refuseAfterModal();
-            await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
+            const { answer } = this;
+            if (answer.kind === 'deleted') throw new Error('There is no answer to delete: it was deleted.');
+            // A follow-up is as private as it was sent, a command's own reply as the interaction's answer, a component's
+            // message as its flags
+            const shown = this.message?.flags?.has(MessageFlags.Ephemeral) ?? false;
+            const ephemeral = answer.kind === 'followUp' ? answer.ephemeral : answersWithOwnMessage(this.interaction) ? Boolean(this.interaction.ephemeral) || shown : shown;
+            if (answer.kind === 'followUp') await this.call('deleteReply', answer.id, ()=>this.interaction.deleteReply(answer.id));
+            else await this.call('deleteReply', undefined, ()=>this.interaction.deleteReply());
+            this.answer = {
+                kind: 'deleted',
+                ephemeral
+            };
+            this.lastMessage = undefined;
+            // The message is gone: nothing is left to put back as it was before a lock
+            this.settled = true;
+            this.leave();
         });
     }
     /** A modal is the interaction's whole answer: what the user enters arrives as a submit interaction of its own. */ refuseAfterModal() {
@@ -590,7 +630,20 @@ function toJson(value) {
     withAttachments(body) {
         return rewriteAttachmentUrls(body, keptAttachmentNames(body, this.message?.attachments?.values() ?? []));
     }
-    /** Edits the answer through the interaction, and through the channel only once its token has expired. */ async editMessage(body, { restoring = false } = {}) {
+    /**
+   * Edits the answer through the interaction, and through the channel only once its token has expired. Once the answer
+   * is deleted, the edit is sent as a follow-up that becomes the answer, as private as the deleted one unless it sets
+   * flags of its own.
+   */ async editMessage(body, { restoring = false } = {}) {
+        const { answer } = this;
+        if (answer.kind === 'deleted') {
+            if (restoring) return undefined;
+            const { attachments: _attachments, ...rest } = body;
+            return this.answerWith({
+                ...rest,
+                flags: body.flags ?? (answer.ephemeral ? MessageFlags.Ephemeral : 0)
+            });
+        }
         if (!restoring) {
             this.settled = true;
             this.leave();
@@ -612,8 +665,13 @@ function toJson(value) {
             ...this.withAttachments(forMode(body, this.v2)),
             flags
         };
+        // A follow-up that is the answer is edited by its id
+        const edit = answer.kind === 'followUp' ? {
+            ...sent,
+            message: answer.id
+        } : sent;
         try {
-            this.lastMessage = await this.call('editReply', sent, ()=>this.interaction.editReply(sent));
+            this.lastMessage = await this.call('editReply', edit, ()=>this.interaction.editReply(edit));
         } catch (error) {
             const message = this.message;
             const expired = Date.now() - this.interaction.createdTimestamp >= TOKEN_EXPIRED_AFTER_MS;
@@ -732,12 +790,16 @@ function toJson(value) {
    * place, and the failure is returned for the caller to report once the user is answered.
    */ async drawnView(error, message, theme) {
         const tone = isUserOutcome(error, this.interaction) ? 'warning' : 'danger';
+        const context = this.presenterContext(this.v2, theme);
+        // Fitted to the mode's limit first, so a presenter that writes the message as its text, MeoCord's own included, renders
+        const generic = ()=>textFor(this.interaction, {
+                key: 'meocord.fallback.error'
+            });
         const presented = {
-            message,
+            message: presentedMessage(message, TEXT_LIMITS[context.mode], generic),
             error,
             tone
         };
-        const context = this.presenterContext(this.v2, theme);
         const ready = (view)=>{
             const sendable = this.sendable(themedView(view, theme), this.keptBeside());
             // Rendered once here, so a view MeoCord cannot render fails before anything is sent
@@ -880,6 +942,11 @@ function toJson(value) {
             await this.followUpNow(this.privateError(view));
             return;
         }
+        // A deleted message has nothing to add the error to or put back: the error follows up, and is the answer
+        if (this.answer.kind === 'deleted') {
+            await this.followUpNow(this.privateError(view));
+            return;
+        }
         // The message the component is on: whether it is private does not change with edits.
         const current = 'message' in this.interaction ? this.interaction.message ?? undefined : this.message;
         if (current?.flags?.has(MessageFlags.Ephemeral)) {
@@ -925,6 +992,12 @@ function toJson(value) {
         /** The answer steps asked for, run one after another; `pending` counts those not yet settled. */ this.queue = Promise.resolve();
         this.pending = 0;
         /** Whether the answer was a modal, which has no message to edit or delete. */ this.modalShown = false;
+        /**
+   * Which message is the answer: the interaction's own reply, a follow-up that took its place, or none since `delete()`,
+   * with whether the deleted one was private. `sync()` leaves it alone, so every edit follows it.
+   */ this.answer = {
+            kind: 'original'
+        };
         this.calls = [];
         /** Whether the interaction was acknowledged with a private deferred reply for a drawn error view, which that view replaces. */ this.privateDeferral = false;
         /** Whether the locked message was answered, so nothing restores it again. */ this.settled = false;
@@ -936,7 +1009,8 @@ function toJson(value) {
         this.v2 = Boolean(message?.flags?.has(MessageFlags.IsComponentsV2));
     }
 }
-const states = new WeakMap();
+// One state per interaction for both builds of this version, so either sees where the other left its answer
+const states = shared('responseStates', ()=>new WeakMap());
 /** The response state of a repliable interaction, created on first use. */ function responseOf(interaction) {
     let state = states.get(interaction);
     if (!state) states.set(interaction, state = new InteractionResponse(interaction));

package/dist/esm/common/route.js

@@ -1,7 +1,9 @@
-import { createRegexFromPattern } from '../decorator/controller.decorator.js';
+import { createRegexFromPattern, literalBraces, MAX_CUSTOM_ID_LENGTH } from '../decorator/controller.decorator.js';
 import { parseSegment } from '../core/scalar-types.js';
+import { Logger } from './logger.js';
+import { warnOnce } from './deprecation.js';
 
-/** The longest customId Discord accepts. */ const MAX_CUSTOM_ID_LENGTH = 100;
+const logger = new Logger('Route');
 const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
 /** Encodes the characters that would end a param's segment, or read as an encoding, in a customId. */ const encodeSegment = (value)=>value.replace(/%/g, '%25').replace(/\//g, '%2F');
 /**
@@ -30,7 +32,8 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
  * fails to compile, and a typed param takes a value of its type.
  *
  * @param pattern - The customId pattern, where `{name}` captures one `/`-separated segment and `{name:int}` a
- *   typed one.
+ *   typed one. A param's name is ASCII letters, digits and _: a brace pair such as `{café}` is literal text, and is
+ *   warned about.
  * @returns A route whose `build` takes a value for each param.
  * @throws Error when the pattern cannot be read, as `@Command` would throw for it.
  *
@@ -55,6 +58,9 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
  * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function route(pattern) {
     const { params, types } = createRegexFromPattern(pattern);
+    const braces = literalBraces(pattern);
+    // Once per pattern, as a route made inside a handler is made on every call
+    if (braces) warnOnce(logger, `Pattern "${pattern}": ${braces}`);
     const names = new Set(params);
     const build = (values = {})=>{
         const unknown = Object.keys(values).filter((name)=>!names.has(name));
@@ -78,6 +84,7 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
             }
             return encodeSegment(text);
         });
+        if (id === '') throw new RangeError(`route('${pattern}').build() made an empty customId; Discord's customIds are 1 to ${MAX_CUSTOM_ID_LENGTH} characters.`);
         if (id.length > MAX_CUSTOM_ID_LENGTH) {
             throw new RangeError(`route('${pattern}').build() made a customId of ${id.length} characters, over Discord's ${MAX_CUSTOM_ID_LENGTH}: "${id}".`);
         }
@@ -90,4 +97,4 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
     });
 }
 
-export { MAX_CUSTOM_ID_LENGTH, decodeRouteParams, route };
+export { decodeRouteParams, route };

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

@@ -9,7 +9,7 @@ import { isShardProcess } from '../util/shard-process.util.js';
  * never held forever. MeoCord itself fails the call after `cooldownStoreTimeoutMs`, a second by default.
  */ const SHARDED_COOLDOWN_ABANDON_MS = 30000;
 /** A shard's channel to its manager, or none outside process sharding. */ function managerChannel() {
-    return isShardProcess() && typeof process.send === 'function' ? channelOver(process) : undefined;
+    return isShardProcess(process.env) && typeof process.send === 'function' ? channelOver(process) : undefined;
 }
 /**
  * The channel over a process's IPC. A send on a closed channel does not throw: without a callback, Node raises an

package/dist/esm/common/translator.js

@@ -1,6 +1,7 @@
 import { Locale } from 'discord.js';
 import { refuse } from '../util/refusal.util.js';
 import { Logger } from './logger.js';
+import { sharedName } from '../util/shared-state.util.js';
 
 /**
  * Declares a message catalog, keeping each message's text as its type so the params it takes can be checked.
@@ -61,23 +62,33 @@ import { Logger } from './logger.js';
 /**
  * Where a translator made by `createTranslator` keeps its catalogs, for MeoCord's texts, `@MeoCord` and
  * `expectCompleteCatalog`.
- */ const CATALOGS = Symbol('catalogs');
-/** How MeoCord's own texts read a translator made by `createTranslator`: the catalogs that serve a locale, in order. */ const LOCALE_CHAIN = Symbol('localeChain');
+ */ const CATALOGS = Symbol.for(sharedName('translator:catalogs'));
+/** How MeoCord's own texts read a translator made by `createTranslator`: the catalogs that serve a locale, in order. */ const LOCALE_CHAIN = Symbol.for(sharedName('translator:localeChain'));
 /** For a class that injects `Translator` in an app that configured none. */ function missingTranslatorError(cls) {
     return new Error(`${cls.name}: it injects Translator, but @MeoCord has no i18n. Pass @MeoCord({ i18n: t }), where t comes from createTranslator.`);
 }
 const DISCORD_LOCALES = new Set(Object.values(Locale));
 const languageOf = (locale)=>locale.split('-')[0];
-/** A message by its dotted key, or undefined when the catalog lacks it or the key names a group. */ function lookup(catalog, key) {
+const PLURAL_CATEGORIES = new Set([
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other'
+]);
+/** A plural's shape: a non-empty object whose every key is a plural category, as the types read one; any other is a group. */ const isPluralShape = (value)=>typeof value === 'object' && value !== null && Object.keys(value).length > 0 && Object.keys(value).every((key)=>PLURAL_CATEGORIES.has(key));
+/**
+ * A message by its dotted key, or undefined when the catalog lacks it or the key names a group. A plural without an
+ * `other` form reads as missing, so a translation that left it out falls back to the next catalog.
+ */ function lookup(catalog, key) {
     let current = catalog;
     for (const part of key.split('.')){
         if (typeof current !== 'object' || current === null) return undefined;
         current = current[part];
     }
     if (typeof current === 'string') return current;
-    if (typeof current === 'object' && current !== null && typeof current.other === 'string') {
-        return current;
-    }
+    if (isPluralShape(current) && typeof current.other === 'string') return current;
     return undefined;
 }
 const plurals = new Map();
@@ -109,6 +120,22 @@ function interpolate(message, params) {
     }
     return typeof current === 'object' && current !== null;
 }
+/** The locale Discord shows a locale's users when that locale has no localization of its own, by its locale fallbacks. */ const FALLBACK_PARTNERS = {
+    [Locale.EnglishUS]: Locale.EnglishGB,
+    [Locale.EnglishGB]: Locale.EnglishUS,
+    [Locale.SpanishLATAM]: Locale.SpanishES
+};
+/** Each key with a `.` in it, which `lookup` splits as a path and so never reaches, with the group it sits in. */ function dottedKeys(catalog, group = '') {
+    return Object.entries(catalog).flatMap(([name, value])=>[
+            ...name.includes('.') ? [
+                {
+                    name,
+                    group
+                }
+            ] : [],
+            ...typeof value === 'object' && value !== null ? dottedKeys(value, group ? `${group}.${name}` : name) : []
+        ]);
+}
 class CatalogTranslator extends Translator {
     /** The catalogs that serve a locale, most specific first, ending with the default. */ [LOCALE_CHAIN](requested) {
         const chain = [];
@@ -127,10 +154,13 @@ class CatalogTranslator extends Translator {
     translate(requested, key, params = {}) {
         for (const locale of this[LOCALE_CHAIN](requested)){
             const message = lookup(this.catalogs[locale], key);
-            if (message !== undefined) return interpolate(pluralForm({
+            if (message === undefined) continue;
+            // An empty translation, as tools export an untranslated string, counts as missing: Discord refuses an empty reply
+            const text = pluralForm({
                 message,
                 locale
-            }, params.count), params);
+            }, params.count);
+            if (text !== '') return interpolate(text, params);
         }
         this.warnUnknown(key);
         return key;
@@ -160,11 +190,16 @@ class CatalogTranslator extends Translator {
         for (const locale of this.locales){
             if (locale === this.defaultLocale) continue;
             const message = lookup(this.catalogs[locale], key);
-            // A translation with a {param} is left out: Discord would show it as written
-            if (typeof message === 'string' && placeholderNames(message).length === 0) {
+            // A translation with a {param} is left out, as Discord would show it as written, and so is an empty one
+            if (typeof message === 'string' && message !== '' && placeholderNames(message).length === 0) {
                 localized[locale] = fillPlaceholders(message, (_name, whole)=>whole);
             }
         }
+        // Discord gives a locale it falls back from its partner's value, so the default keeps its own wording beside one
+        const partner = FALLBACK_PARTNERS[this.defaultLocale];
+        if (partner && localized[partner] !== undefined && typeof original === 'string' && original !== '') {
+            localized[this.defaultLocale] = fillPlaceholders(original, (_name, whole)=>whole);
+        }
         return localized;
     }
     for(interaction, options = {}) {
@@ -243,8 +278,14 @@ class CatalogTranslator extends Translator {
         }
     }
     if (!locales[defaultLocale]) throw refuse(new Error(`The default locale "${defaultLocale}" has no catalog in locales.`));
+    const logger = new Logger('Translator');
+    for (const [locale, catalog] of Object.entries(locales)){
+        for (const { name, group } of dottedKeys(catalog)){
+            logger.warn(`The ${locale} catalog's key "${name}"${group ? ` in ${group}` : ''} has a ".", which a lookup reads as a path, so its ` + 'message is never found. Nest it as a group instead.');
+        }
+    }
     // Typed by the default catalog; at runtime every catalog is read the same way.
     return new CatalogTranslator(defaultLocale, locales);
 }
 
-export { CATALOGS, LOCALE_CHAIN, Translator, createTranslator, defineCatalog, fillPlaceholders, languageOf, lookup, missingTranslatorError, placeholderNames, pluralForm };
+export { CATALOGS, LOCALE_CHAIN, Translator, createTranslator, defineCatalog, fillPlaceholders, isPluralShape, languageOf, lookup, missingTranslatorError, placeholderNames, pluralForm };