meocord 4.1.2 → 4.2.1

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

@@ -0,0 +1,36 @@
+/**
+ * How a package kept out of the bundle is loaded, by how the bundle asks for it: an ESM `import` becomes a dynamic
+ * `import()` where its importer runs, rather than one hoisted above the pre-entry, so the package loads after the
+ * platform check and after the config has loaded `.env`; a CommonJS `require` stays a `require` at its call site, which
+ * returns the module rather than the promise a dynamic import would.
+ */ function externalType(request, dependencyType) {
+    return `${dependencyType === 'commonjs' ? 'node-commonjs' : 'import'} ${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`
+ * and `externals` give them, and a function's untyped result. An object's entries are left as they are.
+ */ 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);
+            return (data, callback)=>{
+                const { request, dependencyType } = data;
+                if (request && matches(request)) return callback(null, externalType(request, dependencyType));
+                callback();
+            };
+        }
+        if (typeof item !== 'function') return item;
+        const original = item;
+        return (data, callback)=>{
+            const finish = (result)=>callback(null, typeof result === 'string' && !typed(result) ? externalType(result, data.dependencyType) : result);
+            // Callback style, as MeoCord's own native externals are, or a promise
+            if (original.length >= 2) {
+                return original(data, (error, result)=>error ? callback(error) : finish(result));
+            }
+            Promise.resolve(original(data)).then(finish, callback);
+        };
+    });
+}
+
+export { externalType, typeExternals };

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

@@ -254,9 +254,17 @@
             };
         });
     }
-    /** Drops the keys whose calls have all left their window, once a minute from the store's first call. */ startSweeping() {
+    /**
+   * Drops the keys whose calls have all left their window, once a minute from a call, until a sweep leaves none: an
+   * idle store then holds no timer, so one nothing references is collected, and its next call starts the sweep again.
+   */ startSweeping() {
         if (this.sweeper) return;
-        this.sweeper = setInterval(()=>sweep(this.calls, Date.now()), SWEEP_INTERVAL_MS);
+        this.sweeper = setInterval(()=>{
+            sweep(this.calls, Date.now());
+            if (this.calls.size > 0) return;
+            clearInterval(this.sweeper);
+            this.sweeper = undefined;
+        }, SWEEP_INTERVAL_MS);
         // A cooldown must never be what keeps a stopping bot alive.
         this.sweeper.unref?.();
     }

package/dist/esm/common/decorator.js

@@ -1,7 +1,7 @@
 import { warnDeprecated } from './deprecation.js';
 import { Logger } from './logger.js';
 import { MetadataKey } from '../enum/metadata-key.enum.js';
-import { refuse, decoratedName } from '../util/refusal.util.js';
+import { declaring, refuse, decoratedName } from '../util/refusal.util.js';
 
 /**
  * Composes several class or method decorators into one.
@@ -30,9 +30,9 @@ import { refuse, decoratedName } from '../util/refusal.util.js';
  *
  * @group Utilities
  * @see {@link createMetadata}
- * @see {@link https://meocord.dev/docs/4.1/custom-decorators | Custom decorators}
+ * @see {@link https://meocord.dev/docs/4.2/custom-decorators | Custom decorators}
  */ function applyDecorators(...decorators) {
-    return function(target, propertyKey, descriptor) {
+    return declaring(function(target, propertyKey, descriptor) {
         // Last first, as TypeScript applies decorators stacked, each given what the one before it returned
         const ordered = [
             ...decorators
@@ -45,7 +45,7 @@ import { refuse, decoratedName } from '../util/refusal.util.js';
         let current = target;
         for (const decorator of ordered)current = decorator(current) ?? current;
         return current;
-    };
+    });
 }
 const logger = new Logger('SetMetadata');
 /** The prefix of every key MeoCord keeps its own metadata under. */ const MEOCORD_PREFIX = 'meocord:';
@@ -84,7 +84,7 @@ const logger = new Logger('SetMetadata');
  * @see {@link createMetadata}
  */ function SetMetadata(metadataKey, metadataValue) {
     warnDeprecated(logger, 'SetMetadata', 'createMetadata');
-    return function(target, propertyKey) {
+    return declaring(function(target, propertyKey) {
         // Checked where it applies, so the refusal names the handler or controller
         const owner = metadataKey.startsWith(MEOCORD_PREFIX) ? `MeoCord keeps its own metadata under keys beginning "${MEOCORD_PREFIX}"` : INJECTION_KEYS.has(metadataKey) ? 'dependency injection reads how to make the class from it' : undefined;
         if (owner) {
@@ -95,7 +95,7 @@ const logger = new Logger('SetMetadata');
         } else {
             Reflect.defineMetadata(metadataKey, metadataValue, target);
         }
-    };
+    });
 }
 
 export { SetMetadata, applyDecorators };

package/dist/esm/common/deprecation.js

@@ -14,10 +14,10 @@ const warned = new Set();
  */ function warnPlaceholder(logger, value, outcome, how) {
     warnOnce(logger, `${value} reads a placeholder here; in the next major version (5.0) ${outcome}. ${how}`);
 }
-function warnOnce(logger, text) {
+/** Logs `text` once per run, however often it is asked for. */ function warnOnce(logger, text) {
     if (warned.has(text)) return;
     warned.add(text);
     logger.warn(text);
 }
 
-export { warnDeprecated, warnDeprecatedBehaviour, warnPlaceholder };
+export { warnDeprecated, warnDeprecatedBehaviour, warnOnce, warnPlaceholder };

package/dist/esm/common/errors.js

@@ -1,4 +1,5 @@
 import { renderText } from './meocord-text.js';
+import { sharedKey } from '../util/shared-state.util.js';
 
 /**
  * Thrown by a guard to deny a call and tell the user why.
@@ -90,7 +91,7 @@ import { renderText } from './meocord-text.js';
  * @group Responses
  * @category Errors
  * @see {@link Catch}
- * @see {@link https://meocord.dev/docs/4.1/exception-filters | Exception filters}
+ * @see {@link https://meocord.dev/docs/4.2/exception-filters | Exception filters}
  */ class CommandNotFoundError extends Error {
     /** @param message - What the error says, `No handler matched the interaction.` unless given. */ constructor(message = 'No handler matched the interaction.'){
         super(message);
@@ -163,7 +164,7 @@ import { renderText } from './meocord-text.js';
  * @category Errors
  * @see {@link MessageHandler}
  * @see {@link translateError}
- * @see {@link https://meocord.dev/docs/4.1/message-commands | Message commands}
+ * @see {@link https://meocord.dev/docs/4.2/message-commands | Message commands}
  */ class MessageUsageError extends Error {
     /**
    * @param usage - The command as the user should type it, such as `!ban <target> [reason…]`, or one line per
@@ -330,5 +331,29 @@ import { renderText } from './meocord-text.js';
         this.name = 'CooldownStoreError';
     }
 }
+/**
+ * Makes `instanceof` hold for an error from either build of this meocord version, ES module or CommonJS: the class's
+ * prototype carries a brand both builds share, which `instanceof` on the class itself checks. A subclass, such as an
+ * app's own `UserError`, keeps the usual check, so it still matches only its own instances.
+ */ function brand(error, name) {
+    const key = sharedKey(`error:${name}`);
+    Object.defineProperty(error.prototype, key, {
+        value: true
+    });
+    Object.defineProperty(error, Symbol.hasInstance, {
+        value (value) {
+            if (this !== error) return Function.prototype[Symbol.hasInstance].call(this, value);
+            return (typeof value === 'object' || typeof value === 'function') && value !== null && key in value;
+        }
+    });
+}
+// Named as written, since a minifier may rename the classes themselves
+brand(GuardDeniedError, 'GuardDeniedError');
+brand(UserError, 'UserError');
+brand(CommandNotFoundError, 'CommandNotFoundError');
+brand(ValidationError, 'ValidationError');
+brand(MessageUsageError, 'MessageUsageError');
+brand(CooldownError, 'CooldownError');
+brand(CooldownStoreError, 'CooldownStoreError');
 
 export { CommandNotFoundError, CooldownError, CooldownStoreError, GuardDeniedError, MessageUsageError, UserError, ValidationError, cooldownMessage, cooldownStoreMessage, cooldownText, usageHeading };

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

@@ -33,7 +33,7 @@ import { useTheme } from '../core/theme-scope.js';
  * @group Utilities
  * @see {@link createMetadata}
  * @see {@link StageParams}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ class ExecutionContext {
     /**
    * The response state of the interaction being handled, the same one `respond(interaction)` returns,

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

@@ -1,5 +1,6 @@
 import { fillPlaceholders, pluralForm, lookup, languageOf, LOCALE_CHAIN, CATALOGS } from './translator.js';
 import { MEOCORD_MESSAGES } from './meocord-messages.js';
+import { shared } from '../util/shared-state.util.js';
 
 const hasCatalogs = (translator)=>translator !== undefined && CATALOGS in translator && LOCALE_CHAIN in translator;
 const ENGLISH = 'en-US';
@@ -31,16 +32,17 @@ const ENGLISH = 'en-US';
     return english();
 }
 const lists = new Map();
-/** A list in a locale's words: "a, b, or c" in en-US, or, for a unit, "a, b, c". */ function listIn(locale, style, items) {
-    let format = lists.get(`${locale} ${style}`);
-    if (!format) lists.set(`${locale} ${style}`, format = new Intl.ListFormat(locale, {
-        type: style === 'or' ? 'disjunction' : 'unit'
+/** An `or` list in a locale's words, such as "a, b, or c" in en-US. */ function orListIn(locale, items) {
+    let format = lists.get(locale);
+    if (!format) lists.set(locale, format = new Intl.ListFormat(locale, {
+        type: 'disjunction'
     }));
     return format.format(items);
 }
 /**
- * A text in `locale`, as {@link findText} finds it. A list in MeoCord's English is joined with its `joiner`, a comma
- * unless given; in an app's catalog, in the words of the locale that has it.
+ * A text in `locale`, as {@link findText} finds it. An `or` list in an app's catalog reads in the words of the locale
+ * 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;
@@ -49,14 +51,15 @@ const lists = new Map();
         if (!Object.hasOwn(params, name)) return whole;
         const value = params[name];
         if (typeof value !== 'object') return String(value);
-        if ('list' in value) return found.own ? listIn(found.locale, value.style, value.list) : value.list.join(value.joiner ?? ', ');
+        if ('list' in value) return found.own && value.style === 'or' ? orListIn(found.locale, value.list) : value.list.join(value.joiner ?? ', ');
         return renderText(translator, locale, value);
     });
 }
 /** Renders texts in one locale through one translator: a word or number as it is, a text in the locale's words. */ function textRenderer(translator, locale) {
     return (text)=>typeof text !== 'object' ? String(text) : 'list' in text ? text.list.join(text.joiner ?? ', ') : renderText(translator, locale, text);
 }
-const translators = new WeakMap();
+// Shared by both builds of this version, so either answers in the app's language
+const translators = shared('clientTranslators', ()=>new WeakMap());
 /** Records the translator of the app a client's interactions and messages come to. */ function registerClientTranslator(client, translator) {
     if (translator) translators.set(client, translator);
     else translators.delete(client);

package/dist/esm/common/metadata.js

@@ -31,7 +31,7 @@ import 'reflect-metadata';
  *
  * @group Utilities
  * @see {@link ExecutionContext}
- * @see {@link https://meocord.dev/docs/4.1/guards | Guards}
+ * @see {@link https://meocord.dev/docs/4.2/guards | Guards}
  */ function createMetadata(description) {
     const key = Symbol(description);
     const decorator = (value)=>function(target, propertyKey) {

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() {
@@ -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');
 /**
@@ -14,6 +16,10 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
             decodeSegment(value)
         ]));
 }
+/** The segment types whose value is text, which `build` takes only as a string. */ const TEXT_TYPES = new Set([
+    'snowflake',
+    'uuid'
+]);
 /**
  * Makes a typed route from a customId pattern, so one declaration serves the handler and the ids that reach it.
  *
@@ -26,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.
  *
@@ -48,9 +55,12 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
  *
  * @group Utilities
  * @see {@link Route}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function 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));
@@ -60,6 +70,11 @@ const PLACEHOLDER = /\{(\w+)(?::([^}/]*))?}/g;
             const value = Object.hasOwn(values, name) ? values[name] : undefined;
             const type = Object.hasOwn(types, name) ? types[name] : undefined;
             if (value === undefined || value === null) throw new TypeError(`route('${pattern}').build() needs a value for ${placeholder}.`);
+            // A snowflake's or uuid's value is its text: a number for a snowflake may have lost digits before it got here
+            if (type && TEXT_TYPES.has(type) && typeof value !== 'string') {
+                const lost = type === 'snowflake' ? ' A number may have lost digits already: pass the ID as text, such as user.id.' : '';
+                throw new TypeError(`route('${pattern}').build() got the ${typeof value} ${String(value)} for ${placeholder}, which takes its value as a string.${lost}`);
+            }
             const text = String(value);
             if (text === '') throw new TypeError(`route('${pattern}').build() got an empty {${name}}, which no customId segment can hold.`);
             // A typed segment must read back as the value it was built from, or the route could never match it
@@ -69,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}".`);
         }
@@ -81,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/translate-error.js

@@ -58,7 +58,7 @@ import { interactionLocale, messageLocale, textOfIssue, renderText } from './meo
  * @group Utilities
  * @category Localisation
  * @see {@link createTranslator}
- * @see {@link https://meocord.dev/docs/4.1/localisation | Localisation}
+ * @see {@link https://meocord.dev/docs/4.2/localisation | Localisation}
  */ function translateError(error, t, target) {
     const locale = target instanceof BaseInteraction ? interactionLocale(target) : target instanceof Message ? messageLocale(target) : target;
     return errorText(error, t, locale);