chapterjs 0.4.0 → 0.5.0

package/dist/structures/wait.d.ts

@@ -0,0 +1,105 @@
+import type { Snowflake } from '../discord/types/common.js';
+import type { Duration } from '../commands/command.js';
+import type { ButtonDeclaration } from '../components/button.js';
+import type { SelectDeclaration } from '../components/select.js';
+import type { WaitKind } from '../waiting/waiters.js';
+import type { Context } from './context.js';
+import type { ComponentInteraction } from './interaction.js';
+import type { GuildMember } from './member.js';
+import type { Message, ReactionEmoji } from './message.js';
+import type { User } from './user.js';
+/** A person, as a wait takes it: a user, a member, or an id. */
+export type PersonInput = User | GuildMember | Snowflake;
+/** What `channel.waitForMessage()` takes. */
+export interface WaitForMessageOptions {
+    /** Only a message of this person. Anyone but a bot by default. */
+    from?: PersonInput;
+    /**
+     * Only a message that says this: a text (the same, whatever the capitals
+     * and the spaces around), a regular expression, or a function of the
+     * message.
+     */
+    matches?: string | RegExp | ((message: Message) => boolean);
+    /**
+     * How long to wait: `'30s'`, `'2m'`. One minute by default, a second at
+     * least, a day at most.
+     */
+    within?: Duration;
+}
+/** What `channel.collectMessages()` takes. */
+export interface CollectMessagesOptions extends WaitForMessageOptions {
+    /** Stops once this many messages came. No limit by default: until `within`. */
+    max?: number;
+}
+/** What `message.waitForClick()` takes. */
+export interface WaitForClickOptions {
+    /** Only a click of this person. Anyone by default. */
+    from?: PersonInput;
+    /** How long to wait: `'30s'`, `'2m'`. One minute by default. */
+    within?: Duration;
+}
+/** What `message.waitForReaction()` takes. */
+export interface WaitForReactionOptions {
+    /** Only a reaction of this person. Anyone but a bot by default. */
+    from?: PersonInput;
+    /**
+     * Only this emoji: a standard one (`'👍'`), or a custom one by its name,
+     * its id or as Discord writes it (`'<:party:123>'`).
+     */
+    emoji?: string;
+    /** How long to wait: `'30s'`, `'2m'`. One minute by default. */
+    within?: Duration;
+}
+/** A click on a button or a menu of a message, as `waitForClick()` gives it. */
+export interface Click {
+    /**
+     * The click itself: answer it as in the `run` of a button, with
+     * `update()`, `reply()` or `deferUpdate()`. Without an answer within 2
+     * seconds, the bot changes nothing on screen for you (`deferUpdate()`).
+     */
+    readonly interaction: ComponentInteraction;
+    /** Who clicked. */
+    readonly user: User;
+    /** Who clicked, as a member of the server; `null` in a private message. */
+    readonly member: GuildMember | null;
+    /** The name of the button or menu: the name of its export. */
+    readonly name: string;
+    /** The data the button or menu carries. */
+    readonly data: Readonly<Record<string, string | number | boolean>>;
+    /**
+     * What was picked in a menu: the values of a menu of texts, the ids of
+     * the people, roles or channels of the others. Empty for a button.
+     */
+    readonly values: readonly string[];
+    /** Whether it is this button or this menu. */
+    is(component: ButtonDeclaration<never> | SelectDeclaration<never>): boolean;
+}
+/** A reaction added to a message, as `waitForReaction()` gives it. */
+export interface WaitedReaction {
+    /** The emoji. */
+    readonly emoji: ReactionEmoji;
+    /** Who reacted. */
+    readonly user: User;
+    /** Who reacted, as a member of the server; `null` in a private message. */
+    readonly member: GuildMember | null;
+}
+/** What the bot offers the waits for a click: `components/router.ts` builds it. */
+export interface OfferedClick extends Click {
+    readonly messageId: Snowflake;
+}
+/** What the bot offers the waits for a reaction: `core/bot.ts` builds it. */
+export interface OfferedReaction extends WaitedReaction {
+    readonly messageId: Snowflake;
+}
+/** The milliseconds of `within`, checked. */
+export declare function readWithin(within: unknown): number;
+/** The id of a person a wait is given, checked. */
+export declare function personId(from: unknown): Snowflake | undefined;
+/** Whether a message says what `matches` asks. */
+export declare function readMatches(matches: unknown): (message: Message) => boolean;
+/** Whether an emoji is the one `emoji` names. */
+export declare function readEmoji(emoji: unknown): (given: ReactionEmoji) => boolean;
+/** The waits of the bot, or why there are none. */
+export declare function waitersOf(structure: object): NonNullable<Context['waiters']>;
+/** Waits for what fits, `max` at most: what was taken, in order. */
+export declare function waitFor<T>(structure: object, kind: WaitKind, match: (offered: T) => boolean, within: number, max?: number): Promise<T[]>;

package/dist/structures/wait.js

@@ -0,0 +1,85 @@
+// What a structure waits for: the options of `channel.waitForMessage()`,
+// `channel.collectMessages()`, `message.waitForClick()` and
+// `message.waitForReaction()`, checked, and turned into the test a wait of
+// `waiting/` runs on what the bot offers it.
+import { DURATION_EXAMPLE, parseDuration } from '../util/duration.js';
+import { ctxOf } from './base.js';
+/** One minute: how long a wait lasts when the file does not say. */
+const DEFAULT_WITHIN = 60_000;
+const MIN_WITHIN = 1_000;
+/** A day: longer would be lost by any restart anyway. */
+const MAX_WITHIN = 86_400_000;
+/** The milliseconds of `within`, checked. */
+export function readWithin(within) {
+    if (within === undefined)
+        return DEFAULT_WITHIN;
+    const ms = typeof within === 'string' ? parseDuration(within) : null;
+    if (ms === null) {
+        throw new TypeError(`"within" is how long to wait, a duration (${DURATION_EXAMPLE}): got ${JSON.stringify(within) ?? typeof within}.`);
+    }
+    if (ms < MIN_WITHIN || ms > MAX_WITHIN) {
+        throw new RangeError(`"within" is ${JSON.stringify(within)}: a wait lasts between 1 second and 1 day.`);
+    }
+    return ms;
+}
+/** The id of a person a wait is given, checked. */
+export function personId(from) {
+    if (from === undefined)
+        return undefined;
+    if (typeof from === 'string' && /^\d+$/.test(from))
+        return from;
+    if (typeof from === 'object' &&
+        from !== null &&
+        typeof from.id === 'string') {
+        return from.id;
+    }
+    throw new TypeError(`"from" is the person to wait for: a user, a member or their id, got ${JSON.stringify(from) ?? typeof from}.`);
+}
+/** Whether a message says what `matches` asks. */
+export function readMatches(matches) {
+    if (matches === undefined)
+        return () => true;
+    if (typeof matches === 'string') {
+        const wanted = matches.trim().toLowerCase();
+        return message => message.content.trim().toLowerCase() === wanted;
+    }
+    if (matches instanceof RegExp) {
+        // A global or sticky expression keeps where it stopped: test from the start.
+        return message => {
+            matches.lastIndex = 0;
+            return matches.test(message.content);
+        };
+    }
+    if (typeof matches === 'function') {
+        return message => matches(message) === true;
+    }
+    throw new TypeError(`"matches" is a text, a regular expression or a function of the message, like matches: 'paris' or matches: /^paris$/i.`);
+}
+/** Whether an emoji is the one `emoji` names. */
+export function readEmoji(emoji) {
+    if (emoji === undefined)
+        return () => true;
+    if (typeof emoji !== 'string' || emoji.trim() === '') {
+        throw new TypeError(`"emoji" is the emoji to wait for: '👍', or a custom one by its name, its id or as '<:name:id>'.`);
+    }
+    const custom = /^<a?:(\w+):(\d+)>$/.exec(emoji.trim());
+    const wanted = custom ? custom[2] : emoji.trim();
+    return given => given.id === wanted || given.name === wanted;
+}
+/** The waits of the bot, or why there are none. */
+export function waitersOf(structure) {
+    const { waiters } = ctxOf(structure);
+    if (!waiters) {
+        throw new Error('Waiting for what comes next only works in a running bot: in a command, an event, a component or a task.');
+    }
+    return waiters;
+}
+/** Waits for what fits, `max` at most: what was taken, in order. */
+export function waitFor(structure, kind, match, within, max = 1) {
+    return waitersOf(structure).wait({
+        kind,
+        match: offered => match(offered),
+        max,
+        within,
+    });
+}

package/dist/testing/harness.d.ts

@@ -1,10 +1,11 @@
 import type { PermissionName } from '../discord/permissions.js';
 import type { Locale } from '../discord/types/common.js';
 import { type RawEmbed } from '../discord/types/message.js';
-import type { CommandDeclaration, CommandOption, CommandOptions, CommandWhere } from '../commands/command.js';
+import type { CommandDeclaration, CommandOption, CommandOptions, CommandWhere, MenuDeclaration, MenuType } from '../commands/command.js';
 import type { ButtonDeclaration } from '../components/button.js';
 import { type ButtonComponent, type ModalComponent, type SelectComponent } from '../components/instance.js';
 import type { CheckboxesField, CheckboxField, EntityField, FilesField, ModalDeclaration, ModalField, ModalFields, NoteField, RadioField, SelectField, TextField } from '../components/modal.js';
+import type { DataShape } from '../components/custom-id.js';
 import type { OptionValue } from '../components/options.js';
 import type { SelectDeclaration } from '../components/select.js';
 import type { Bot } from '../core/bot.js';
@@ -190,8 +191,12 @@ export interface TestReply extends TestAssertions<TestReply> {
     isDeferred(): TestReply;
     /** Checks that the bot changed the message of the button or menu. */
     updatesMessage(): TestReply;
-    /** Checks that the bot opened a form, this one when given. */
-    opensForm(form?: ModalDeclaration<ModalFields, never> | TestForm): TestReply;
+    /**
+     * Checks that the bot opened a form, this one when given: its export
+     * (whatever data it carries), the form called with its data, or one found
+     * on an answer.
+     */
+    opensForm<Fields extends ModalFields, Data extends DataShape>(form?: ModalDeclaration<Fields, Data> | ModalComponent | TestForm): TestReply;
     /** Checks that the bot answered with nothing visible (a deferred update). */
     changesNothing(): TestReply;
     /** The button with this label, to click it. Fails when there is none. */
@@ -258,6 +263,14 @@ export type SelectInput = string | TestMember | TestRole | TestChannel;
 export type ButtonTarget = ButtonDeclaration<never> | ButtonComponent | TestButton;
 export type SelectTarget = SelectDeclaration<never> | SelectComponent | TestMenu;
 export type FormTarget<Fields extends ModalFields = ModalFields> = ModalDeclaration<Fields, never> | ModalComponent | TestForm;
+/**
+ * What a menu command is used on in a test: a person for a `'user'` menu,
+ * a message for a `'message'` menu.
+ */
+export type TestMenuTarget<Type extends MenuType = MenuType> = {
+    /** The person or the message the menu is used on. */
+    readonly on: Type extends 'user' ? TestMember : TestMessage;
+};
 /** The arguments of `bot.use()`: the options may be left out when none is required. */
 type UseArgs<Options extends CommandOptions> = {} extends OptionInputsOf<Options> ? [options?: OptionInputsOf<Options>, where?: TestWhere] : [options: OptionInputsOf<Options>, where?: TestWhere];
 /**
@@ -291,7 +304,13 @@ export interface TestBot {
     role(name: string, options?: TestRoleOptions): TestRole;
     /** A channel of the server, made the first time the name is given. `#general` exists. */
     channel(name: string, options?: TestChannelOptions): TestChannel;
-    /** Uses a slash command, as a person would. Resolves once the bot answered. */
+    /**
+     * Uses a command, as a person would: a slash command with its options,
+     * or a menu command on what it is used on (`{ on: message }`,
+     * `{ on: member }`; a message menu is used in the channel of its
+     * message). Resolves once the bot answered.
+     */
+    use<Type extends MenuType, Where extends CommandWhere>(command: MenuDeclaration<Type, Where>, target: TestMenuTarget<Type>, where?: TestWhere): Promise<TestReply>;
     use<Options extends CommandOptions, Where extends CommandWhere>(command: CommandDeclaration<Options, Where>, ...args: UseArgs<Options>): Promise<TestReply>;
     /** Clicks a button. Resolves once the bot answered. */
     click(button: ButtonTarget, where?: TestWhere): Promise<TestReply>;
@@ -311,6 +330,12 @@ export interface TestBot {
     leave(member: TestMember): Promise<void>;
     /** Runs a task now, as if its time had come. Resolves once it is done. */
     run(task: TaskDeclaration, at?: Date): Promise<void>;
+    /**
+     * Ends everything the bot waits for (`waitForMessage()`,
+     * `waitForClick()`...) as if its time was up: time does not pass in the
+     * test server. Resolves once the bot handled it.
+     */
+    endWaits(): Promise<void>;
     /** Waits for everything the bot started to be done. */
     settle(): Promise<void>;
 }
@@ -329,13 +354,26 @@ export declare function captureLog(): {
 export declare class Observer {
     #private;
     readonly observe: ProjectObserver;
-    /** Forgets the interactions seen so far: a new world starts. */
+    /**
+     * Forgets everything of the world before: a new world starts. What the
+     * files of the last one still run (a case given up on) is never waited
+     * for again.
+     */
     reset(): void;
-    /** Resolves once the files are done with the interaction `id`. */
+    /**
+     * Resolves once the files were given the interaction `id`: `settle()`
+     * then waits for them to be done with it.
+     */
     interaction(id: string, timeout: number): Promise<void>;
-    /** Resolves once the files are done with the next event that matches. */
+    /**
+     * Resolves once the files were given the next event that matches:
+     * `settle()` then waits for them to be done with it.
+     */
     event(match: (event: string, data: unknown) => boolean, timeout: number): Promise<void>;
-    /** Resolves once nothing the files started is still running. */
+    /**
+     * Resolves once nothing the files started is still running, but what
+     * waits for the test to act (a run waiting for a message, a click...).
+     */
     settle(): Promise<void>;
 }
 /** The bot in its world, with the handles a test works with. */
@@ -362,6 +400,7 @@ export declare class Session implements TestBot {
     member(name: string, options?: TestMemberOptions): TestMember;
     role(name: string, options?: TestRoleOptions): TestRole;
     channel(name: string, options?: TestChannelOptions): TestChannel;
+    use<Type extends MenuType, Where extends CommandWhere>(command: MenuDeclaration<Type, Where>, target: TestMenuTarget<Type>, where?: TestWhere): Promise<TestReply>;
     use<Options extends CommandOptions, Where extends CommandWhere>(command: CommandDeclaration<Options, Where>, ...args: UseArgs<Options>): Promise<TestReply>;
     suggest<Options extends CommandOptions, Where extends CommandWhere>(command: CommandDeclaration<Options, Where>, option: keyof Options & string, typed: string, where?: TestWhere): Promise<TestSuggestion[]>;
     click(button: ButtonTarget, where?: TestWhere): Promise<TestReply>;
@@ -373,6 +412,7 @@ export declare class Session implements TestBot {
     leave(member: TestMember): Promise<void>;
     run(task: TaskDeclaration, at?: Date): Promise<void>;
     settle(): Promise<void>;
+    endWaits(): Promise<void>;
     /**
      * Sends a gateway event to the bot and waits for the files to be done
      * with it. For the checks of `chapterjs test`, not for scenarios.

package/dist/testing/harness.js

@@ -10,12 +10,17 @@ import { ComponentType, } from '../discord/types/component.js';
 import { InteractionType, } from '../discord/types/interaction.js';
 import { MessageFlags, MessageType, } from '../discord/types/message.js';
 import { PermissionFlags } from '../discord/types/permissions.js';
-import { commandName } from '../commands/tree.js';
+import { capitalize, commandName, describeCommand, } from '../commands/tree.js';
 import { componentStateOf } from '../components/declared.js';
 import { isPiece, renderedOf, resolve, } from '../components/instance.js';
 import { translatorOf } from '../messages/translate.js';
 import { toCamelCase } from '../util/case.js';
 import { expectThat, shown, TestFailure } from './failure.js';
+/** The type Discord gives each kind of menu command. */
+const MENU_COMMAND_TYPES = {
+    user: ApplicationCommandType.User,
+    message: ApplicationCommandType.Message,
+};
 /** A `Log` that keeps what is written, for the runner to show per check. */
 export function captureLog() {
     let current = { errors: [], warnings: [], infos: [] };
@@ -37,10 +42,27 @@ export function captureLog() {
 /** Watches what the bot does with the files, to wait for it. */
 export class Observer {
     #pending = new Set();
+    /**
+     * The runs of the files waiting for what comes next: each keeps one
+     * promise pending that only the test can end (`bot.say()`...).
+     */
+    #parked = new Set();
+    /** Resolves the next time a run starts or stops waiting. */
+    #parkChanged = () => { };
     #interactions = new Map();
     #interactionWaiters = new Map();
     #eventWaiters = [];
     observe = {
+        waits: {
+            parked: run => {
+                this.#parked.add(run);
+                this.#parkChanged();
+            },
+            resumed: run => {
+                this.#parked.delete(run);
+                this.#parkChanged();
+            },
+        },
         interaction: (raw, done) => {
             const settled = done.then(() => { }, () => { });
             this.#track(settled);
@@ -67,34 +89,47 @@ export class Observer {
         this.#pending.add(settled);
         settled.finally(() => this.#pending.delete(settled));
     }
-    /** Forgets the interactions seen so far: a new world starts. */
+    /**
+     * Forgets everything of the world before: a new world starts. What the
+     * files of the last one still run (a case given up on) is never waited
+     * for again.
+     */
     reset() {
         this.#interactions.clear();
+        this.#pending.clear();
+        this.#parked.clear();
+        this.#interactionWaiters.clear();
+        this.#eventWaiters.length = 0;
     }
-    /** Resolves once the files are done with the interaction `id`. */
+    /**
+     * Resolves once the files were given the interaction `id`: `settle()`
+     * then waits for them to be done with it.
+     */
     interaction(id, timeout) {
-        const known = this.#interactions.get(id);
-        if (known)
-            return known;
+        if (this.#interactions.has(id))
+            return Promise.resolve();
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.#interactionWaiters.delete(id);
                 reject(new TestFailure(`The bot did not receive the interaction within ${timeout / 1000} s.`));
             }, timeout);
-            this.#interactionWaiters.set(id, done => {
+            this.#interactionWaiters.set(id, () => {
                 clearTimeout(timer);
-                resolve(done);
+                resolve();
             });
         });
     }
-    /** Resolves once the files are done with the next event that matches. */
+    /**
+     * Resolves once the files were given the next event that matches:
+     * `settle()` then waits for them to be done with it.
+     */
     event(match, timeout) {
         return new Promise((resolve, reject) => {
             const waiter = {
                 match,
-                resolve: (done) => {
+                resolve: () => {
                     clearTimeout(timer);
-                    resolve(done);
+                    resolve();
                 },
             };
             const timer = setTimeout(() => {
@@ -106,13 +141,22 @@ export class Observer {
             this.#eventWaiters.push(waiter);
         });
     }
-    /** Resolves once nothing the files started is still running. */
+    /**
+     * Resolves once nothing the files started is still running, but what
+     * waits for the test to act (a run waiting for a message, a click...).
+     */
     async settle() {
-        while (this.#pending.size > 0) {
-            await Promise.all([...this.#pending]);
-        }
-        // Answers sent at the very end have reached the world by now.
-        await new Promise(resolve => setImmediate(resolve));
+        do {
+            while (this.#pending.size > this.#parked.size) {
+                const changed = new Promise(resolve => (this.#parkChanged = resolve));
+                // Looked at again as soon as one is done: the one left may be a
+                // run that waits, which only the test ends.
+                await Promise.race([...this.#pending, changed]);
+            }
+            // Answers sent at the very end have reached the world by now, and a
+            // wait given what just happened has started running again.
+            await new Promise(resolve => setImmediate(resolve));
+        } while (this.#pending.size > this.#parked.size);
     }
 }
 // ── The handles ──────────────────────────────────────────────────────
@@ -170,13 +214,24 @@ function collectComponents(components) {
     walk(components);
     return { buttons, menus };
 }
-const buttonHandle = (raw) => Object.freeze({
+/**
+ * The message a button or a menu was found on, kept out of sight: clicking
+ * it clicks that message, as a person would.
+ */
+const FOUND_ON = Symbol('found on');
+/** The id of the message a handle was found on, if it was found on one. */
+const foundOn = (target) => typeof target === 'object' && target !== null
+    ? target[FOUND_ON]
+    : undefined;
+/** Keeps the message a handle was found on, without showing it. */
+const onMessage = (handle, messageId) => Object.freeze(Object.defineProperty(handle, FOUND_ON, { value: messageId }));
+const buttonHandle = (raw, messageId) => onMessage({
     label: raw.label ?? null,
     style: BUTTON_STYLES[raw.style] ?? 'secondary',
     disabled: raw.disabled === true,
     customId: raw.custom_id ?? null,
-});
-const menuHandle = (raw) => Object.freeze({
+}, messageId);
+const menuHandle = (raw, messageId) => onMessage({
     type: MENU_TYPES[raw.type] ?? 'string',
     placeholder: raw.placeholder ?? null,
     disabled: raw.disabled === true,
@@ -187,7 +242,7 @@ const menuHandle = (raw) => Object.freeze({
         }))
         : [],
     customId: raw.custom_id,
-});
+}, messageId);
 /** Checks a message or an answer; written once for both. */
 function check(self, what, get) {
     const present = () => {
@@ -442,8 +497,8 @@ export class Session {
             return {
                 content: message.content,
                 embeds: toCamelCase(message.embeds),
-                buttons: buttons.map(buttonHandle),
-                menus: menus.map(menuHandle),
+                buttons: buttons.map(button => buttonHandle(button, raw.id)),
+                menus: menus.map(menu => menuHandle(menu, raw.id)),
                 ephemeral: ((message.flags ?? 0) & MessageFlags.Ephemeral) !== 0,
                 present: true,
             };
@@ -563,9 +618,14 @@ export class Session {
             opensForm(form) {
                 expectThat(record.modal !== null, `The bot should have opened a form, it ${record.original ? `answered ${shown(record.original.content)}` : 'opened none'}.`);
                 if (form) {
-                    const expected = 'customId' in form
-                        ? form.customId
-                        : self.#customIdOf(form, 'modal');
+                    // Only the name is compared: the form itself names it, with no
+                    // need for the data it was opened with.
+                    const state = componentStateOf(form);
+                    const expected = state?.kind === 'modal' && state.bound
+                        ? state.bound.name
+                        : typeof form === 'object' && 'customId' in form
+                            ? form.customId
+                            : self.#customIdOf(form, 'modal');
                     const opened = record.modal.custom_id.split(':')[0];
                     expectThat(opened === expected.split(':')[0], `The bot should have opened the form ${expected.split(':')[0]}, it opened ${opened}.`);
                 }
@@ -740,8 +800,11 @@ export class Session {
         return entry;
     }
     async use(command, ...args) {
-        const [given = {}, where] = args;
         const entry = this.#commandEntry(command);
+        if (entry.command.type !== 'slash') {
+            return this.#useMenu(entry, args[0], args[1]);
+        }
+        const [given = {}, where] = args;
         const actor = this.#actor(where);
         const channel = this.#place(where, actor, entry.command.where === 'dm');
         const { options, resolved } = this.#commandOptions(entry, given, channel);
@@ -773,6 +836,54 @@ export class Session {
             value: choice.value,
         }));
     }
+    /**
+     * Uses a menu command on a person or a message, as Discord's client
+     * does: on a message, in the channel of that message; on a person, where
+     * `where` says (`#general`, or the private conversation of a
+     * `where: 'dm'` command, by default).
+     */
+    async #useMenu(entry, target, where) {
+        const { type, path, where: place } = entry.command;
+        const kind = MENU_COMMAND_TYPES[type];
+        const name = describeCommand(entry.command);
+        const on = target?.on;
+        const actor = this.#actor(where);
+        const resolved = {};
+        let channel;
+        let targetId;
+        if (type === 'message') {
+            const message = on && !this.#isMember(on) ? this.world.findMessage(on.id) : undefined;
+            if (!message) {
+                throw new TestFailure(on && !this.#isMember(on)
+                    ? `The message ${on.id} does not exist any more: ${name} can not be used on it.`
+                    : `${capitalize(name)} is used on a message: bot.use(command, { on: message }), with a message of the test (await bot.say('...'), or one the bot sent).`);
+            }
+            const found = this.world.channels.get(message.channel_id);
+            if (!found) {
+                throw new TestFailure(`The channel of the message ${message.id} does not exist any more.`);
+            }
+            channel = found;
+            targetId = message.id;
+            (resolved.messages ??= {})[message.id] = message;
+        }
+        else {
+            if (!this.#isMember(on)) {
+                throw new TestFailure(`${capitalize(name)} is used on a person: bot.use(command, { on: bot.member('alice') }).`);
+            }
+            channel = this.#place(where, actor, place === 'dm');
+            targetId = this.#resolveMember(`${capitalize(name)}`, on, resolved, channel);
+        }
+        const registered = this.world.guildCommands.find(command => command.name === path[0] && command.type === kind);
+        const raw = this.#rawInteraction(InteractionType.ApplicationCommand, actor, channel, {
+            id: registered?.id ?? this.world.snowflake(),
+            name: path[0],
+            type: kind,
+            target_id: targetId,
+            resolved,
+            ...(channel.guild_id ? { guild_id: channel.guild_id } : {}),
+        });
+        return this.#reply(await this.#interact(raw));
+    }
     /** The `data` of a command interaction, subcommands nested as Discord does. */
     #commandData(entry, options, resolved) {
         const [name, ...rest] = entry.command.path;
@@ -788,7 +899,9 @@ export class Session {
                 },
             ];
         }
-        const registered = this.world.guildCommands.find(command => command.name === name);
+        const registered = this.world.guildCommands.find(command => command.name === name &&
+            (command.type ?? ApplicationCommandType.ChatInput) ===
+                ApplicationCommandType.ChatInput);
         return {
             id: registered?.id ?? this.world.snowflake(),
             name: name,
@@ -991,8 +1104,13 @@ export class Session {
         return [...this.project.components.values()].find(entry => entry.component.kind === kind && entry.component.name === name);
     }
     /** The message a component is on: the one given, or one of the bot. */
-    #messageFor(where, actor, channel, component) {
+    #messageFor(where, actor, channel, component, target) {
         const given = where?.on;
+        // Found on a message: that message, as long as it is there.
+        const found = given ? undefined : foundOn(target);
+        const sent = found ? this.world.findMessage(found) : undefined;
+        if (sent)
+            return sent;
         if (given) {
             const id = 'message' in given ? given.message?.id : given.id;
             const found = id ? this.world.findMessage(id) : undefined;
@@ -1036,11 +1154,7 @@ export class Session {
         const entry = this.#componentEntry('button', customId);
         const actor = this.#actor(where);
         const channel = this.#place(where, actor, entry?.component.kind === 'button' && entry.component.where === 'dm');
-        const message = this.#messageFor(where, actor, channel, {
-            type: ComponentType.Button,
-            style: 2,
-            custom_id: customId,
-        });
+        const message = this.#messageFor(where, actor, channel, { type: ComponentType.Button, style: 2, custom_id: customId }, button);
         const raw = this.#rawInteraction(InteractionType.MessageComponent, actor, channel, { custom_id: customId, component_type: ComponentType.Button }, message);
         return this.#reply(await this.#interact(raw));
     }
@@ -1091,8 +1205,10 @@ export class Session {
         const message = this.#messageFor(where, actor, channel, {
             type: componentType,
             custom_id: customId,
-            ...(componentType === ComponentType.StringSelect ? { options: [] } : {}),
-        });
+            ...(componentType === ComponentType.StringSelect
+                ? { options: [] }
+                : {}),
+        }, menu);
         const raw = this.#rawInteraction(InteractionType.MessageComponent, actor, channel, {
             custom_id: customId,
             component_type: componentType,
@@ -1377,6 +1493,10 @@ export class Session {
     settle() {
         return this.#observer.settle();
     }
+    async endWaits() {
+        this.bot.ctx.waiters?.close();
+        await this.#observer.settle();
+    }
     /**
      * Sends a gateway event to the bot and waits for the files to be done
      * with it. For the checks of `chapterjs test`, not for scenarios.

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
 export { scenario } from './scenario.js';
 export type { ScenarioDeclaration } from './scenario.js';
 export { TestFailure } from './failure.js';
-export type { ButtonTarget, FieldInputsOf, FormTarget, OptionInputsOf, SelectInput, SelectTarget, TestAssertions, TestBot, TestButton, TestChannel, TestChannelOptions, TestChannelType, TestFile, TestForm, TestMember, TestMemberOptions, TestMenu, TestMessage, TestReply, TestRole, TestRoleOptions, TestSuggestion, TestWhere, } from './harness.js';
+export type { ButtonTarget, FieldInputsOf, FormTarget, OptionInputsOf, SelectInput, SelectTarget, TestAssertions, TestBot, TestButton, TestChannel, TestChannelOptions, TestChannelType, TestFile, TestForm, TestMember, TestMemberOptions, TestMenu, TestMenuTarget, TestMessage, TestReply, TestRole, TestRoleOptions, TestSuggestion, TestWhere, } from './harness.js';