chapterjs 0.4.0 → 0.5.0

package/dist/commands/declaration.js

@@ -40,6 +40,7 @@ const OPTION_KEYS = {
     channel: ['channelTypes'],
 };
 const COMMAND_KEYS = [
+    'type',
     'name',
     'description',
     'options',
@@ -52,6 +53,20 @@ const COMMAND_KEYS = [
     'autocomplete',
     'run',
 ];
+const MENU_KEYS = [
+    'type',
+    'name',
+    'locales',
+    'permissions',
+    'where',
+    'nsfw',
+    'ephemeral',
+    'cooldown',
+    'run',
+];
+const MENU_TYPES = ['message', 'user'];
+/** The longest name of a menu command. */
+const MAX_MENU_NAME = 32;
 /** The kinds of options whose suggestions can come from the bot. */
 const SUGGESTABLE_TYPES = ['string', 'integer', 'number'];
 const fail = (message) => {
@@ -411,11 +426,91 @@ export function readCommandName(name) {
     }
     return parts;
 }
+/**
+ * The name of a menu command: what the menu shows, 1 to 32 characters,
+ * capitals and spaces included.
+ * @see https://docs.discord.com/developers/interactions/application-commands#application-command-object-application-command-naming
+ */
+function readMenuName(name, what) {
+    if (typeof name !== 'string' || name.trim() === '') {
+        return fail(`${what} has no "name": what the menu shows, like name: 'Report message'.`);
+    }
+    if (name !== name.trim()) {
+        return fail(`The name ${JSON.stringify(name)} of ${what} starts or ends with a space: remove it.`);
+    }
+    if ([...name].length > MAX_MENU_NAME) {
+        return fail(`The name ${JSON.stringify(name)} of ${what} is ${[...name].length} characters long: Discord accepts ${MAX_MENU_NAME} at most.`);
+    }
+    return name;
+}
+/** Checks the `locales` of a menu command: a name per language. */
+function checkMenuLocales(locales) {
+    const names = {};
+    if (locales === undefined)
+        return names;
+    if (!isRecord(locales)) {
+        return fail(`"locales" is an object whose keys are languages: locales: { fr: { name: '...' } }`);
+    }
+    for (const [locale, translation] of Object.entries(locales)) {
+        const where = `the "${locale}" translation`;
+        if (!LOCALES.includes(locale)) {
+            fail(`"${locale}" is not a language Discord knows. Languages are: ${LOCALES.join(', ')}.`);
+        }
+        if (!isRecord(translation)) {
+            return fail(`${where} must be an object like { name: '...' }.`);
+        }
+        checkKeys(where, translation, ['name']);
+        if (translation.name === undefined)
+            continue;
+        names[locale] = readMenuName(translation.name, `this command in ${where}`);
+    }
+    return names;
+}
+/** A menu command, checked: one used on a message or a person. */
+function readMenu(config) {
+    const type = config.type;
+    if (!MENU_TYPES.includes(type)) {
+        return fail(`"type" is what a menu command is used on: 'message' (a right click on a message) or 'user' (a right click on a person). Got ${JSON.stringify(type) ?? typeof type}. Leave it out for a slash command.`);
+    }
+    const what = `this ${type === 'user' ? 'user' : 'message'} menu command`;
+    for (const key of ['description', 'options', 'autocomplete']) {
+        if (config[key] !== undefined) {
+            fail(key === 'description'
+                ? `A menu command has no "description": Discord only shows its name. Remove it.`
+                : `A menu command has no "${key}": it receives what it was used on (${type === 'user' ? 'target' : 'message'}). Remove it, or make it a slash command (no "type").`);
+        }
+    }
+    checkKeys('a menu command', config, MENU_KEYS);
+    const name = readMenuName(config.name, what);
+    if (typeof config.run !== 'function') {
+        fail(`This command has no "run": the function to run when someone uses it, like async run({ interaction }) { await interaction.reply('Done!'); }`);
+    }
+    const where = checkWhere(config.where);
+    return Object.freeze({
+        type: type,
+        names: Object.freeze(checkMenuLocales(config.locales)),
+        descriptions: Object.freeze({}),
+        optionLocales: Object.freeze({}),
+        path: Object.freeze([name]),
+        // Its texts are its name and its translations, all in its file.
+        described: true,
+        description: '',
+        options: Object.freeze([]),
+        permissions: checkPermissions(config.permissions),
+        where,
+        nsfw: checkBoolean('"nsfw"', config.nsfw),
+        ephemeral: checkBoolean('"ephemeral"', config.ephemeral),
+        cooldown: checkCooldown(config.cooldown, where),
+        autocomplete: Object.freeze({}),
+        run: config.run,
+    });
+}
 /**
  * A slash command, declared anywhere in `src/` with `command()`: `name` is
  * what people type after the `/`, with its parents for a subcommand
- * (`'mod ban'` is `/mod ban`, `'mod roles add'` is `/mod roles add`). A
- * file may declare several.
+ * (`'mod ban'` is `/mod ban`, `'mod roles add'` is `/mod roles add`). With
+ * a `type`, a menu command, used on a message or a person. A file may
+ * declare several.
  */
 export const commandDeclaration = {
     one: 'command',
@@ -427,6 +522,8 @@ export const commandDeclaration = {
         if (!isRecord(config)) {
             return fail(`command() needs an object: ${EXAMPLE}`);
         }
+        if (config.type !== undefined)
+            return readMenu(config);
         checkKeys('a command', config, COMMAND_KEYS);
         const parts = readCommandName(config.name);
         // No description: the language files describe the command, options
@@ -453,6 +550,7 @@ export const commandDeclaration = {
         options.sort((a, b) => Number(b.required === true) - Number(a.required === true));
         const where = checkWhere(config.where);
         return Object.freeze({
+            type: 'slash',
             ...checkLocales(config.locales, options),
             path: Object.freeze(parts),
             described,
@@ -470,11 +568,35 @@ export const commandDeclaration = {
 };
 /** `command({ ... name: '...' ... })`, as written in a file. */
 const DECLARED = /\bcommand\s*\(\s*\{[^]*?\bname\s*:\s*['"`]([^'"`]+)['"`]/g;
+/** `type: 'message'` or `type: 'user'`: a menu command, which no language file describes. */
+const MENU = /\btype\s*:\s*['"`](?:message|user)['"`]/;
+/**
+ * The text of an object written in a file, without what is nested in it:
+ * the `type` of an option is not the `type` of the command. `code` starts
+ * right after the `{` of the object.
+ */
+function topLevel(code) {
+    let depth = 0;
+    let kept = '';
+    for (const char of code) {
+        if (char === '{' || char === '[' || char === '(')
+            depth++;
+        else if (char === '}' || char === ']' || char === ')') {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        else if (depth === 0)
+            kept += char;
+    }
+    return kept;
+}
 /**
  * The names of the commands of a project, found without running its
  * files: a text search for `command({ name: '...' })`. Approximate on
  * purpose, for `sync`, which runs nothing: `dev` and `build` then write
  * the exact ones. Whether a command is described is not known: none is.
+ * Menu commands are left out: their texts are always in their file.
  */
 export async function scanCommands(cwd) {
     const names = new Set();
@@ -483,6 +605,10 @@ export async function scanCommands(cwd) {
         if (!code.includes('command('))
             continue;
         for (const match of code.matchAll(DECLARED)) {
+            // The config of this declaration, without its options.
+            const open = code.indexOf('{', match.index);
+            if (MENU.test(topLevel(code.slice(open + 1))))
+                continue;
             const name = match[1].trim().split(/\s+/).join(' ');
             if (name !== '')
                 names.add(name);

package/dist/commands/router.js

@@ -1,6 +1,6 @@
 // Runs the command someone used: finds its file, turns what Discord sent
 // into what `run` receives, and makes sure the person always gets an answer.
-import { Permissions } from '../discord/permissions.js';
+import { Permissions, permissionWords } from '../discord/permissions.js';
 import { ApplicationCommandOptionType, ApplicationCommandType, } from '../discord/types/application-command.js';
 import { InteractionType, } from '../discord/types/interaction.js';
 import { timestamp, TimestampStyle } from '../discord/formatting.js';
@@ -11,13 +11,18 @@ import { CommandInteraction } from '../structures/interaction.js';
 import { remember } from '../structures/known.js';
 import { toCamelCase } from '../util/case.js';
 import { suggest } from './autocomplete.js';
-import { commandName } from './tree.js';
+import { commandKey, describeCommand } from './tree.js';
 /**
  * How long a refusal for a cooldown may wait before deleting itself: the
  * token of an interaction lives 15 minutes, with room for the request.
  * @see https://docs.discord.com/developers/interactions/receiving-and-responding#interaction-object
  */
 const DELETE_WITHIN = 14 * 60_000;
+/** The menu commands, by the type Discord sends. */
+const MENUS = {
+    [ApplicationCommandType.User]: 'user',
+    [ApplicationCommandType.Message]: 'message',
+};
 const SUB = ApplicationCommandOptionType.SubCommand;
 const GROUP = ApplicationCommandOptionType.SubCommandGroup;
 export class CommandRouter {
@@ -35,7 +40,7 @@ export class CommandRouter {
     set(entries) {
         const commands = new Map();
         for (const entry of entries) {
-            commands.set(entry.command.path.join(' '), entry);
+            commands.set(commandKey(entry.command), entry);
         }
         this.#commands = commands;
     }
@@ -52,20 +57,35 @@ export class CommandRouter {
             return null;
         }
         const data = raw.data;
-        if (!data || data.type !== ApplicationCommandType.ChatInput)
+        if (!data)
             return null;
-        // `/mod roles add` comes as a command with nested options.
-        const path = [data.name];
-        let given = data.options ?? [];
-        while (given[0] && (given[0].type === SUB || given[0].type === GROUP)) {
-            path.push(given[0].name);
-            given = given[0].options ?? [];
+        const menu = MENUS[data.type];
+        if (data.type !== ApplicationCommandType.ChatInput && !menu)
+            return null;
+        let path;
+        let given = [];
+        if (menu) {
+            // Discord sends no autocomplete for a command without options.
+            if (autocomplete)
+                return null;
+            path = [data.name];
+        }
+        else {
+            // `/mod roles add` comes as a command with nested options.
+            path = [data.name];
+            given = data.options ?? [];
+            while (given[0] && (given[0].type === SUB || given[0].type === GROUP)) {
+                path.push(given[0].name);
+                given = given[0].options ?? [];
+            }
         }
-        const entry = this.#commands.get(path.join(' '));
+        const type = menu ?? 'slash';
+        const key = commandKey({ type, path });
+        const entry = this.#commands.get(key);
         if (autocomplete) {
             return suggest(ctx, raw, entry, given, this.#options, this.#warnedOnce);
         }
-        const name = commandName(path);
+        const name = describeCommand({ type, path });
         const author = authorOf(raw);
         if (!author)
             return null;
@@ -73,7 +93,7 @@ export class CommandRouter {
         const user = ctx.entities.user(author.user);
         const interaction = new CommandInteraction(ctx, rest, user, {
             ephemeral: entry?.command.ephemeral ?? false,
-            commandName: name,
+            commandName: menu ? data.name : name,
         });
         if (!entry) {
             // Still registered on Discord, but its file is gone or broken.
@@ -91,13 +111,13 @@ export class CommandRouter {
             const missing = new Permissions(author.member.permissions ?? '0').missing(command.permissions);
             if (missing.length > 0) {
                 return refuse(interaction, 'needsPermissions', {
-                    permissions: missing.join(', '),
+                    permissions: missing.map(permissionWords).join(', '),
                     count: missing.length,
                 });
             }
         }
         // Used too soon: the person is told when, and nothing runs.
-        const again = checkCooldown(this.#cooldowns, path.join(' '), command.cooldown, {
+        const again = checkCooldown(this.#cooldowns, key, command.cooldown, {
             user: user.id,
             channel: place.channel.id,
             guild: place.guild?.id,
@@ -105,9 +125,15 @@ export class CommandRouter {
         if (again > 0) {
             return this.#refuseUntil(interaction, again);
         }
-        let options;
+        // What `run` receives besides the place: the options of a slash
+        // command, or what a menu command was used on.
+        let received;
         try {
-            options = this.#readOptions(ctx, raw, data, given, entry);
+            received = menu
+                ? this.#readTarget(ctx, raw, data, menu)
+                : {
+                    options: Object.freeze(this.#readOptions(ctx, raw, data, given, entry)),
+                };
         }
         catch (error) {
             this.#options.onError(file, error);
@@ -120,7 +146,7 @@ export class CommandRouter {
         });
         const context = Object.freeze({
             interaction,
-            options: Object.freeze(options),
+            ...received,
             user,
             ...placeContext(place, command.where),
             // `t` speaks the language of who will read the answer.
@@ -164,6 +190,40 @@ export class CommandRouter {
         timer.unref();
         return refused;
     }
+    /**
+     * What a menu command was used on: the person (`target`, and
+     * `targetMember` in a server, `null` when they are not in it), or the
+     * message. Discord sends it whole in `resolved`, keyed by `target_id`.
+     * @see https://docs.discord.com/developers/interactions/application-commands#user-commands
+     * @see https://docs.discord.com/developers/interactions/application-commands#message-commands
+     */
+    #readTarget(ctx, raw, data, type) {
+        const id = data.target_id;
+        const resolved = data.resolved ?? {};
+        const guildId = raw.guild_id;
+        if (type === 'message') {
+            const message = id ? resolved.messages?.[id] : undefined;
+            if (!message) {
+                throw new Error(`Discord sent the message menu "${data.name}" without the message it was used on.`);
+            }
+            return { message: ctx.entities.message(message, guildId) };
+        }
+        const rawUser = id ? resolved.users?.[id] : undefined;
+        if (!rawUser) {
+            throw new Error(`Discord sent the user menu "${data.name}" without the person it was used on.`);
+        }
+        const target = ctx.entities.user(rawUser);
+        // Outside a server, there is no member.
+        if (!guildId)
+            return { target, targetMember: null };
+        const member = resolved.members?.[id];
+        return {
+            target,
+            targetMember: member && guildId
+                ? ctx.entities.member(guildId, member, rawUser)
+                : null,
+        };
+    }
     /** The value of each declared option, as structures where it applies. */
     #readOptions(ctx, raw, data, given, { command }) {
         const values = new Map(given.map(option => [option.name, option.value]));

package/dist/commands/tree.d.ts

@@ -16,14 +16,34 @@ export interface CommandConflict {
 export type CommandPayload = BulkOverwriteGuildApplicationCommandsJSONParams;
 /** `/mod ban` for `['mod', 'ban']`. */
 export declare const commandName: (path: readonly string[]) => string;
+/**
+ * A command as messages name it: `/mod ban` for a slash command, `the
+ * message menu "Report"` for a menu command.
+ */
+export declare const describeCommand: (command: Pick<LoadedCommand, 'type' | 'path'>) => string;
+/** The same text, starting with a capital: the start of a sentence. */
+export declare const capitalize: (text: string) => string;
+/**
+ * What tells one command from another: its path for a slash command, its
+ * type and name for a menu command (Discord lets a slash command, a
+ * message menu and a user menu share a name).
+ */
+export declare const commandKey: (command: Pick<LoadedCommand, 'type' | 'path'>) => string;
+/**
+ * How many menu commands of each type Discord accepts, for everyone and
+ * in each server.
+ * @see https://docs.discord.com/developers/interactions/application-commands#registering-a-command
+ */
+export declare const MAX_MENUS = 15;
 /**
  * Finds the declarations that can't be commands together, and leaves them
  * out:
- * - two commands with the same name;
+ * - two commands with the same name (and type);
  * - a command that also has subcommands: Discord only lets people use the
- *   subcommands.
+ *   subcommands;
+ * - a menu command beyond the 15 of its type Discord accepts.
  */
-export declare function findConflicts(entries: readonly CommandEntry[]): {
+export declare function findConflicts(entries: readonly CommandEntry[], running?: ReadonlySet<string>): {
     valid: CommandEntry[];
     conflicts: CommandConflict[];
 };
@@ -34,7 +54,8 @@ export declare function findConflicts(entries: readonly CommandEntry[]): {
  */
 export declare const privateOnly: (entries: readonly CommandEntry[]) => CommandEntry[];
 /**
- * What to register for a set of commands. `guild` is for commands of one
+ * What to register for a set of commands: the slash commands, then the
+ * menu commands. `guild` is for commands of one
  * server (dev), where Discord takes no contexts: the commands that only
  * work in private messages are left out, they could never run there.
  *

package/dist/commands/tree.js

@@ -4,7 +4,7 @@
 import { ApplicationCommandOptionType, ApplicationCommandType, } from '../discord/types/application-command.js';
 import { ApplicationIntegrationType } from '../discord/types/application.js';
 import { InteractionContextType } from '../discord/types/interaction.js';
-import { siteName } from '../loader/loader.js';
+import { bySite, siteName } from '../loader/loader.js';
 const TYPES = {
     string: ApplicationCommandOptionType.String,
     integer: ApplicationCommandOptionType.Integer,
@@ -76,26 +76,46 @@ function toOption(option, locales, autocomplete) {
 }
 /** `/mod ban` for `['mod', 'ban']`. */
 export const commandName = (path) => `/${path.join(' ')}`;
+/**
+ * A command as messages name it: `/mod ban` for a slash command, `the
+ * message menu "Report"` for a menu command.
+ */
+export const describeCommand = (command) => command.type === 'slash'
+    ? commandName(command.path)
+    : `the ${command.type} menu "${command.path[0]}"`;
+/** The same text, starting with a capital: the start of a sentence. */
+export const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+/**
+ * What tells one command from another: its path for a slash command, its
+ * type and name for a menu command (Discord lets a slash command, a
+ * message menu and a user menu share a name).
+ */
+export const commandKey = (command) => command.type === 'slash'
+    ? command.path.join(' ')
+    : `${command.type}:${command.path[0]}`;
+/**
+ * How many menu commands of each type Discord accepts, for everyone and
+ * in each server.
+ * @see https://docs.discord.com/developers/interactions/application-commands#registering-a-command
+ */
+export const MAX_MENUS = 15;
+const MENU_TYPES = {
+    user: ApplicationCommandType.User,
+    message: ApplicationCommandType.Message,
+};
 /**
  * Finds the declarations that can't be commands together, and leaves them
  * out:
- * - two commands with the same name;
+ * - two commands with the same name (and type);
  * - a command that also has subcommands: Discord only lets people use the
- *   subcommands.
+ *   subcommands;
+ * - a menu command beyond the 15 of its type Discord accepts.
  */
-export function findConflicts(entries) {
+export function findConflicts(entries, running) {
     const conflicts = [];
     const seen = new Map();
-    const unique = [...entries]
-        .sort((a, b) => a.file === b.file
-        ? a.export < b.export
-            ? -1
-            : 1
-        : a.file < b.file
-            ? -1
-            : 1)
-        .filter(entry => {
-        const key = entry.command.path.join(' ');
+    const unique = bySite(entries, running).filter(entry => {
+        const key = commandKey(entry.command);
         const first = seen.get(key);
         if (!first) {
             seen.set(key, entry);
@@ -104,13 +124,25 @@ export function findConflicts(entries) {
         conflicts.push({
             file: entry.file,
             export: entry.export,
-            message: `${commandName(entry.command.path)} is already declared in ${siteName(first)}: two commands can't have the same name.`,
+            message: `${capitalize(describeCommand(entry.command))} is already declared in ${siteName(first)}: two ${entry.command.type === 'slash' ? 'commands' : `${entry.command.type} menu commands`} can't have the same name.`,
         });
         return false;
     });
+    const menus = { user: 0, message: 0 };
     const valid = unique.filter(entry => {
-        const { path } = entry.command;
+        const { path, type } = entry.command;
+        if (type !== 'slash') {
+            if (++menus[type] <= MAX_MENUS)
+                return true;
+            conflicts.push({
+                file: entry.file,
+                export: entry.export,
+                message: `${capitalize(describeCommand(entry.command))} is one ${type} menu command too many: Discord accepts ${MAX_MENUS} at most. Remove one, or make it a slash command (no "type").`,
+            });
+            return false;
+        }
         const child = unique.find(other => other !== entry &&
+            other.command.type === 'slash' &&
             other.command.path.length > path.length &&
             path.every((part, index) => other.command.path[index] === part));
         if (!child)
@@ -131,7 +163,8 @@ export function findConflicts(entries) {
  */
 export const privateOnly = (entries) => entries.filter(entry => entry.command.where === 'dm');
 /**
- * What to register for a set of commands. `guild` is for commands of one
+ * What to register for a set of commands: the slash commands, then the
+ * menu commands. `guild` is for commands of one
  * server (dev), where Discord takes no contexts: the commands that only
  * work in private messages are left out, they could never run there.
  *
@@ -148,14 +181,19 @@ export function buildCommands(entries, { guild }) {
         ...(command.options.length > 0 ? { options: optionsOf(command) } : {}),
     }, command.names, command.descriptions);
     const roots = new Map();
+    const menus = [];
     for (const { command } of entries) {
         if (guild && command.where === 'dm')
             continue;
+        if (command.type !== 'slash') {
+            menus.push(command);
+            continue;
+        }
         const list = roots.get(command.path[0]) ?? [];
         list.push(command);
         roots.set(command.path[0], list);
     }
-    return [...roots]
+    const slash = [...roots]
         .sort(([a], [b]) => (a < b ? -1 : 1))
         .map(([name, commands]) => {
         const [first] = commands;
@@ -175,14 +213,7 @@ export function buildCommands(entries, { guild }) {
                     integration_types: [ApplicationIntegrationType.GuildInstall],
                     // A command is offered wherever one of its subcommands
                     // works; each one refuses the place it does not work in.
-                    contexts: [
-                        ...(commands.some(command => command.where !== 'dm')
-                            ? [InteractionContextType.Guild]
-                            : []),
-                        ...(commands.some(command => command.where !== 'guild')
-                            ? [InteractionContextType.BotDm]
-                            : []),
-                    ],
+                    contexts: contextsOf(commands),
                 }),
             ...(commands.some(command => command.nsfw) ? { nsfw: true } : {}),
         }, leaf?.names, leaf?.descriptions);
@@ -213,4 +244,42 @@ export function buildCommands(entries, { guild }) {
         payload.options = options;
         return payload;
     });
+    return [
+        ...slash,
+        ...menus.sort(byTypeAndName).map(menu => toMenu(menu, guild)),
+    ];
+}
+/** Menu commands in a stable order: by type, then by name. */
+const byTypeAndName = (a, b) => commandKey(a) < commandKey(b) ? -1 : 1;
+/**
+ * What Discord registers for a menu command: a name and no description
+ * ("The `description` field is not allowed when creating user commands"),
+ * nor options.
+ * @see https://docs.discord.com/developers/interactions/application-commands#user-commands
+ * @see https://docs.discord.com/developers/interactions/application-commands#message-commands
+ */
+function toMenu(command, guild) {
+    const names = localized(command.names);
+    return {
+        type: MENU_TYPES[command.type],
+        name: command.path[0],
+        ...(names ? { name_localizations: names } : {}),
+        default_member_permissions: command.permissions === 0n ? null : String(command.permissions),
+        ...(guild
+            ? {}
+            : {
+                integration_types: [ApplicationIntegrationType.GuildInstall],
+                contexts: contextsOf([command]),
+            }),
+        ...(command.nsfw ? { nsfw: true } : {}),
+    };
 }
+/** Where Discord offers a command: wherever one of these works. */
+const contextsOf = (commands) => [
+    ...(commands.some(command => command.where !== 'dm')
+        ? [InteractionContextType.Guild]
+        : []),
+    ...(commands.some(command => command.where !== 'guild')
+        ? [InteractionContextType.BotDm]
+        : []),
+];

package/dist/commands/twins.d.ts

@@ -1,5 +1,13 @@
 import type { RawApplicationCommand } from '../discord/types/application-command.js';
 import type { CommandPayload } from './tree.js';
+/**
+ * A registered command as messages name it: `/ping`, or `the message menu
+ * "Report"`.
+ */
+export declare function shownName(command: {
+    type?: number;
+    name: string;
+}): string;
 /** Whether a command of the project is the one Discord has for everyone. */
 export declare function sameDefinition(ours: CommandPayload, theirs: RawApplicationCommand): boolean;
 /**

package/dist/commands/twins.js

@@ -4,6 +4,21 @@
 // twice in the dev server. So the dev server only gets the commands that
 // are not already there for everyone, exactly as the project declares them.
 // https://docs.discord.com/developers/interactions/application-commands#registering-a-command
+import { ApplicationCommandType } from '../discord/types/application-command.js';
+/**
+ * A registered command as messages name it: `/ping`, or `the message menu
+ * "Report"`.
+ */
+export function shownName(command) {
+    switch (command.type ?? ApplicationCommandType.ChatInput) {
+        case ApplicationCommandType.User:
+            return `the user menu "${command.name}"`;
+        case ApplicationCommandType.Message:
+            return `the message menu "${command.name}"`;
+        default:
+            return `/${command.name}`;
+    }
+}
 /** What says how a command looks and works: the rest is not compared. */
 const DEFINITION = new Set([
     'type',
@@ -25,6 +40,9 @@ const DEFINITION = new Set([
     'autocomplete',
 ]);
 const isEmpty = (value) => value === null ||
+    // The description of a menu command: "an empty string (instead of
+    // null) when fetching commands", and never sent.
+    value === '' ||
     value === undefined ||
     value === false ||
     (Array.isArray(value) && value.length === 0) ||
@@ -58,20 +76,20 @@ export function sameDefinition(ours, theirs) {
  * next to the one in production until that one is updated.
  */
 export function withoutGlobalTwins(commands, global) {
-    const byName = new Map(global
-        .filter(command => (command.type ?? 1) === 1)
-        .map(command => [command.name, command]));
+    // A slash command and a menu command may share a name.
+    const keyOf = (command) => `${command.type ?? 1}:${command.name}`;
+    const byName = new Map(global.map(command => [keyOf(command), command]));
     const kept = [];
     const twins = [];
     const changed = [];
     for (const command of commands) {
-        const other = byName.get(command.name);
+        const other = byName.get(keyOf(command));
         if (other && sameDefinition(command, other)) {
-            twins.push(command.name);
+            twins.push(shownName(command));
             continue;
         }
         if (other)
-            changed.push(command.name);
+            changed.push(shownName(command));
         kept.push(command);
     }
     return { kept, twins, changed };