chapterjs 0.2.3 → 0.3.0

package/dist/cli/test.js

@@ -0,0 +1,444 @@
+// `chapterjs test`: runs the bot of the current folder against a Discord
+// in memory and checks it, without a token and without touching Discord.
+// First what needs nothing written: every command, button, menu, form,
+// event and task is used once with ordinary values and with hard ones,
+// and must answer without throwing. Then the scenarios of the project
+// (`src/**/*.test.ts`, written with `scenario()` from 'chapterjs/test'),
+// each on a fresh server.
+import { join } from 'node:path';
+import { enableProjectLoader } from '../loader/hot.js';
+import { listTests, loadFiles, readDeclarations, siteName, } from '../loader/loader.js';
+import { locate, messageOf } from '../loader/locate.js';
+import { MemoryStoreBackend } from '../store/memory-backend.js';
+import { TestFailure } from '../testing/failure.js';
+import { captureLog, Observer, Session } from '../testing/harness.js';
+import { scenarioDeclaration, } from '../testing/scenario.js';
+import { smokeChecks } from '../testing/smoke.js';
+import { World } from '../testing/world.js';
+import { createProject, hasSources, writeTypes, } from './project.js';
+/**
+ * What a terminal shows while a file is tested: `↻ Testing src/close.ts`,
+ * then one line per thing and case as it is tried. Once the file is done,
+ * those lines are erased and its result takes their place, so a report
+ * that passed reads as if nothing had moved. When nobody is watching (the
+ * output is not a terminal), nothing is shown meanwhile.
+ */
+export function checkProgress(enabled, log, write) {
+    let lines = 0;
+    return {
+        start(title) {
+            if (!enabled)
+                return;
+            log.reload(title);
+            lines = 1;
+        },
+        step(label) {
+            if (!enabled)
+                return;
+            write(`  → ${label}\n`);
+            lines++;
+        },
+        clear() {
+            if (!enabled || lines === 0)
+                return;
+            // Up to the first line of the check, then everything below it goes.
+            write(`\x1b[${lines}A\x1b[0J`);
+            lines = 0;
+        },
+    };
+}
+/** What the files said to the developer during a check, as failures. */
+function problems(captured) {
+    const failures = [...captured.errors];
+    const warnings = [];
+    for (const warning of captured.warnings) {
+        // The person sees "The application did not respond": a failure.
+        if (warning.includes('finished without answering'))
+            failures.push(warning);
+        else
+            warnings.push(warning);
+    }
+    return { failures, warnings };
+}
+/** Where a failure of a scenario comes from, when it is in the project. */
+function where(error, cwd) {
+    const found = locate(error, cwd);
+    return found ? `${found.file}:${found.line} ` : '';
+}
+/** Runs the whole project in a fresh world; `close` ends it. */
+async function startSession(project, observer, stores) {
+    stores.clear();
+    observer.reset();
+    const world = new World();
+    await world.start();
+    let bot;
+    try {
+        bot = await project.connect({
+            token: 'test-token',
+            apiUrl: world.discord.url,
+            privateEvents: true,
+            onFatal: () => { },
+        });
+    }
+    catch (error) {
+        await world.close();
+        throw error;
+    }
+    const session = new Session(world, project, bot, observer);
+    return {
+        session,
+        close: async () => {
+            await bot.close();
+            await world.close();
+        },
+    };
+}
+/**
+ * What the files print while they are tested, kept out of the report: a
+ * `console.log` of a `ready` event saying "online" would read as the bot
+ * being online. The runner writes through `report()`; what the files wrote
+ * is given back by `take()`, to show under a failure.
+ */
+function quiet() {
+    const original = {
+        out: process.stdout.write.bind(process.stdout),
+        err: process.stderr.write.bind(process.stderr),
+    };
+    let printed = '';
+    const swallow = (chunk) => {
+        printed +=
+            typeof chunk === 'string'
+                ? chunk
+                : Buffer.from(chunk).toString();
+        return true;
+    };
+    const silence = () => {
+        process.stdout.write = swallow;
+        process.stderr.write = swallow;
+    };
+    const restore = () => {
+        process.stdout.write = original.out;
+        process.stderr.write = original.err;
+    };
+    silence();
+    return {
+        report(write) {
+            restore();
+            try {
+                write();
+            }
+            finally {
+                silence();
+            }
+        },
+        take() {
+            const taken = printed;
+            printed = '';
+            return taken;
+        },
+        restore,
+    };
+}
+/** What the files printed, as the lines under a failure. */
+function printed(output) {
+    const text = output.trim();
+    if (text === '')
+        return '';
+    return `\nWhat the files printed meanwhile:\n${text}`;
+}
+/** Resolves with the exit code of the process. */
+export async function test(options) {
+    const { cwd } = options;
+    if (!(await hasSources(cwd, options.log)))
+        return 1;
+    const src = join(cwd, 'src');
+    const output = quiet();
+    try {
+        return await run(options, src, output);
+    }
+    finally {
+        output.restore();
+    }
+}
+async function run(options, src, output) {
+    const { cwd } = options;
+    // The report, written while what the files print is kept out of it.
+    const log = {
+        success: message => output.report(() => options.log.success(message)),
+        info: message => output.report(() => options.log.info(message)),
+        reload: message => output.report(() => options.log.reload(message)),
+        warn: message => output.report(() => options.log.warn(message)),
+        error: message => output.report(() => options.log.error(message)),
+    };
+    // 1. The files of the project, every one of them running.
+    enableProjectLoader(src, { reload: false });
+    const capture = captureLog();
+    const observer = new Observer();
+    const stores = new MemoryStoreBackend();
+    const project = createProject({
+        cwd,
+        version: options.version,
+        log: capture.log,
+        stores,
+        observe: observer.observe,
+    });
+    await writeTypes(cwd);
+    const failures = await project.load();
+    await writeTypes(cwd, project.typesInfo());
+    if (failures.length > 0) {
+        for (const failure of failures)
+            report(failure, cwd, log);
+        log.error(`${failures.length === 1 ? 'This file' : `These ${failures.length} files`} can't run, so your bot was not tested. Fix ${failures.length === 1 ? 'it' : 'them'} and test again: chapterjs dev shows the same errors while you write.${printed(output.take())}`);
+        await project.closeStores();
+        return 1;
+    }
+    if (project.isEmpty()) {
+        log.info(project.summary());
+        await project.closeStores();
+        return 0;
+    }
+    log.success(project.summary());
+    output.take();
+    let checksPassed = 0;
+    let checksFailed = 0;
+    let scenariosPassed = 0;
+    let scenariosFailed = 0;
+    try {
+        // 2. What needs nothing written: every file used once. The report
+        // has one line per file: what was checked in it only shows when
+        // something failed.
+        const { checks, notSimulated } = smokeChecks(project);
+        const smoke = await startSession(project, observer, stores);
+        const progress = checkProgress(options.progress === true, log, text => output.report(() => process.stdout.write(text)));
+        try {
+            // The ready event runs first, as it does online; its result is
+            // reported with the file it comes from.
+            project.ready(smoke.session.bot);
+            await smoke.session.settle();
+            const atStart = problems(capture.take());
+            const readyPrinted = output.take();
+            const readyFiles = [
+                ...new Set([...project.events.values()]
+                    .filter(({ event }) => event.name === 'ready')
+                    .map(({ file }) => file)),
+            ];
+            for (const warning of atStart.warnings)
+                log.warn(warning);
+            /** What was found in each file, in the order of the files. */
+            const byFile = new Map();
+            for (const file of readyFiles)
+                byFile.set(file, []);
+            for (const check of checks) {
+                byFile.set(check.file, [...(byFile.get(check.file) ?? []), check]);
+            }
+            // The files that passed are one line at the end: these checks are
+            // the framework's, what the developer reads is the scenarios.
+            const quietFiles = [];
+            let quietChecks = 0;
+            for (const [file, own] of [...byFile].sort(([a], [b]) => a < b ? -1 : 1)) {
+                progress.start(`Checking ${file}`);
+                const failures = [];
+                const warnings = [];
+                let passed = 0;
+                if (readyFiles.includes(file)) {
+                    if (atStart.failures.length > 0) {
+                        failures.push(`event ready failed: ${atStart.failures.map(failure => failure.split('\n').join(' ')).join('; ')}${printed(readyPrinted)}`);
+                    }
+                    else
+                        passed++;
+                }
+                for (const check of own) {
+                    progress.step(check.subject);
+                    const result = await runCheck(check, smoke.session, capture, cwd, label => progress.step(`${check.subject}, ${label}`));
+                    const wrote = output.take();
+                    if (result.failed.length === 0)
+                        passed++;
+                    else {
+                        // One case: its label says nothing more than the subject.
+                        failures.push(check.cases.length === 1
+                            ? `${check.subject} failed\n${result.failed[0].message}${printed(wrote)}`
+                            : `${check.subject} failed in ${result.failed.length === check.cases.length ? 'every case' : `${result.failed.length} of ${check.cases.length} cases`}\n${result.failed.map(one => `${one.label}: ${one.message}`).join('\n')}${printed(wrote)}`);
+                    }
+                    for (const warning of result.warnings)
+                        warnings.push(`${check.subject}: ${warning}`);
+                }
+                progress.clear();
+                checksPassed += passed;
+                checksFailed += failures.length;
+                if (failures.length === 0) {
+                    quietFiles.push(file);
+                    quietChecks += passed;
+                }
+                for (const failure of failures)
+                    log.error(`Checked ${file}: ${failure}`);
+                for (const warning of warnings)
+                    log.warn(`Checked ${file}: ${warning}`);
+            }
+            if (quietFiles.length > 0) {
+                const files = `${quietFiles.length} ${quietFiles.length === 1 ? 'file' : 'files'}`;
+                const count = `${quietChecks} ${quietChecks === 1 ? 'check' : 'checks'}`;
+                log.success(quietFiles.length === byFile.size
+                    ? `Checked every file once: ${count} in ${files}`
+                    : `Checked the other ${files} once: ${count}`);
+            }
+        }
+        finally {
+            await smoke.close();
+        }
+        if (notSimulated.length > 0) {
+            log.info(`${notSimulated.length === 1 ? 'An event is' : 'Some events are'} not simulated yet, so ${notSimulated.length === 1 ? 'its file was' : 'their files were'} not run: ${notSimulated.join(', ')}.`);
+        }
+        // 3. The scenarios of the project, each on a fresh server: one line
+        // per test file, the scenarios of it only shown when one failed.
+        const files = await listTests(cwd);
+        const { loaded, broken } = await loadScenarios(files, cwd, log);
+        scenariosFailed += broken;
+        const scenariosByFile = new Map();
+        for (const { scenario, file } of loaded) {
+            scenariosByFile.set(file, [
+                ...(scenariosByFile.get(file) ?? []),
+                scenario,
+            ]);
+        }
+        for (const [file, own] of scenariosByFile) {
+            progress.start(`Testing ${file}`);
+            const failures = [];
+            const warnings = [];
+            let passed = 0;
+            for (const scenario of own) {
+                progress.step(`"${scenario.label}"`);
+                const run = await startSession(project, observer, stores);
+                let failure = null;
+                try {
+                    project.ready(run.session.bot);
+                    await run.session.settle();
+                    capture.take();
+                    output.take();
+                    await withTimeout(Promise.resolve(scenario.run(run.session)), options.scenarioTimeout ?? 10_000, `took more than ${(options.scenarioTimeout ?? 10_000) / 1000} s: is something waiting for an answer that never comes?`);
+                    await run.session.settle();
+                }
+                catch (error) {
+                    failure =
+                        error instanceof TestFailure
+                            ? `${where(error, cwd)}${error.message}`
+                            : `${where(error, cwd)}${messageOf(error)}`;
+                }
+                finally {
+                    await run.close();
+                }
+                const captured = problems(capture.take());
+                const wrote = output.take();
+                if (failure === null && captured.failures.length === 0)
+                    passed++;
+                else {
+                    failures.push(`"${scenario.label}" failed\n${[...(failure ? [failure] : []), ...captured.failures].join('\n')}${printed(wrote)}`);
+                }
+                for (const warning of captured.warnings)
+                    warnings.push(`"${scenario.label}": ${warning}`);
+            }
+            progress.clear();
+            scenariosPassed += passed;
+            scenariosFailed += failures.length;
+            if (failures.length === 0)
+                log.success(`Tested ${file}`);
+            for (const failure of failures)
+                log.error(`Tested ${file}: ${failure}`);
+            for (const warning of warnings)
+                log.warn(`Tested ${file}: ${warning}`);
+        }
+        if (files.length === 0) {
+            log.info(`No scenario yet. Write one in a *.test.ts file of src/ with scenario() from 'chapterjs/test' to check what your bot answers.`);
+        }
+    }
+    finally {
+        await project.closeStores();
+    }
+    // 4. The bottom line.
+    const checksTotal = checksPassed + checksFailed;
+    const scenariosTotal = scenariosPassed + scenariosFailed;
+    const parts = [
+        `${checksTotal} ${checksTotal === 1 ? 'check' : 'checks'}`,
+        ...(scenariosTotal > 0
+            ? [`${scenariosTotal} ${scenariosTotal === 1 ? 'scenario' : 'scenarios'}`]
+            : []),
+    ];
+    if (checksFailed === 0 && scenariosFailed === 0) {
+        log.success(`${parts.join(' and ')} passed`);
+        return 0;
+    }
+    log.error(`${[
+        ...(checksFailed > 0
+            ? [
+                `${checksFailed} of ${checksTotal} ${checksTotal === 1 ? 'check' : 'checks'}`,
+            ]
+            : []),
+        ...(scenariosFailed > 0
+            ? [
+                `${scenariosFailed} of ${scenariosTotal} ${scenariosTotal === 1 ? 'scenario' : 'scenarios'}`,
+            ]
+            : []),
+    ].join(' and ')} failed`);
+    return 1;
+}
+/** Shows a file (or an export) that could not run. */
+function report(failure, cwd, log) {
+    const found = locate(failure.error, cwd);
+    log.error(`${found ? `${found.file}:${found.line}` : siteName(failure)} ${messageOf(failure.error)}`);
+}
+/** Runs the cases of a check, one after the other, in the same world. */
+async function runCheck(check, session, capture, cwd, onCase = () => { }) {
+    const failed = [];
+    const warnings = [];
+    for (const one of check.cases) {
+        onCase(one.label);
+        capture.take();
+        let thrown = null;
+        try {
+            await withTimeout(one.run(session), 5000, 'the bot did not answer within 5 s');
+        }
+        catch (error) {
+            thrown =
+                error instanceof TestFailure
+                    ? error.message
+                    : `${where(error, cwd)}${messageOf(error)}`;
+        }
+        const captured = problems(capture.take());
+        const messages = [...(thrown ? [thrown] : []), ...captured.failures];
+        if (messages.length > 0) {
+            failed.push({ label: one.label, message: messages.join('; ') });
+        }
+        for (const warning of captured.warnings) {
+            if (!warnings.includes(warning))
+                warnings.push(warning);
+        }
+    }
+    return { failed, warnings };
+}
+/** Loads the test files and reads their scenarios; what fails is reported. */
+async function loadScenarios(files, cwd, log) {
+    const sources = await loadFiles(files);
+    const read = readDeclarations(sources.modules, scenarioDeclaration);
+    const failures = [...sources.failed, ...read.failed];
+    for (const failure of failures)
+        report(failure, cwd, log);
+    const loaded = read.loaded.map(item => ({
+        scenario: item.value,
+        file: item.file,
+    }));
+    for (const { file, exports } of sources.modules) {
+        if (!read.loaded.some(item => item.file === file) &&
+            !read.failed.some(item => item.file === file)) {
+            log.warn(`${file} declares no scenario: export one made with scenario() from 'chapterjs/test'${Object.keys(exports).length === 0 ? '' : ` (its exports are: ${Object.keys(exports).join(', ')})`}.`);
+        }
+    }
+    return { loaded, broken: failures.length };
+}
+function withTimeout(promise, ms, message) {
+    let timer;
+    return Promise.race([
+        promise.finally(() => clearTimeout(timer)),
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new TestFailure(message)), ms);
+        }),
+    ]);
+}

package/dist/commands/autocomplete.d.ts

@@ -10,4 +10,4 @@ export declare const MAX_SUGGESTIONS = 25;
  * is empty, so every path ends with an answer, even when the function
  * fails: the person is never left with a spinner.
  */
-export declare function suggest(ctx: Context, raw: RawInteraction, entry: CommandEntry | undefined, given: readonly RawApplicationCommandInteractionDataOption[], reporter: Reporter, warnedOnce: Set<string>): void;
+export declare function suggest(ctx: Context, raw: RawInteraction, entry: CommandEntry | undefined, given: readonly RawApplicationCommandInteractionDataOption[], reporter: Reporter, warnedOnce: Set<string>): Promise<void>;

package/dist/commands/autocomplete.js

@@ -27,39 +27,37 @@ const UNKNOWN_INTERACTION = 10062;
 export function suggest(ctx, raw, entry, given, reporter, warnedOnce) {
     const focused = given.find(option => option.focused);
     const started = Date.now();
-    const answer = (choices) => {
-        ctx.rest
-            .request(CreateInteractionResponse, [raw.id, raw.token], {
-            body: {
-                type: InteractionCallbackType.ApplicationCommandAutocompleteResult,
-                data: { choices },
-            },
-            auth: false,
-        })
-            .catch((error) => {
-            if (!entry || !focused)
-                return;
-            const name = `${commandName(entry.command.path)} ${focused.name}`;
-            if (error instanceof DiscordApiError &&
-                error.code === UNKNOWN_INTERACTION) {
-                // Too late, or the person typed on and Discord dropped this one.
-                if (Date.now() - started < DEADLINE)
-                    return;
-                reporter.onWarning(entry.file, `The suggestions for ${name} took ${((Date.now() - started) / 1000).toFixed(1)} s: Discord waits 3 seconds, then shows none. Make the autocomplete function faster.`);
+    const answer = (choices) => ctx.rest
+        .request(CreateInteractionResponse, [raw.id, raw.token], {
+        body: {
+            type: InteractionCallbackType.ApplicationCommandAutocompleteResult,
+            data: { choices },
+        },
+        auth: false,
+    })
+        .then(() => { }, (error) => {
+        if (!entry || !focused)
+            return;
+        const name = `${commandName(entry.command.path)} ${focused.name}`;
+        if (error instanceof DiscordApiError &&
+            error.code === UNKNOWN_INTERACTION) {
+            // Too late, or the person typed on and Discord dropped this one.
+            if (Date.now() - started < DEADLINE)
                 return;
-            }
-            reporter.onError(entry.file, error);
-        });
-    };
+            reporter.onWarning(entry.file, `The suggestions for ${name} took ${((Date.now() - started) / 1000).toFixed(1)} s: Discord waits 3 seconds, then shows none. Make the autocomplete function faster.`);
+            return;
+        }
+        reporter.onError(entry.file, error);
+    });
     // The command, the option or its function is gone: nothing to suggest.
     const fn = focused && entry?.command.autocomplete[focused.name];
     if (!entry || !focused || !fn) {
-        answer([]);
+        const sent = answer([]);
         if (entry && focused) {
             // Still registered with suggestions, but the file has no function.
             reporter.onWarning(entry.file, `Discord asked suggestions for ${commandName(entry.command.path)} ${focused.name}, which has none in "autocomplete": the command was registered with an older version of this file.`);
         }
-        return;
+        return sent;
     }
     const { command, file } = entry;
     const name = `${commandName(command.path)} ${focused.name}`;
@@ -97,24 +95,22 @@ export function suggest(ctx, raw, entry, given, reporter, warnedOnce) {
         // Suggestions are shown to the person alone: their language.
         ...translation(ctx, raw.locale ?? null),
     });
-    new Promise(resolve => resolve(fn(context)))
-        .then(suggestions => {
-        answer(toChoices(suggestions, {
-            name,
-            isText,
-            integer: option.type === 'integer',
-            warn: message => {
-                // Said once per option: it happens on every keystroke.
-                if (warnedOnce.has(`${file} ${name} ${message}`))
-                    return;
-                warnedOnce.add(`${file} ${name} ${message}`);
-                reporter.onWarning(file, `${name}: ${message}`);
-            },
-        }));
-    })
+    return new Promise(resolve => resolve(fn(context)))
+        .then(suggestions => answer(toChoices(suggestions, {
+        name,
+        isText,
+        integer: option.type === 'integer',
+        warn: message => {
+            // Said once per option: it happens on every keystroke.
+            if (warnedOnce.has(`${file} ${name} ${message}`))
+                return;
+            warnedOnce.add(`${file} ${name} ${message}`);
+            reporter.onWarning(file, `${name}: ${message}`);
+        },
+    })))
         .catch((error) => {
         reporter.onError(file, error);
-        answer([]);
+        return answer([]);
     });
 }
 /**

package/dist/commands/router.d.ts

@@ -15,6 +15,9 @@ export declare class CommandRouter {
     /**
      * Handles an Interaction Create event, if it is a slash command being
      * used, or someone typing in one of its options with suggestions.
+     * Returns a promise of everything being done (the function run, the
+     * person answered), or `null` when the interaction is not for this
+     * router. Nothing of the bot waits for it: `chapterjs test` does.
      */
-    dispatch(ctx: Context, raw: RawInteraction): void;
+    dispatch(ctx: Context, raw: RawInteraction): Promise<void> | null;
 }

package/dist/commands/router.js

@@ -42,15 +42,18 @@ export class CommandRouter {
     /**
      * Handles an Interaction Create event, if it is a slash command being
      * used, or someone typing in one of its options with suggestions.
+     * Returns a promise of everything being done (the function run, the
+     * person answered), or `null` when the interaction is not for this
+     * router. Nothing of the bot waits for it: `chapterjs test` does.
      */
     dispatch(ctx, raw) {
         const autocomplete = raw.type === InteractionType.ApplicationCommandAutocomplete;
         if (raw.type !== InteractionType.ApplicationCommand && !autocomplete) {
-            return;
+            return null;
         }
         const data = raw.data;
         if (!data || data.type !== ApplicationCommandType.ChatInput)
-            return;
+            return null;
         // `/mod roles add` comes as a command with nested options.
         const path = [data.name];
         let given = data.options ?? [];
@@ -60,13 +63,12 @@ export class CommandRouter {
         }
         const entry = this.#commands.get(path.join(' '));
         if (autocomplete) {
-            suggest(ctx, raw, entry, given, this.#options, this.#warnedOnce);
-            return;
+            return suggest(ctx, raw, entry, given, this.#options, this.#warnedOnce);
         }
         const name = commandName(path);
         const author = authorOf(raw);
         if (!author)
-            return;
+            return null;
         const { user: _user, member: _member, message: _message, ...rest } = raw;
         const user = ctx.entities.user(author.user);
         const interaction = new CommandInteraction(ctx, rest, user, {
@@ -75,14 +77,12 @@ export class CommandRouter {
         });
         if (!entry) {
             // Still registered on Discord, but its file is gone or broken.
-            refuse(interaction, 'unavailable');
-            return;
+            return refuse(interaction, 'unavailable');
         }
         const { command, file } = entry;
         const placed = resolvePlace(ctx, raw, user, author.member, command.where, message => this.#options.onWarning(file, `${name} ${message}`));
         if (!placed.place) {
-            refuse(interaction, placed.refusal, { what: 'command' });
-            return;
+            return refuse(interaction, placed.refusal, { what: 'command' });
         }
         const { place } = placed;
         // What the member can do where the command was used, overwrites
@@ -90,11 +90,10 @@ export class CommandRouter {
         if (command.permissions !== 0n && author.member) {
             const missing = new Permissions(author.member.permissions ?? '0').missing(command.permissions);
             if (missing.length > 0) {
-                refuse(interaction, 'needsPermissions', {
+                return refuse(interaction, 'needsPermissions', {
                     permissions: missing.join(', '),
                     count: missing.length,
                 });
-                return;
             }
         }
         // Used too soon: the person is told when, and nothing runs.
@@ -104,8 +103,7 @@ export class CommandRouter {
             guild: place.guild?.id,
         });
         if (again > 0) {
-            this.#refuseUntil(interaction, again);
-            return;
+            return this.#refuseUntil(interaction, again);
         }
         let options;
         try {
@@ -113,8 +111,7 @@ export class CommandRouter {
         }
         catch (error) {
             this.#options.onError(file, error);
-            refuse(interaction, 'failed', { what: 'command' });
-            return;
+            return refuse(interaction, 'failed', { what: 'command' });
         }
         remember(interaction, {
             guild: place.guild ?? undefined,
@@ -133,7 +130,7 @@ export class CommandRouter {
                 ephemeral: command.ephemeral,
             })),
         });
-        runInteraction({
+        return runInteraction({
             interaction,
             file,
             name,
@@ -159,12 +156,13 @@ export class CommandRouter {
         const when = timestamp(at, deletable ? TimestampStyle.Relative : TimestampStyle.LongDateShortTime);
         const refused = refuse(interaction, 'cooldown', { what: 'command', when });
         if (!deletable)
-            return;
+            return refused;
         const timer = setTimeout(() => {
             refused.then(() => interaction.delete()).catch(() => { });
         }, wait);
         // Nothing of the bot waits for it: the process may stop meanwhile.
         timer.unref();
+        return refused;
     }
     /** The value of each declared option, as structures where it applies. */
     #readOptions(ctx, raw, data, given, { command }) {