chapterjs 0.2.2 → 0.3.0

package/dist/testing/harness.js

@@ -0,0 +1,1418 @@
+// What a test drives: the bot of the project, connected to the Discord in
+// memory of `world.ts`, and the handles a scenario works with (a member, a
+// channel, what the bot answered). Everything a person would do on Discord
+// is turned into the payloads Discord would send, given to the real
+// routers, and what the bot sends back is read from the world.
+import { Permissions } from '../discord/permissions.js';
+import { ApplicationCommandOptionType, ApplicationCommandType, } from '../discord/types/application-command.js';
+import { ChannelType } from '../discord/types/channel.js';
+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 { 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';
+/** A `Log` that keeps what is written, for the runner to show per check. */
+export function captureLog() {
+    let current = { errors: [], warnings: [], infos: [] };
+    return {
+        log: {
+            success: message => current.infos.push(message),
+            info: message => current.infos.push(message),
+            reload: message => current.infos.push(message),
+            warn: message => current.warnings.push(message),
+            error: message => current.errors.push(message),
+        },
+        take() {
+            const taken = current;
+            current = { errors: [], warnings: [], infos: [] };
+            return taken;
+        },
+    };
+}
+/** Watches what the bot does with the files, to wait for it. */
+export class Observer {
+    #pending = new Set();
+    #interactions = new Map();
+    #interactionWaiters = new Map();
+    #eventWaiters = [];
+    observe = {
+        interaction: (raw, done) => {
+            const settled = done.then(() => { }, () => { });
+            this.#track(settled);
+            this.#interactions.set(raw.id, settled);
+            const waiter = this.#interactionWaiters.get(raw.id);
+            if (waiter) {
+                this.#interactionWaiters.delete(raw.id);
+                waiter(settled);
+            }
+        },
+        event: (event, data, done) => {
+            const settled = done.then(() => { }, () => { });
+            this.#track(settled);
+            for (let index = this.#eventWaiters.length - 1; index >= 0; index--) {
+                const waiter = this.#eventWaiters[index];
+                if (waiter.match(event, data)) {
+                    this.#eventWaiters.splice(index, 1);
+                    waiter.resolve(settled);
+                }
+            }
+        },
+    };
+    #track(settled) {
+        this.#pending.add(settled);
+        settled.finally(() => this.#pending.delete(settled));
+    }
+    /** Forgets the interactions seen so far: a new world starts. */
+    reset() {
+        this.#interactions.clear();
+    }
+    /** Resolves once the files are done with the interaction `id`. */
+    interaction(id, timeout) {
+        const known = this.#interactions.get(id);
+        if (known)
+            return known;
+        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 => {
+                clearTimeout(timer);
+                resolve(done);
+            });
+        });
+    }
+    /** Resolves once the files are done with the next event that matches. */
+    event(match, timeout) {
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                match,
+                resolve: (done) => {
+                    clearTimeout(timer);
+                    resolve(done);
+                },
+            };
+            const timer = setTimeout(() => {
+                const index = this.#eventWaiters.indexOf(waiter);
+                if (index !== -1)
+                    this.#eventWaiters.splice(index, 1);
+                reject(new TestFailure(`The bot did not receive the event within ${timeout / 1000} s.`));
+            }, timeout);
+            this.#eventWaiters.push(waiter);
+        });
+    }
+    /** Resolves once nothing the files started is still running. */
+    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));
+    }
+}
+// ── The handles ──────────────────────────────────────────────────────
+const permissionNames = (bits) => Object.keys(PermissionFlags).filter(name => (bits & PermissionFlags[name]) !== 0n);
+const BUTTON_STYLES = {
+    1: 'primary',
+    2: 'secondary',
+    3: 'success',
+    4: 'danger',
+    5: 'link',
+    6: 'premium',
+};
+const MENU_TYPES = {
+    [ComponentType.StringSelect]: 'string',
+    [ComponentType.UserSelect]: 'user',
+    [ComponentType.RoleSelect]: 'role',
+    [ComponentType.MentionableSelect]: 'mentionable',
+    [ComponentType.ChannelSelect]: 'channel',
+};
+const CHANNEL_TYPES = {
+    text: ChannelType.GuildText,
+    announcement: ChannelType.GuildAnnouncement,
+    voice: ChannelType.GuildVoice,
+    category: ChannelType.GuildCategory,
+    forum: ChannelType.GuildForum,
+};
+const channelTypeName = (type) => (Object.entries(CHANNEL_TYPES).find(([, value]) => value === type)?.[0] ??
+    (type === ChannelType.Dm
+        ? 'dm'
+        : type === ChannelType.PublicThread ||
+            type === ChannelType.PrivateThread ||
+            type === ChannelType.AnnouncementThread
+            ? 'thread'
+            : 'other'));
+/** Every button and menu of a message, wherever they are nested. */
+function collectComponents(components) {
+    const buttons = [];
+    const menus = [];
+    const walk = (list) => {
+        for (const raw of list ?? []) {
+            const component = raw;
+            if (component.type === ComponentType.Button) {
+                buttons.push(component);
+            }
+            else if (MENU_TYPES[component.type]) {
+                menus.push(component);
+            }
+            else {
+                walk(component.components);
+                if (component.accessory)
+                    walk([component.accessory]);
+            }
+        }
+    };
+    walk(components);
+    return { buttons, menus };
+}
+const buttonHandle = (raw) => Object.freeze({
+    label: raw.label ?? null,
+    style: BUTTON_STYLES[raw.style] ?? 'secondary',
+    disabled: raw.disabled === true,
+    customId: raw.custom_id ?? null,
+});
+const menuHandle = (raw) => Object.freeze({
+    type: MENU_TYPES[raw.type] ?? 'string',
+    placeholder: raw.placeholder ?? null,
+    disabled: raw.disabled === true,
+    options: 'options' in raw
+        ? raw.options.map(option => ({
+            label: option.label,
+            value: option.value,
+        }))
+        : [],
+    customId: raw.custom_id,
+});
+/** Checks a message or an answer; written once for both. */
+function check(self, what, get) {
+    const present = () => {
+        const state = get();
+        expectThat(state.present, `${what} has no message to check.`);
+        return state;
+    };
+    return {
+        says(text) {
+            const { content } = present();
+            const matches = typeof text === 'string' ? content.includes(text) : text.test(content);
+            expectThat(matches, `${what} should say ${typeof text === 'string' ? shown(text) : text}, it says ${shown(content)}.`);
+            return self;
+        },
+        saysExactly(text) {
+            const { content } = present();
+            expectThat(content === text, `${what} should say exactly ${shown(text)}, it says ${shown(content)}.`);
+            return self;
+        },
+        isEphemeral() {
+            expectThat(present().ephemeral, `${what} should be ephemeral (seen by one person), it is seen by everyone.`);
+            return self;
+        },
+        isPublic() {
+            expectThat(!present().ephemeral, `${what} should be seen by everyone, it is ephemeral.`);
+            return self;
+        },
+        hasButton(label) {
+            const { buttons } = present();
+            expectThat(buttons.some(button => button.label === label), `${what} should have a button ${shown(label)}, its buttons are: ${buttons.map(button => shown(button.label ?? '')).join(', ') || 'none'}.`);
+            return self;
+        },
+        hasEmbed(title) {
+            const { embeds } = present();
+            expectThat(embeds.length > 0, `${what} should have an embed, it has none.`);
+            if (title !== undefined) {
+                expectThat(embeds.some(embed => embed.title === title), `${what} should have an embed titled ${shown(title)}, its embeds are titled: ${embeds.map(embed => shown(embed.title ?? '')).join(', ')}.`);
+            }
+            return self;
+        },
+        hasNoEmbed() {
+            const { embeds } = present();
+            expectThat(embeds.length === 0, `${what} should have no embed, it has ${embeds.length}.`);
+            return self;
+        },
+        hasNoComponent() {
+            const { buttons, menus } = present();
+            expectThat(buttons.length === 0 && menus.length === 0, `${what} should have no button or menu, it has ${buttons.length} button(s) and ${menus.length} menu(s).`);
+            return self;
+        },
+    };
+}
+/** The bot in its world, with the handles a test works with. */
+export class Session {
+    world;
+    project;
+    bot;
+    #observer;
+    #timeout;
+    #members = new Map();
+    #roles = new Map();
+    #channels = new Map();
+    #messages = new Map();
+    #someone = null;
+    constructor(world, project, bot, observer, options = {}) {
+        this.world = world;
+        this.project = project;
+        this.bot = bot;
+        this.#observer = observer;
+        this.#timeout = options.timeout ?? 5000;
+    }
+    get guild() {
+        return { id: this.world.guildId, name: this.world.guildName };
+    }
+    get me() {
+        return this.#member(this.world.botId);
+    }
+    get owner() {
+        return this.#member(this.world.ownerId);
+    }
+    get someone() {
+        return (this.#someone ??= this.member('someone'));
+    }
+    get requests() {
+        return this.world.discord.requests.map(({ method, path, body }) => ({
+            method,
+            path,
+            body,
+        }));
+    }
+    // ── Handles ──
+    #member(id) {
+        let handle = this.#members.get(id);
+        if (handle)
+            return handle;
+        const { world } = this;
+        const user = () => world.users.get(id);
+        const member = () => world.members.get(id);
+        const self = this;
+        handle = Object.freeze({
+            id,
+            get name() {
+                return user().username;
+            },
+            get nickname() {
+                return member()?.nick ?? null;
+            },
+            get roles() {
+                return (member()?.roles ?? [])
+                    .map(roleId => world.roles.get(roleId)?.name)
+                    .filter((name) => name !== undefined);
+            },
+            get permissions() {
+                return permissionNames(world.permissionsOf(id));
+            },
+            get inServer() {
+                return member() !== undefined;
+            },
+            get banned() {
+                return world.bans.has(id);
+            },
+            get timedOut() {
+                const until = member()?.communication_disabled_until;
+                return typeof until === 'string' && Date.parse(until) > Date.now();
+            },
+            get privateMessages() {
+                return (world.messages
+                    .get([...world.channels.values()].find(channel => channel.type === ChannelType.Dm &&
+                    channel.recipients?.[0]?.id === id)?.id ?? '')
+                    ?.map(raw => self.#message(raw)) ?? []);
+            },
+            can: (permission) => new Permissions(world.permissionsOf(id)).has(permission),
+            hasRole: (role) => (member()?.roles ?? []).some(roleId => typeof role === 'string'
+                ? world.roles.get(roleId)?.name === role
+                : roleId === role.id),
+        });
+        this.#members.set(id, handle);
+        return handle;
+    }
+    #role(id) {
+        let handle = this.#roles.get(id);
+        if (handle)
+            return handle;
+        const { world } = this;
+        handle = Object.freeze({
+            id,
+            get name() {
+                return world.roles.get(id)?.name ?? '';
+            },
+            get permissions() {
+                return permissionNames(BigInt(world.roles.get(id)?.permissions ?? '0'));
+            },
+            get exists() {
+                return world.roles.has(id);
+            },
+        });
+        this.#roles.set(id, handle);
+        return handle;
+    }
+    #channel(id) {
+        let handle = this.#channels.get(id);
+        if (handle)
+            return handle;
+        const { world } = this;
+        const self = this;
+        const raw = () => world.channels.get(id);
+        // What only one person saw (an ephemeral answer) is not in the channel.
+        const messages = () => (world.messages.get(id) ?? [])
+            .filter(message => ((message.flags ?? 0) & MessageFlags.Ephemeral) === 0)
+            .map(message => self.#message(message));
+        handle = Object.freeze({
+            id,
+            get name() {
+                return raw()?.name ?? '';
+            },
+            get type() {
+                return raw() ? channelTypeName(raw().type) : 'deleted';
+            },
+            get topic() {
+                return raw()?.topic ?? null;
+            },
+            get slowmode() {
+                return raw()?.rate_limit_per_user ?? 0;
+            },
+            get exists() {
+                return raw() !== undefined;
+            },
+            get messages() {
+                return messages();
+            },
+            get last() {
+                return messages().at(-1) ?? null;
+            },
+            get threads() {
+                return [...world.channels.values()]
+                    .filter(channel => channel.parent_id === id && world.isThread(channel))
+                    .map(thread => self.#channel(thread.id));
+            },
+            get members() {
+                return [...(world.threadMembers.get(id) ?? [])].map(userId => self.#member(userId));
+            },
+            get archived() {
+                return raw()?.thread_metadata?.archived === true;
+            },
+            get locked() {
+                return raw()?.thread_metadata?.locked === true;
+            },
+            allows: (who, permission) => {
+                const channel = raw();
+                if (!channel)
+                    return false;
+                const isRole = !('inServer' in who);
+                const base = isRole
+                    ? BigInt(world.roles.get(who.id)?.permissions ?? '0')
+                    : world.permissionsOf(who.id);
+                if ((base & PermissionFlags.Administrator) !== 0n)
+                    return true;
+                let permissions = base;
+                const overwrites = channel.permission_overwrites ?? [];
+                const apply = (overwriteId) => {
+                    const overwrite = overwrites.find(one => one.id === overwriteId);
+                    if (!overwrite)
+                        return;
+                    permissions &= ~BigInt(overwrite.deny);
+                    permissions |= BigInt(overwrite.allow);
+                };
+                apply(world.guildId);
+                if (!isRole) {
+                    for (const roleId of world.members.get(who.id)?.roles ?? [])
+                        apply(roleId);
+                }
+                else {
+                    apply(who.id);
+                }
+                apply(who.id);
+                return new Permissions(permissions).has(permission);
+            },
+        });
+        this.#channels.set(id, handle);
+        return handle;
+    }
+    #message(raw) {
+        let handle = this.#messages.get(raw.id);
+        if (handle)
+            return handle;
+        const { world } = this;
+        const self = this;
+        const current = () => world.findMessage(raw.id) ?? raw;
+        const parts = () => {
+            const message = current();
+            const { buttons, menus } = collectComponents(message.components);
+            return {
+                content: message.content,
+                embeds: toCamelCase(message.embeds),
+                buttons: buttons.map(buttonHandle),
+                menus: menus.map(menuHandle),
+                ephemeral: ((message.flags ?? 0) & MessageFlags.Ephemeral) !== 0,
+                present: true,
+            };
+        };
+        const base = {
+            id: raw.id,
+            get content() {
+                return current().content;
+            },
+            get author() {
+                return world.users.has(raw.author.id)
+                    ? self.#member(raw.author.id)
+                    : null;
+            },
+            fromBot: raw.author.id === world.botId,
+            get embeds() {
+                return parts().embeds;
+            },
+            get buttons() {
+                return parts().buttons;
+            },
+            get menus() {
+                return parts().menus;
+            },
+            get ephemeral() {
+                return parts().ephemeral;
+            },
+            get pinned() {
+                return current().pinned;
+            },
+            channel: this.#channel(raw.channel_id),
+            get deleted() {
+                return world.findMessage(raw.id) === undefined;
+            },
+            button(label) {
+                const found = parts().buttons.find(button => button.label === label);
+                expectThat(found !== undefined, `The message has no button ${shown(label)}: its buttons are ${parts()
+                    .buttons.map(button => shown(button.label ?? ''))
+                    .join(', ') || 'none'}.`);
+                return found;
+            },
+            menu(placeholder) {
+                const { menus } = parts();
+                const found = placeholder === undefined
+                    ? menus[0]
+                    : menus.find(menu => menu.placeholder === placeholder);
+                expectThat(found !== undefined, placeholder === undefined
+                    ? 'The message has no menu.'
+                    : `The message has no menu with the placeholder ${shown(placeholder)}.`);
+                return found;
+            },
+        };
+        handle = Object.freeze(Object.assign(base, check(base, 'The message', parts)));
+        this.#messages.set(raw.id, handle);
+        return handle;
+    }
+    #reply(record) {
+        const self = this;
+        const message = () => record.original ? self.#message(record.original) : null;
+        const parts = () => {
+            const found = message();
+            return {
+                content: found?.content ?? '',
+                embeds: found?.embeds ?? [],
+                buttons: found?.buttons ?? [],
+                menus: found?.menus ?? [],
+                ephemeral: found?.ephemeral ?? false,
+                present: found !== null,
+            };
+        };
+        const base = {
+            get message() {
+                return message();
+            },
+            get content() {
+                return parts().content;
+            },
+            get embeds() {
+                return parts().embeds;
+            },
+            get buttons() {
+                return parts().buttons;
+            },
+            get menus() {
+                return parts().menus;
+            },
+            get followUps() {
+                return record.followUps.map(raw => self.#message(raw));
+            },
+            get form() {
+                if (!record.modal)
+                    return null;
+                return Object.freeze({
+                    title: record.modal.title,
+                    fields: record.modal.components
+                        .map(component => {
+                        const label = component;
+                        return label.component?.custom_id;
+                    })
+                        .filter((name) => typeof name === 'string'),
+                    customId: record.modal.custom_id,
+                });
+            },
+            deferred: record.deferred,
+            updated: record.updated,
+            get ephemeral() {
+                return parts().ephemeral;
+            },
+            isDeferred() {
+                expectThat(record.deferred, 'The bot should have said the answer was coming (interaction.defer()), it answered right away.');
+                return reply;
+            },
+            updatesMessage() {
+                expectThat(record.updated, 'The bot should have changed the message of the component (interaction.update()), it answered with a new message instead.');
+                return reply;
+            },
+            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');
+                    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}.`);
+                }
+                return reply;
+            },
+            changesNothing() {
+                expectThat(record.deferred &&
+                    record.updated &&
+                    record.followUps.length === 0 &&
+                    record.callbacks.length === 1 &&
+                    (record.original === null ||
+                        record.original.edited_timestamp === null), 'The bot should have changed nothing (interaction.deferUpdate() alone), it answered something.');
+                return reply;
+            },
+            button(label) {
+                const found = message();
+                expectThat(found !== null, 'The bot answered with no message: there is no button to find.');
+                return found.button(label);
+            },
+            menu(placeholder) {
+                const found = message();
+                expectThat(found !== null, 'The bot answered with no message: there is no menu to find.');
+                return found.menu(placeholder);
+            },
+        };
+        const reply = Object.freeze(Object.assign(base, check(base, 'The answer', parts)));
+        return reply;
+    }
+    // ── Making things ──
+    member(name, options = {}) {
+        const existing = this.world.findUser(name);
+        if (existing)
+            return this.#member(existing.id);
+        const user = this.world.addUser(name, {
+            ...(options.bot ? { bot: true } : {}),
+            locale: options.locale ?? 'en-US',
+        });
+        const roles = (options.roles ?? []).map(role => typeof role === 'string' ? this.role(role).id : role.id);
+        if (options.permissions && options.permissions.length > 0) {
+            roles.push(this.role(`${name} permissions`, { permissions: options.permissions })
+                .id);
+        }
+        this.world.addMember(user.id, {
+            roles,
+            nick: options.nickname ?? null,
+        });
+        return this.#member(user.id);
+    }
+    role(name, options = {}) {
+        for (const role of this.world.roles.values()) {
+            if (role.name === name)
+                return this.#role(role.id);
+        }
+        const role = this.world.addRole(name, {
+            permissions: new Permissions([...(options.permissions ?? [])]).bits,
+        });
+        if (this.#connected()) {
+            this.world.dispatch('GUILD_ROLE_CREATE', {
+                guild_id: this.world.guildId,
+                role,
+            });
+        }
+        return this.#role(role.id);
+    }
+    channel(name, options = {}) {
+        const existing = this.world.findChannel(name);
+        if (existing)
+            return this.#channel(existing.id);
+        const channel = this.world.addChannel(name, {
+            type: CHANNEL_TYPES[options.type ?? 'text'],
+            parentId: options.parent?.id ?? null,
+            topic: options.topic ?? null,
+        });
+        if (this.#connected())
+            this.world.dispatch('CHANNEL_CREATE', channel);
+        return this.#channel(channel.id);
+    }
+    #connected() {
+        const connection = this.world.gateway.connections.at(-1);
+        return connection !== undefined && !connection.closed;
+    }
+    // ── Doing things ──
+    /** Who does something: the member given, or someone. */
+    #actor(where) {
+        const id = where?.by?.id ?? this.someone.id;
+        const user = this.world.users.get(id);
+        if (!user)
+            throw new TestFailure(`${where?.by?.name ?? 'This person'} is not in this world.`);
+        return user;
+    }
+    /** The channel something happens in. */
+    #place(where, actor, forDm) {
+        if (where?.in === 'dm' || (where?.in === undefined && forDm)) {
+            return this.world.dm(actor.id);
+        }
+        const id = where?.in?.id ?? this.world.findChannel('general').id;
+        const channel = this.world.channels.get(id);
+        if (!channel) {
+            throw new TestFailure(`The channel ${where?.in ? `#${where.in.name}` : '#general'} does not exist any more.`);
+        }
+        return channel;
+    }
+    #token() {
+        return `token-${this.world.snowflake()}`;
+    }
+    /** An interaction as Discord would send it. */
+    #rawInteraction(type, actor, channel, data, message) {
+        const inGuild = channel.guild_id !== undefined;
+        const member = inGuild ? this.world.members.get(actor.id) : undefined;
+        if (inGuild && !member) {
+            throw new TestFailure(`${actor.username} is not in the server: they can not use anything there.`);
+        }
+        const id = this.world.snowflake();
+        return {
+            id,
+            application_id: this.world.applicationId,
+            type,
+            data,
+            ...(inGuild
+                ? {
+                    guild_id: channel.guild_id,
+                    guild: {
+                        id: channel.guild_id,
+                        locale: 'en-US',
+                        features: [],
+                    },
+                    member: {
+                        ...member,
+                        permissions: this.world.permissionsOf(actor.id).toString(),
+                    },
+                    guild_locale: 'en-US',
+                    app_permissions: this.world
+                        .permissionsOf(this.world.botId)
+                        .toString(),
+                    context: 0,
+                    authorizing_integration_owners: { '0': channel.guild_id },
+                }
+                : {
+                    user: actor,
+                    app_permissions: '0',
+                    context: 1,
+                    authorizing_integration_owners: { '1': actor.id },
+                }),
+            channel_id: channel.id,
+            channel: {
+                id: channel.id,
+                type: channel.type,
+                ...(channel.name ? { name: channel.name } : {}),
+            },
+            token: this.#token(),
+            version: 1,
+            ...(message ? { message } : {}),
+            locale: actor.locale ?? 'en-US',
+            entitlements: [],
+            attachment_size_limit: 10 * 1024 * 1024,
+        };
+    }
+    /** Makes the interaction happen and waits for the bot to be done with it. */
+    async #interact(raw) {
+        const waiting = this.#observer.interaction(raw.id, this.#timeout);
+        const record = this.world.interaction(raw);
+        await waiting;
+        await this.#observer.settle();
+        return record;
+    }
+    #commandEntry(declaration) {
+        const run = declaration?.config?.run;
+        const entry = [...this.project.commands.values()].find(one => one.command.run === run);
+        if (!entry) {
+            throw new TestFailure(`This command is not loaded: is it exported from a file of src/ (export const ping = command({ ... })), and did its file load without error?`);
+        }
+        return entry;
+    }
+    async use(command, ...args) {
+        const [given = {}, where] = args;
+        const entry = this.#commandEntry(command);
+        const actor = this.#actor(where);
+        const channel = this.#place(where, actor, entry.command.where === 'dm');
+        const { options, resolved } = this.#commandOptions(entry, given, channel);
+        const raw = this.#rawInteraction(InteractionType.ApplicationCommand, actor, channel, this.#commandData(entry, options, resolved));
+        return this.#reply(await this.#interact(raw));
+    }
+    async suggest(command, option, typed, where) {
+        const entry = this.#commandEntry(command);
+        const declared = entry.command.options.find(one => one.name === option);
+        if (!declared) {
+            throw new TestFailure(`${commandName(entry.command.path)} has no option "${option}": its options are ${entry.command.options.map(one => one.name).join(', ') || 'none'}.`);
+        }
+        const actor = this.#actor(where);
+        const channel = this.#place(where, actor, entry.command.where === 'dm');
+        const isNumber = declared.type === 'integer' || declared.type === 'number';
+        const value = isNumber && typed !== '' && Number.isFinite(Number(typed))
+            ? Number(typed)
+            : typed;
+        const focused = {
+            name: option,
+            type: OPTION_TYPES[declared.type],
+            value,
+            focused: true,
+        };
+        const raw = this.#rawInteraction(InteractionType.ApplicationCommandAutocomplete, actor, channel, this.#commandData(entry, [focused], {}));
+        const record = await this.#interact(raw);
+        return (record.suggestions ?? []).map(choice => ({
+            name: choice.name,
+            value: choice.value,
+        }));
+    }
+    /** The `data` of a command interaction, subcommands nested as Discord does. */
+    #commandData(entry, options, resolved) {
+        const [name, ...rest] = entry.command.path;
+        let nested = options;
+        for (const part of [...rest].reverse()) {
+            nested = [
+                {
+                    name: part,
+                    type: rest.indexOf(part) === 0 && rest.length === 2
+                        ? ApplicationCommandOptionType.SubCommandGroup
+                        : ApplicationCommandOptionType.SubCommand,
+                    options: nested,
+                },
+            ];
+        }
+        const registered = this.world.guildCommands.find(command => command.name === name);
+        return {
+            id: registered?.id ?? this.world.snowflake(),
+            name: name,
+            type: ApplicationCommandType.ChatInput,
+            options: nested,
+            ...(Object.keys(resolved).length > 0 ? { resolved } : {}),
+            guild_id: this.world.guildId,
+        };
+    }
+    /** The options as Discord sends them, checked as its client would. */
+    #commandOptions(entry, given, channel) {
+        const name = commandName(entry.command.path);
+        const declared = entry.command.options;
+        for (const key of Object.keys(given)) {
+            if (!declared.some(option => option.name === key)) {
+                throw new TestFailure(`${name} has no option "${key}": its options are ${declared.map(option => option.name).join(', ') || 'none'}.`);
+            }
+        }
+        const options = [];
+        const resolved = {};
+        for (const option of declared) {
+            const value = given[option.name];
+            if (value === undefined) {
+                if (option.required) {
+                    throw new TestFailure(`The option "${option.name}" of ${name} is required: Discord would not let the command be sent without it.`);
+                }
+                continue;
+            }
+            const what = `The option "${option.name}" of ${name}`;
+            options.push({
+                name: option.name,
+                type: OPTION_TYPES[option.type],
+                value: this.#optionValue(what, option, value, resolved, channel),
+            });
+        }
+        return { options, resolved };
+    }
+    #optionValue(what, option, value, resolved, channel) {
+        const choices = 'choices' in option && option.choices
+            ? Array.isArray(option.choices)
+                ? [...option.choices]
+                : Object.values(option.choices)
+            : null;
+        if (choices && !choices.includes(value)) {
+            throw new TestFailure(`${what} must be one of its choices (${choices.map(shown).join(', ')}), got ${shown(value)}.`);
+        }
+        switch (option.type) {
+            case 'string': {
+                if (typeof value !== 'string') {
+                    throw new TestFailure(`${what} is a text, got ${shown(value)}.`);
+                }
+                if (option.minLength !== undefined && value.length < option.minLength) {
+                    throw new TestFailure(`${what} is ${option.minLength} characters at least, got ${value.length}.`);
+                }
+                if (option.maxLength !== undefined && value.length > option.maxLength) {
+                    throw new TestFailure(`${what} is ${option.maxLength} characters at most, got ${value.length}.`);
+                }
+                return value;
+            }
+            case 'integer':
+            case 'number': {
+                if (typeof value !== 'number' || !Number.isFinite(value)) {
+                    throw new TestFailure(`${what} is a number, got ${shown(value)}.`);
+                }
+                if (option.type === 'integer' && !Number.isInteger(value)) {
+                    throw new TestFailure(`${what} is a whole number, got ${value}.`);
+                }
+                if (option.min !== undefined && value < option.min) {
+                    throw new TestFailure(`${what} is ${option.min} at least, got ${value}.`);
+                }
+                if (option.max !== undefined && value > option.max) {
+                    throw new TestFailure(`${what} is ${option.max} at most, got ${value}.`);
+                }
+                return value;
+            }
+            case 'boolean':
+                if (typeof value !== 'boolean') {
+                    throw new TestFailure(`${what} is true or false, got ${shown(value)}.`);
+                }
+                return value;
+            case 'user':
+                return this.#resolveMember(what, value, resolved, channel);
+            case 'role':
+                return this.#resolveRole(what, value, resolved);
+            case 'mentionable':
+                return this.#isMember(value)
+                    ? this.#resolveMember(what, value, resolved, channel)
+                    : this.#resolveRole(what, value, resolved);
+            case 'channel':
+                return this.#resolveChannel(what, value, resolved);
+            case 'attachment':
+                return this.#resolveFile(what, value, resolved);
+        }
+    }
+    #isMember(value) {
+        return typeof value === 'object' && value !== null && 'inServer' in value;
+    }
+    #resolveMember(what, value, resolved, channel) {
+        if (!this.#isMember(value)) {
+            throw new TestFailure(`${what} is a person (bot.member('alice')), got ${shown(value)}.`);
+        }
+        const user = this.world.users.get(value.id);
+        if (!user)
+            throw new TestFailure(`${what}: ${value.name} is not in this world.`);
+        (resolved.users ??= {})[user.id] = user;
+        const member = channel.guild_id
+            ? this.world.members.get(user.id)
+            : undefined;
+        if (member) {
+            const { user: _user, ...rest } = member;
+            (resolved.members ??= {})[user.id] = {
+                ...rest,
+                permissions: this.world.permissionsOf(user.id).toString(),
+            };
+        }
+        return user.id;
+    }
+    #resolveRole(what, value, resolved) {
+        if (typeof value !== 'object' ||
+            value === null ||
+            !('exists' in value) ||
+            'inServer' in value ||
+            'messages' in value) {
+            throw new TestFailure(`${what} is a role (bot.role('Moderator')), got ${shown(value)}.`);
+        }
+        const role = this.world.roles.get(value.id);
+        if (!role)
+            throw new TestFailure(`${what}: that role does not exist any more.`);
+        (resolved.roles ??= {})[role.id] = role;
+        return role.id;
+    }
+    #resolveChannel(what, value, resolved) {
+        if (typeof value !== 'object' || value === null || !('messages' in value)) {
+            throw new TestFailure(`${what} is a channel (bot.channel('general')), got ${shown(value)}.`);
+        }
+        const channel = this.world.channels.get(value.id);
+        if (!channel)
+            throw new TestFailure(`${what}: that channel does not exist any more.`);
+        (resolved.channels ??= {})[channel.id] = {
+            id: channel.id,
+            type: channel.type,
+            name: channel.name,
+            ...(channel.guild_id ? { guild_id: channel.guild_id } : {}),
+            ...(channel.parent_id !== undefined
+                ? { parent_id: channel.parent_id }
+                : {}),
+            permissions: this.world.permissionsOf(this.world.botId).toString(),
+            ...(channel.thread_metadata
+                ? { thread_metadata: channel.thread_metadata }
+                : {}),
+        };
+        return channel.id;
+    }
+    #resolveFile(what, value, resolved) {
+        const file = value;
+        if (typeof file !== 'object' ||
+            file === null ||
+            typeof file.name !== 'string') {
+            throw new TestFailure(`${what} is a file ({ name: 'photo.png', content: '...' }), got ${shown(value)}.`);
+        }
+        const attachment = {
+            id: this.world.snowflake(),
+            filename: file.name,
+            size: Buffer.byteLength(file.content ?? ''),
+            url: `https://cdn.discordapp.test/${file.name}`,
+            proxy_url: `https://media.discordapp.test/${file.name}`,
+            ...(file.type ? { content_type: file.type } : {}),
+        };
+        (resolved.attachments ??= {})[attachment.id] = attachment;
+        return attachment.id;
+    }
+    /** The id and kind of a component, from how the test named it. */
+    #customIdOf(target, expected) {
+        if (typeof target === 'object' && target !== null && 'customId' in target) {
+            const id = target.customId;
+            if (typeof id !== 'string') {
+                throw new TestFailure('This button has no id: it is a link or a premium button, which the bot never hears of.');
+            }
+            return id;
+        }
+        const state = componentStateOf(target);
+        if (state && !state.bound) {
+            throw new TestFailure(`This ${state.kind} is not loaded: is it exported from a file of src/, and did its file load without error?`);
+        }
+        if (!isPiece(target)) {
+            throw new TestFailure(`Give the ${expected === 'modal' ? 'form' : expected === 'select' ? 'menu' : 'button'} itself (its export, called with its data when it has some) or one found on an answer (reply.button('Confirm')), got ${shown(target)}.`);
+        }
+        const rendered = renderedOf(target, 'The component given to the test');
+        if (rendered.kind !== expected) {
+            throw new TestFailure(`Expected a ${expected === 'modal' ? 'form' : expected === 'select' ? 'menu' : 'button'}, got a ${rendered.kind}.`);
+        }
+        const raw = resolve(rendered, translatorOf(this.bot.ctx, { person: 'en-US', ephemeral: true })).raw;
+        if (typeof raw.custom_id !== 'string') {
+            throw new TestFailure('This component has no id the bot could hear of.');
+        }
+        return raw.custom_id;
+    }
+    #componentEntry(kind, customId) {
+        const name = customId.split(':')[0];
+        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) {
+        const given = where?.on;
+        if (given) {
+            const id = 'message' in given ? given.message?.id : given.id;
+            const found = id ? this.world.findMessage(id) : undefined;
+            if (!found) {
+                throw new TestFailure('message' in given
+                    ? 'The answer given in "on" has no message: the bot answered with none.'
+                    : 'The message given in "on" was deleted.');
+            }
+            return found;
+        }
+        // Not sent: a message of the bot the person is looking at.
+        return {
+            id: this.world.snowflake(),
+            channel_id: channel.id,
+            author: this.world.bot,
+            content: '',
+            timestamp: new Date().toISOString(),
+            edited_timestamp: null,
+            tts: false,
+            mention_everyone: false,
+            mentions: [],
+            mention_roles: [],
+            attachments: [],
+            embeds: [],
+            pinned: false,
+            type: MessageType.Default,
+            flags: 0,
+            components: [
+                { type: ComponentType.ActionRow, components: [component] },
+            ],
+            interaction_metadata: {
+                id: this.world.snowflake(),
+                type: InteractionType.ApplicationCommand,
+                user: actor,
+                authorizing_integration_owners: {},
+            },
+        };
+    }
+    async click(button, where) {
+        const customId = this.#customIdOf(button, 'button');
+        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 raw = this.#rawInteraction(InteractionType.MessageComponent, actor, channel, { custom_id: customId, component_type: ComponentType.Button }, message);
+        return this.#reply(await this.#interact(raw));
+    }
+    async select(menu, values, where) {
+        const customId = this.#customIdOf(menu, 'select');
+        const entry = this.#componentEntry('select', customId);
+        const actor = this.#actor(where);
+        const channel = this.#place(where, actor, entry?.component.kind === 'select' && entry.component.where === 'dm');
+        const type = typeof menu === 'object' && menu !== null && 'customId' in menu
+            ? menu.type
+            : entry?.component.kind === 'select'
+                ? entry.component.type
+                : 'string';
+        const resolved = {};
+        const what = `What is picked in ${customId.split(':')[0]}`;
+        const picked = values.map(value => {
+            if (type === 'string') {
+                if (typeof value !== 'string') {
+                    throw new TestFailure(`${what} is a text (the value of an option), got ${shown(value)}.`);
+                }
+                return value;
+            }
+            if (type === 'user')
+                return this.#resolveMember(what, value, resolved, channel);
+            if (type === 'role')
+                return this.#resolveRole(what, value, resolved);
+            if (type === 'channel')
+                return this.#resolveChannel(what, value, resolved);
+            return this.#isMember(value)
+                ? this.#resolveMember(what, value, resolved, channel)
+                : this.#resolveRole(what, value, resolved);
+        });
+        if (entry?.component.kind === 'select') {
+            const { min, max, options, name } = entry.component;
+            if (picked.length < min || picked.length > max) {
+                throw new TestFailure(`${name} takes ${min === max ? min : `${min} to ${max}`} value(s): Discord would not let ${picked.length} be sent.`);
+            }
+            if (type === 'string' && options.length > 0) {
+                const allowed = options.map(option => option.value);
+                for (const value of picked) {
+                    if (!allowed.includes(value)) {
+                        throw new TestFailure(`${name} has no option ${shown(value)}: its options are ${allowed.map(shown).join(', ')}.`);
+                    }
+                }
+            }
+        }
+        const componentType = SELECT_COMPONENT_TYPES[type] ?? ComponentType.StringSelect;
+        const message = this.#messageFor(where, actor, channel, {
+            type: componentType,
+            custom_id: customId,
+            ...(componentType === ComponentType.StringSelect ? { options: [] } : {}),
+        });
+        const raw = this.#rawInteraction(InteractionType.MessageComponent, actor, channel, {
+            custom_id: customId,
+            component_type: componentType,
+            values: picked,
+            ...(Object.keys(resolved).length > 0 ? { resolved } : {}),
+        }, message);
+        return this.#reply(await this.#interact(raw));
+    }
+    async submit(form, fields = {}, where) {
+        const customId = this.#customIdOf(form, 'modal');
+        const entry = this.#componentEntry('modal', customId);
+        if (!entry || entry.component.kind !== 'modal') {
+            throw new TestFailure(`The form ${customId.split(':')[0]} is not loaded: is it exported from a file of src/, and did its file load without error?`);
+        }
+        const modal = entry.component;
+        const actor = this.#actor(where);
+        const channel = this.#place(where, actor, modal.where === 'dm');
+        const given = fields;
+        for (const key of Object.keys(given)) {
+            if (!modal.fields.some(field => field.name === key && field.field.type !== 'note')) {
+                throw new TestFailure(`The form ${modal.name} has no field "${key}": its fields are ${modal.fields
+                    .filter(field => field.field.type !== 'note')
+                    .map(field => field.name)
+                    .join(', ')}.`);
+            }
+        }
+        const resolved = {};
+        const components = [];
+        let id = 1;
+        for (const loaded of modal.fields) {
+            const { name, field, required, min, max } = loaded;
+            if (field.type === 'note')
+                continue;
+            const what = `The field "${name}" of ${modal.name}`;
+            const value = given[name];
+            const count = (list) => {
+                if (required && list.length === 0) {
+                    throw new TestFailure(`${what} is required: Discord would not let the form be sent empty.`);
+                }
+                if (list.length > 0 && (list.length < min || list.length > max)) {
+                    throw new TestFailure(`${what} takes ${min === max ? min : `${min} to ${max}`} value(s), got ${list.length}.`);
+                }
+            };
+            let component;
+            switch (field.type) {
+                case 'text': {
+                    const text = value === undefined ? '' : value;
+                    if (typeof text !== 'string')
+                        throw new TestFailure(`${what} is a text, got ${shown(value)}.`);
+                    if (required && text === '') {
+                        throw new TestFailure(`${what} is required: Discord would not let the form be sent empty.`);
+                    }
+                    if (text !== '' && (text.length < min || text.length > max)) {
+                        throw new TestFailure(`${what} is ${min} to ${max} characters, got ${text.length}.`);
+                    }
+                    component = {
+                        type: ComponentType.TextInput,
+                        id: id++,
+                        custom_id: name,
+                        value: text,
+                    };
+                    break;
+                }
+                case 'select':
+                case 'checkboxes': {
+                    const list = value === undefined ? [] : value;
+                    if (!Array.isArray(list) ||
+                        list.some(one => typeof one !== 'string')) {
+                        throw new TestFailure(`${what} is a list of option values, got ${shown(value)}.`);
+                    }
+                    const allowed = loaded.options.map(option => option.value);
+                    for (const one of list) {
+                        if (!allowed.includes(one)) {
+                            throw new TestFailure(`${what} has no option ${shown(one)}: its options are ${allowed.map(shown).join(', ')}.`);
+                        }
+                    }
+                    count(list);
+                    component = {
+                        type: field.type === 'select'
+                            ? ComponentType.StringSelect
+                            : ComponentType.CheckboxGroup,
+                        id: id++,
+                        custom_id: name,
+                        values: list,
+                    };
+                    break;
+                }
+                case 'radio': {
+                    if (value === undefined) {
+                        if (required)
+                            throw new TestFailure(`${what} is required: Discord would not let the form be sent without a choice.`);
+                        component = {
+                            type: ComponentType.RadioGroup,
+                            id: id++,
+                            custom_id: name,
+                            value: null,
+                        };
+                        break;
+                    }
+                    const allowed = loaded.options.map(option => option.value);
+                    if (typeof value !== 'string' || !allowed.includes(value)) {
+                        throw new TestFailure(`${what} is one of ${allowed.map(shown).join(', ')}, got ${shown(value)}.`);
+                    }
+                    component = {
+                        type: ComponentType.RadioGroup,
+                        id: id++,
+                        custom_id: name,
+                        value,
+                    };
+                    break;
+                }
+                case 'checkbox':
+                    if (value !== undefined && typeof value !== 'boolean') {
+                        throw new TestFailure(`${what} is true or false, got ${shown(value)}.`);
+                    }
+                    component = {
+                        type: ComponentType.Checkbox,
+                        id: id++,
+                        custom_id: name,
+                        value: value === true,
+                    };
+                    break;
+                case 'files': {
+                    const list = value === undefined ? [] : value;
+                    if (!Array.isArray(list))
+                        throw new TestFailure(`${what} is a list of files, got ${shown(value)}.`);
+                    count(list);
+                    component = {
+                        type: ComponentType.FileUpload,
+                        id: id++,
+                        custom_id: name,
+                        values: list.map(file => this.#resolveFile(what, file, resolved)),
+                    };
+                    break;
+                }
+                default: {
+                    const list = value === undefined ? [] : value;
+                    if (!Array.isArray(list))
+                        throw new TestFailure(`${what} is a list, got ${shown(value)}.`);
+                    count(list);
+                    const picked = list.map(one => field.type === 'user'
+                        ? this.#resolveMember(what, one, resolved, channel)
+                        : field.type === 'role'
+                            ? this.#resolveRole(what, one, resolved)
+                            : field.type === 'channel'
+                                ? this.#resolveChannel(what, one, resolved)
+                                : this.#isMember(one)
+                                    ? this.#resolveMember(what, one, resolved, channel)
+                                    : this.#resolveRole(what, one, resolved));
+                    component = {
+                        type: SELECT_COMPONENT_TYPES[field.type],
+                        id: id++,
+                        custom_id: name,
+                        values: picked,
+                        resolved,
+                    };
+                }
+            }
+            components.push({
+                type: ComponentType.Label,
+                id: id++,
+                component,
+            });
+        }
+        const opened = where?.on
+            ? this.#messageFor(where, actor, channel, {
+                type: ComponentType.Button,
+                style: 2,
+                custom_id: 'opened',
+            })
+            : undefined;
+        const raw = this.#rawInteraction(InteractionType.ModalSubmit, actor, channel, {
+            custom_id: customId,
+            components,
+            ...(Object.keys(resolved).length > 0 ? { resolved } : {}),
+        }, opened);
+        return this.#reply(await this.#interact(raw));
+    }
+    async say(content, where) {
+        const actor = this.#actor(where);
+        const channel = this.#place(where, actor, false);
+        if (channel.guild_id && !this.world.members.has(actor.id)) {
+            throw new TestFailure(`${actor.username} is not in the server: they can not write there.`);
+        }
+        const id = this.world.snowflake();
+        const done = this.#observer.event((type, data) => type === 'MESSAGE_CREATE' && data.id === id, this.#timeout);
+        const message = this.world.createMessage(channel.id, actor, { content }, {}, {
+            id,
+        });
+        await done;
+        await this.#observer.settle();
+        return this.#message(message);
+    }
+    async react(message, emoji, where) {
+        const actor = this.#actor(where);
+        const raw = this.world.findMessage(message.id);
+        if (!raw)
+            throw new TestFailure('That message was deleted.');
+        const channel = this.world.channels.get(raw.channel_id);
+        const [name, id] = emoji.includes(':')
+            ? emoji.split(':')
+            : [emoji, undefined];
+        const done = this.#observer.event((type, data) => type === 'MESSAGE_REACTION_ADD' &&
+            data.message_id === raw.id, this.#timeout);
+        this.world.dispatch('MESSAGE_REACTION_ADD', {
+            user_id: actor.id,
+            channel_id: raw.channel_id,
+            message_id: raw.id,
+            ...(channel.guild_id
+                ? {
+                    guild_id: channel.guild_id,
+                    member: this.world.members.get(actor.id),
+                }
+                : {}),
+            emoji: { id: id ?? null, name },
+            burst: false,
+            type: 0,
+        });
+        await done;
+        await this.#observer.settle();
+    }
+    async join(member, options) {
+        let user;
+        if (typeof member === 'string') {
+            user =
+                this.world.findUser(member) ??
+                    this.world.addUser(member, {
+                        ...(options?.bot ? { bot: true } : {}),
+                        locale: options?.locale ?? 'en-US',
+                    });
+        }
+        else {
+            user = this.world.users.get(member.id);
+        }
+        if (!user)
+            throw new TestFailure('That person is not in this world.');
+        if (this.world.members.has(user.id)) {
+            throw new TestFailure(`${user.username} is already in the server.`);
+        }
+        if (this.world.bans.has(user.id)) {
+            throw new TestFailure(`${user.username} is banned: Discord would not let them join.`);
+        }
+        const roles = (options?.roles ?? []).map(role => typeof role === 'string' ? this.role(role).id : role.id);
+        if (options?.permissions && options.permissions.length > 0) {
+            roles.push(this.role(`${user.username} permissions`, {
+                permissions: options.permissions,
+            }).id);
+        }
+        const raw = this.world.addMember(user.id, {
+            roles,
+            nick: options?.nickname ?? null,
+        });
+        const done = this.#observer.event((type, data) => type === 'GUILD_MEMBER_ADD' &&
+            data.user?.id === user.id, this.#timeout);
+        this.world.dispatch('GUILD_MEMBER_ADD', {
+            ...raw,
+            guild_id: this.world.guildId,
+        });
+        await done;
+        await this.#observer.settle();
+        return this.#member(user.id);
+    }
+    async leave(member) {
+        if (!this.world.members.has(member.id)) {
+            throw new TestFailure(`${member.name} is not in the server.`);
+        }
+        const done = this.#observer.event((type, data) => type === 'GUILD_MEMBER_REMOVE' &&
+            data.user.id === member.id, this.#timeout);
+        this.world.removeMember(member.id);
+        await done;
+        await this.#observer.settle();
+    }
+    async run(task, at = new Date()) {
+        const run = task?.config?.run;
+        const entry = [...this.project.tasks.values()].find(one => one.task.run === run);
+        if (!entry) {
+            throw new TestFailure('This task is not loaded: is it exported from a file of src/ (export const weekly = task({ ... })), and did its file load without error?');
+        }
+        await this.project.runTask(entry, this.bot, at);
+        await this.#observer.settle();
+    }
+    settle() {
+        return 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.
+     */
+    async emit(type, data) {
+        const done = this.#observer.event(event => event === type, this.#timeout);
+        this.world.dispatch(type, data);
+        await done;
+        await this.#observer.settle();
+    }
+    /**
+     * Runs `act`, which makes the world send the event `type`, and waits for
+     * the files to be done with it.
+     */
+    async expectEvent(type, act) {
+        const done = this.#observer.event(event => event === type, this.#timeout);
+        act();
+        await done;
+        await this.#observer.settle();
+    }
+}
+const OPTION_TYPES = {
+    string: ApplicationCommandOptionType.String,
+    integer: ApplicationCommandOptionType.Integer,
+    number: ApplicationCommandOptionType.Number,
+    boolean: ApplicationCommandOptionType.Boolean,
+    user: ApplicationCommandOptionType.User,
+    role: ApplicationCommandOptionType.Role,
+    channel: ApplicationCommandOptionType.Channel,
+    mentionable: ApplicationCommandOptionType.Mentionable,
+    attachment: ApplicationCommandOptionType.Attachment,
+};
+const SELECT_COMPONENT_TYPES = {
+    string: ComponentType.StringSelect,
+    user: ComponentType.UserSelect,
+    role: ComponentType.RoleSelect,
+    mentionable: ComponentType.MentionableSelect,
+    channel: ComponentType.ChannelSelect,
+};