chapterjs 0.4.0 → 0.5.0

package/README.md

@@ -34,10 +34,12 @@ The framework loads every file of `src/`, wherever it is and whatever it is call
 
 ## What it does
 
-- **Slash commands** with typed options, choices, autocomplete, permissions, cooldowns and translations.
+- **Slash commands** with typed options, choices, autocomplete, permissions, cooldowns and translations, and **menu commands** on the right click of a message or a person.
 - **Events**: the intents follow from the files you write, privileged ones included, with a direct link when one must be enabled.
 - **Components**: buttons, select menus, forms and embeds, with typed `data` carried in the message and no id to write.
+- **Waiting for an answer**: `await channel.waitForMessage({ matches: 'paris', within: '30s' })`, a click or a reaction, right where your function asked.
 - **Tasks**: every so often or with a cron, in the timezone you choose.
+- **Presence**: one activity, or several in turn, with texts computed when shown.
 - **Storage**: `store<Warning[]>({ expires: '30d' })` keeps data from one restart to the next, per server, typed, in a JSON file written for you, or in Redis with `storage: 'redis'` and a `REDIS_URL`; `ranking()` keeps a score per member in order, for leaderboards.
 - **Translated messages**: `t('welcome', { name })` speaks the language of who will read it.
 - **Voice**: join a channel and play a file, an attachment or a link, end-to-end encrypted (DAVE).

package/dist/assets/public.js

@@ -4,7 +4,7 @@
 import { existsSync, watch } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
-import { watchFolder } from '../loader/watch.js';
+import { snapshotFolder, watchFolder } from '../loader/watch.js';
 /** The folder, at the root of the project. */
 export const PUBLIC_FOLDER = 'public';
 /**
@@ -69,9 +69,9 @@ export function watchPublic(projectDir, onChange) {
     const appeared = () => {
         if (inner)
             return;
-        // The folder was not there: what it has by the time it is watched
-        // (files copied with it, or written right after) is all new.
-        watchInside(Promise.resolve(''));
+        // The folder was not there: what it has now (files copied with it) is
+        // told at once, and what is written after it by the watch.
+        watchInside(snapshotFolder(root));
         if (!inner)
             return;
         outer?.close();

package/dist/cli/build.d.ts

@@ -1,4 +1,5 @@
 import { type BuiltFile } from '../loader/loader.js';
+import { type FoundUses } from '../loader/usage.js';
 import type { Log } from './log.js';
 /** Where the build of a project is, from its folder. */
 export declare const buildDir: (cwd: string) => string;
@@ -12,8 +13,11 @@ export interface BuildInfo {
     sources: string;
     commands: number;
     events: number;
-    /** Whether the files join voice channels (an intent to ask for). */
-    voice: boolean;
+    /**
+     * What the files do that only their code shows, with the files doing it
+     * (`CODE_USES`: intents to ask for).
+     */
+    uses: FoundUses;
 }
 /** One value for everything in a folder: it changes when a file does. */
 export declare function fingerprint(dir: string): Promise<string>;

package/dist/cli/build.js

@@ -14,9 +14,9 @@ import { join, relative, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { enableProjectLoader } from '../loader/hot.js';
 import { listSources } from '../loader/loader.js';
-import { sourcesJoinVoice } from '../voice/usage.js';
+import { scanUses } from '../loader/usage.js';
 import { MemoryStoreBackend } from '../store/memory-backend.js';
-import { createProject, hasSources, writeTypes } from './project.js';
+import { CODE_USES, createProject, hasSources, writeTypes } from './project.js';
 /** Where the build of a project is, from its folder. */
 export const buildDir = (cwd) => join(cwd, '.chapterjs', 'build');
 /** The file the whole bot is compiled into, in the build. */
@@ -206,7 +206,7 @@ export async function build(options) {
         sources: await fingerprint(src),
         commands: built.commands.size,
         events: built.events.size,
-        voice: await sourcesJoinVoice(cwd),
+        uses: await scanUses(cwd, CODE_USES),
     };
     await writeFile(join(out, 'build.json'), JSON.stringify(info, null, 2));
     if (built.isEmpty())

package/dist/cli/dev.js

@@ -2,7 +2,7 @@
 // server, and reloads every file of the project when it is saved.
 import { join } from 'node:path';
 import { registerCommands } from '../commands/register.js';
-import { buildCommands, commandName, privateOnly } from '../commands/tree.js';
+import { buildCommands, capitalize, describeCommand, privateOnly, } from '../commands/tree.js';
 import { withoutGlobalTwins } from '../commands/twins.js';
 import { configure } from '../core/memory.js';
 import { GetGlobalApplicationCommands } from '../discord/endpoints.js';
@@ -150,7 +150,7 @@ export async function dev(options) {
                 if (saidTwice.has(name))
                     continue;
                 saidTwice.add(name);
-                log.info(`/${name} is not the same here as in production, so ${guild.name} shows it twice: yours, and the one everyone has. It is shown once again when production runs your version.`);
+                log.info(`${capitalize(name)} is not the same here as in production, so ${guild.name} shows it twice: yours, and the one everyone has. It is shown once again when production runs your version.`);
             }
             try {
                 return await registerCommands({
@@ -176,6 +176,7 @@ export async function dev(options) {
         project.ready(bot);
         // Tasks follow the bot through reconnections: they read the current one.
         project.startTasks(() => bot);
+        project.startPresence(() => bot);
         // Said once per file: what only happens in private messages can't be
         // tried here. Discord only offers the commands of a server in that
         // server, and private messages are answered by the bot in production.
@@ -188,7 +189,7 @@ export async function dev(options) {
                 log.info(`${file} ${what} only works in private messages, and chapterjs dev only runs your bot in ${guild.name}. Try it with chapterjs start.`);
             };
             for (const entry of privateOnly([...project.commands.values()])) {
-                note(siteName(entry), commandName(entry.command.path));
+                note(siteName(entry), describeCommand(entry.command));
             }
             for (const entry of project.events.values()) {
                 const { event } = entry;
@@ -251,7 +252,7 @@ export async function dev(options) {
                     bot = await connect();
                     log.success(`Reconnected, ${project.summary()}`);
                     if (await syncCommands())
-                        log.reload('Commands updated on Discord');
+                        log.reload(`Commands updated on ${guild.name}`);
                     return;
                 }
                 const ms = Math.max(1, Math.round(performance.now() - started));
@@ -262,7 +263,7 @@ export async function dev(options) {
                     log.warn(`Reloaded with ${failures.length === 1 ? 'an error' : `${failures.length} errors`}: ${failures.length === 1 ? 'that file keeps' : 'those files keep'} running ${failures.length === 1 ? 'its' : 'their'} last working version`);
                 }
                 if (updated)
-                    log.reload('Commands updated on Discord');
+                    log.reload(`Commands updated on ${guild.name}`);
             })
                 .catch(error => {
                 if (!signal.aborted)
@@ -277,6 +278,7 @@ export async function dev(options) {
         const code = await ended;
         await reloading.catch(() => { });
         project.stopTasks();
+        project.stopPresence();
         watcher.close();
         assets.close();
         memory.stop();
@@ -289,6 +291,7 @@ export async function dev(options) {
     }
     catch (error) {
         project.stopTasks();
+        project.stopPresence();
         watcher?.close();
         assets.close();
         memory.stop();

package/dist/cli/project.d.ts

@@ -1,3 +1,5 @@
+import { type WaitWatcher } from '../waiting/waiters.js';
+import { type FoundUses } from '../loader/usage.js';
 import { type CommandEntry } from '../commands/tree.js';
 import { type ComponentEntry } from '../components/router.js';
 import { type LoadedStore } from '../store/declaration.js';
@@ -27,10 +29,11 @@ export interface ProjectOptions {
      */
     built?: readonly BuiltFile[];
     /**
-     * Whether the files join voice channels, as `chapterjs build` found.
+     * What the files do that only their code shows (`CODE_USES`: joining
+     * voice, waiting for messages or reactions), as `chapterjs build` found.
      * Without it, the files of `src` are read on every load.
      */
-    joinsVoice?: boolean;
+    uses?: FoundUses;
     /**
      * Where the stores of the project keep their data, by storage. `file`: a
      * file per store in the `data/` folder of the project by default, the
@@ -53,6 +56,11 @@ export interface ProjectObserver {
     interaction?(raw: RawInteraction, done: Promise<void>): void;
     /** A gateway event was given to the files; `done` once they handled it. */
     event?(event: GatewayDispatchEventName, data: unknown, done: Promise<void>): void;
+    /**
+     * Told when a run of the files starts and stops waiting for what comes
+     * next (`waitForMessage()`...): its `done` waits for the test to act.
+     */
+    waits?: WaitWatcher;
 }
 /** What the types of a project are written from, once its files ran. */
 export interface TypesInfo {
@@ -106,6 +114,8 @@ export interface ConnectOptions {
     globalLimit?: number | undefined;
     /** Only tests change this. */
     identifyInterval?: number | undefined;
+    /** Where nothing can play (`chapterjs test`): what `join()` says at once. */
+    voiceUnavailable?: string | undefined;
     /** Discord refused the bot for good. */
     onFatal: (bot: Bot) => void;
 }
@@ -162,6 +172,20 @@ export interface Project {
      * change since the bot was given one.
      */
     applyPresence(bot: Bot): boolean;
+    /**
+     * Shows the activities of the presence in turn on the bot `current`
+     * returns, and runs its functions when their time comes.
+     */
+    startPresence(current: () => Bot | null): void;
+    /** Stops the presence: nothing of it runs after this. */
+    stopPresence(): void;
+    /** The file of the presence, or `null` without one. */
+    readonly presenceFile: string | null;
+    /**
+     * Runs every function of the presence once (the list, then each text),
+     * as the rotation would, with the bot given. What goes wrong is reported.
+     */
+    runPresence(bot: Bot): Promise<void>;
     /**
      * Starts the tasks of the project, with the bot `current` returns (none
      * while it reconnects). Only one process of a bot runs them.
@@ -181,6 +205,11 @@ export interface Project {
     /** Writes what the stores still have to write. Nothing is kept after this. */
     closeStores(): Promise<void>;
 }
+/**
+ * What the files may do that only their code shows, each with the intents
+ * it needs: read in `src/` (dev, at every load) or kept by the build.
+ */
+export declare const CODE_USES: readonly [import("../loader/usage.js").CodeUse, import("../loader/usage.js").CodeUse, import("../loader/usage.js").CodeUse];
 /**
  * A promise of the files that nobody waited for (`store.set()` without
  * `await`, in a `run` that is not `async`) rejects with nobody to tell:

package/dist/cli/project.js

@@ -7,7 +7,10 @@ import { join } from 'node:path';
 import { setPublicDir } from '../assets/asset.js';
 import { listPublic, publicDeclarations } from '../assets/public.js';
 import { MissingForEvent } from '../events/registry.js';
-import { sourcesJoinVoice } from '../voice/usage.js';
+import { VOICE_USE } from '../voice/usage.js';
+import { MESSAGES_USE, REACTIONS_USE } from '../waiting/usage.js';
+import { MemoryWaiters } from '../waiting/waiters.js';
+import { scanUses, usesIntents } from '../loader/usage.js';
 import { writeGenerated } from '../loader/generated.js';
 import { commandDeclaration, scanCommands } from '../commands/declaration.js';
 import { CommandRouter } from '../commands/router.js';
@@ -19,7 +22,9 @@ import { storeDeclaration } from '../store/declaration.js';
 import { rankingDeclaration, } from '../ranking/declaration.js';
 import { nowhereToKeep, NowhereToKeepError, setStoreBackend, STORAGES, } from '../store/backend.js';
 import { DATA_FOLDER, FileStoreBackend } from '../store/file-backend.js';
-import { DEFAULT_PRESENCE, presenceDeclaration, } from '../presence/declaration.js';
+import { checkText, DEFAULT_PRESENCE, presenceDeclaration, readActivities, } from '../presence/declaration.js';
+import { PresenceRotation } from '../presence/rotation.js';
+import { GetCurrentApplication } from '../discord/endpoints.js';
 import { assembleMessages, commandsDeclarations, languageDeclaration, languageDefaultsDeclaration, messagesDeclarations, scanLanguages, } from '../messages/declaration.js';
 import { translation } from '../messages/translate.js';
 import { translateCommand, unknownCommands } from '../messages/commands.js';
@@ -30,7 +35,7 @@ import { GatewayIntent } from '../discord/intents.js';
 import { eventDeclaration } from '../events/declaration.js';
 import { EventRouter, intentsFor, intentsOf, limitsFor, } from '../events/router.js';
 import { GatewayFatalError, SessionLimitError } from '../gateway/errors.js';
-import { loadSources, readDeclarations, siteName, } from '../loader/loader.js';
+import { loadSources, bySite, readDeclarations, siteKey, siteName, } from '../loader/loader.js';
 import { locate, messageOf } from '../loader/locate.js';
 import { DiscordApiError, DiscordUnavailableError, InvalidTokenError, } from '../rest/errors.js';
 import { PreflightFailure } from './preflight.js';
@@ -73,6 +78,11 @@ export const DECLARATIONS = [
     presenceDeclaration,
     languageDeclaration,
 ];
+/**
+ * What the files may do that only their code shows, each with the intents
+ * it needs: read in `src/` (dev, at every load) or kept by the build.
+ */
+export const CODE_USES = [VOICE_USE, MESSAGES_USE, REACTIONS_USE];
 /**
  * A promise of the files that nobody waited for (`store.set()` without
  * `await`, in a `run` that is not `async`) rejects with nobody to tell:
@@ -107,23 +117,15 @@ const PRIVATE_INTENTS = GatewayIntent.DirectMessages |
     GatewayIntent.DirectMessagePolls;
 const megabytes = (bytes) => `${Math.round(bytes / 1024 / 1024)} MB`;
 /** What tells one declaration from another: its file and its export. */
-const keyOf = (site) => `${site.file}#${site.export}`;
+const keyOf = siteKey;
 /**
  * Two declarations with the same name, where the name is the export's
  * (a task): the later one is left out, with a message saying so.
  */
-function sameNames(entries, nameOf, what) {
+function sameNames(entries, nameOf, what, running) {
     const seen = new Map();
     const conflicts = [];
-    const valid = [...entries]
-        .sort((a, b) => a.file === b.file
-        ? a.export < b.export
-            ? -1
-            : 1
-        : a.file < b.file
-            ? -1
-            : 1)
-        .filter(entry => {
+    const valid = bySite(entries, running).filter(entry => {
         const first = seen.get(nameOf(entry));
         if (!first) {
             seen.set(nameOf(entry), entry);
@@ -183,19 +185,78 @@ export function createProject(options) {
     let stores = new Map();
     let rankings = new Map();
     let presence = null;
+    /** Where the presence is declared, for what its functions do wrong. */
+    let presenceSite = { file: 'the presence', export: 'default' };
     /** The files the presence was declared in, to keep it when they break. */
     let presenceFiles = new Set();
-    // Joining voice needs the bot's own voice state, sent with an intent.
-    let voice = options.joinsVoice ?? false;
-    const neededIntents = () => intentsFor(events.values()) | (voice ? GatewayIntent.GuildVoiceStates : 0);
+    // Joining voice, waiting for messages or reactions: intents the code
+    // needs without any declaration saying it.
+    let uses = options.uses ?? {};
+    const neededIntents = () => intentsFor(events.values()) | usesIntents(CODE_USES, uses);
     let messages = null;
     /** The last version of each language that loaded. */
     let languages = new Map();
     let languageDefaults = [];
+    /** Whether the files were loaded before: what a reload compares with. */
+    let loadedOnce = false;
     /** The bot running the files now, to give it what a reload changes. */
     let running = null;
     /** The presence each bot was given last, to send only what changed. */
     const given = new WeakMap();
+    /** What each bot shows now, to send only what changed. */
+    const shown = new WeakMap();
+    /** Whether the running bot is only part of the bot (a cluster). */
+    let partial = false;
+    /** How many servers the whole bot is in, as Discord counted it last. */
+    let counted = null;
+    let counting = false;
+    /**
+     * How many servers the bot is in: what this process knows when it runs
+     * every shard; else what Discord counts for the application, asked at
+     * most every 10 minutes.
+     * @see https://docs.discord.com/developers/resources/application#application-object-application-structure
+     */
+    const guildCount = (bot) => {
+        const local = bot.ctx.cache.guilds.size;
+        if (!partial)
+            return local;
+        if (!counting && (!counted || Date.now() - counted.at > 600_000)) {
+            counting = true;
+            bot.ctx.rest
+                .request(GetCurrentApplication, [])
+                .then(application => {
+                const guilds = application.approximate_guild_count;
+                if (guilds !== undefined)
+                    counted = { guilds, at: Date.now() };
+            })
+                .catch(() => { })
+                .finally(() => (counting = false));
+        }
+        return counted?.guilds ?? local;
+    };
+    let presenceBot = () => null;
+    const rotation = new PresenceRotation({
+        apply(raw) {
+            const bot = presenceBot();
+            if (!bot)
+                return;
+            const text = JSON.stringify(raw);
+            if (shown.get(bot) === text)
+                return;
+            shown.set(bot, text);
+            bot.setPresence(raw);
+        },
+        context() {
+            const bot = presenceBot();
+            if (!bot?.ctx.self)
+                return null;
+            return {
+                guilds: guildCount(bot),
+                ...translation(bot.ctx, null),
+            };
+        },
+        onError: error => report({ ...presenceSite, error }),
+    });
     let lost = false;
     const count = (size, one, many) => `${size} ${size === 1 ? one : many}`;
     return {
@@ -243,7 +304,10 @@ export function createProject(options) {
             })),
             ...(messages ? { defaultLocale: messages.default } : {}),
             languageDefaults,
-            commands: [...commands.values()].map(({ command }) => ({
+            // Only slash commands have texts in the language files.
+            commands: [...commands.values()]
+                .filter(({ command }) => command.type === 'slash')
+                .map(({ command }) => ({
                 name: command.path.join(' '),
                 described: command.described,
             })),
@@ -251,8 +315,8 @@ export function createProject(options) {
         report,
         async load() {
             const { built } = options;
-            if (options.joinsVoice === undefined) {
-                voice = await sourcesJoinVoice(cwd);
+            if (options.uses === undefined) {
+                uses = await scanUses(cwd, CODE_USES);
             }
             // Every file of src/ runs (or ran, in a build); what each exports is
             // then read, kind by kind.
@@ -292,13 +356,14 @@ export function createProject(options) {
                 event: item.value,
             }));
             router.set(events.values());
+            // A name two declarations share stays with the one that ran before.
             const { valid, conflicts } = findConflicts([
                 ...next(commands, commandItems, item => ({
                     file: item.file,
                     export: item.export,
                     command: item.value,
                 })).values(),
-            ]);
+            ], new Set(commands.keys()));
             commands = new Map(valid.map(entry => [keyOf(entry), entry]));
             const unique = findDuplicates([
                 ...next(components, componentItems, item => ({
@@ -306,7 +371,7 @@ export function createProject(options) {
                     export: item.export,
                     component: item.value,
                 })).values(),
-            ]);
+            ], new Set(components.keys()));
             components = new Map(unique.valid.map(entry => [keyOf(entry), entry]));
             componentRouter.set(components.values());
             const sameTask = sameNames([
@@ -315,7 +380,7 @@ export function createProject(options) {
                     export: item.export,
                     task: item.value,
                 })).values(),
-            ], entry => entry.task.name, 'task');
+            ], entry => entry.task.name, 'task', new Set(tasks.keys()));
             tasks = new Map(sameTask.valid.map(entry => [keyOf(entry), entry]));
             scheduler.set(tasks.values());
             const keptOf = (entry) => 'store' in entry ? entry.store : entry.ranking;
@@ -330,7 +395,7 @@ export function createProject(options) {
                     export: item.export,
                     ranking: item.value,
                 })).values(),
-            ], entry => keptOf(entry).name, entry => ('store' in entry ? 'store' : 'ranking'));
+            ], entry => keptOf(entry).name, entry => ('store' in entry ? 'store' : 'ranking'), new Set([...stores.keys(), ...rankings.keys()]));
             // What is kept where nothing keeps it (Redis without REDIS_URL) is
             // reported and left out: it says so itself when used.
             const unkept = sameStore.valid.filter(entry => !storeBackends.has(keptOf(entry).storage));
@@ -348,8 +413,10 @@ export function createProject(options) {
             }));
             // One presence. A second one is left out.
             const [first, ...extra] = presenceItems.loaded;
-            if (first)
+            if (first) {
                 presence = first.value;
+                presenceSite = { file: first.file, export: first.export };
+            }
             else if (presenceItems.failed.length === 0 &&
                 ![...broken].some(file => presenceFiles.has(file))) {
                 presence = null;
@@ -376,14 +443,20 @@ export function createProject(options) {
             languages = nextLanguages;
             let assembled = assembleMessages([...languages.values()]);
             // A language that no longer matches the others keeps its last version
-            // that did, like a declaration that no longer loads.
+            // that did, like a declaration that no longer loads; one that was not
+            // there before is left out. What already ran is never what breaks
+            // the languages: a second default: true saved in a new file must not
+            // take the texts of every command away.
             const restored = assembled.failed.filter(failure => {
                 const key = keyOf({
                     file: failure.file,
                     export: failure.export ?? 'default',
                 });
+                const current = languages.get(key);
+                if (current === undefined)
+                    return false;
                 const previous = previousLanguages.get(key);
-                return previous !== undefined && previous !== languages.get(key);
+                return previous === undefined ? loadedOnce : previous !== current;
             });
             if (restored.length > 0) {
                 for (const failure of restored) {
@@ -391,7 +464,11 @@ export function createProject(options) {
                         file: failure.file,
                         export: failure.export ?? 'default',
                     });
-                    languages.set(key, previousLanguages.get(key));
+                    const previous = previousLanguages.get(key);
+                    if (previous)
+                        languages.set(key, previous);
+                    else
+                        languages.delete(key);
                 }
                 const again = assembleMessages([...languages.values()]);
                 assembled = {
@@ -403,6 +480,7 @@ export function createProject(options) {
                 };
             }
             messages = assembled.messages;
+            loadedOnce = true;
             if (running)
                 running.ctx.messages = messages;
             // A command has its texts in its file, or in the language files: the
@@ -410,7 +488,9 @@ export function createProject(options) {
             // be described is left out.
             const badTexts = [...assembled.failed];
             if (messages) {
-                const names = new Set([...commands.values()].map(entry => entry.command.path.join(' ')));
+                const names = new Set([...commands.values()]
+                    .filter(entry => entry.command.type === 'slash')
+                    .map(entry => entry.command.path.join(' ')));
                 for (const { file, path } of unknownCommands(messages, names)) {
                     badTexts.push({
                         file,
@@ -492,9 +572,12 @@ export function createProject(options) {
             messages === null,
         // A file declaring several events that need the intent is named once.
         filesNeeding: intent => [
-            ...new Set([...events.values()]
-                .filter(({ event }) => (intentsOf(event) & GatewayIntent[intent]) !== 0)
-                .map(({ file }) => file)),
+            ...new Set([
+                ...[...events.values()]
+                    .filter(({ event }) => (intentsOf(event) & GatewayIntent[intent]) !== 0)
+                    .map(({ file }) => file),
+                ...CODE_USES.filter(use => (use.intents & GatewayIntent[intent]) !== 0).flatMap(use => uses[use.name] ?? []),
+            ]),
         ],
         intents: (privateEvents = true) => neededIntents() & (privateEvents ? ~0 : ~PRIVATE_INTENTS),
         async connect(connection) {
@@ -506,6 +589,7 @@ export function createProject(options) {
                 guildFilter: connection.guildFilter,
                 privateEvents: connection.privateEvents,
                 presence: presence?.raw,
+                waiters: new MemoryWaiters(options.observe?.waits ? { watch: options.observe.waits } : {}),
                 shards: connection.shards,
                 identifyGate: connection.identifyGate,
                 ...(connection.identifyInterval === undefined
@@ -514,7 +598,12 @@ export function createProject(options) {
                 // Only what the files of the project use is remembered.
                 cache: { limits: limitsFor(events.values()) },
                 // A local fake of Discord (tests) serves voice without TLS too.
-                voice: { secure: !connection.apiUrl?.startsWith('http://') },
+                voice: {
+                    secure: !connection.apiUrl?.startsWith('http://'),
+                    ...(connection.voiceUnavailable === undefined
+                        ? {}
+                        : { unavailable: connection.voiceUnavailable }),
+                },
                 rest: {
                     ...(connection.apiUrl ? { baseUrl: connection.apiUrl } : {}),
                     ...(connection.globalLimit === undefined
@@ -558,19 +647,62 @@ export function createProject(options) {
                 },
             });
             given.set(created, presence?.key ?? '');
+            shown.set(created, JSON.stringify(presence?.raw ?? DEFAULT_PRESENCE));
+            partial =
+                connection.shards !== undefined &&
+                    connection.shards.ids.length < connection.shards.count;
             created.ctx.messages = messages;
             running = created;
             await created.connect();
             return created;
         },
         applyPresence(bot) {
+            // Always the functions of the files as they are now: a file they
+            // import may have changed. What is shown is only sent when it differs.
+            rotation.set(presence);
             const key = presence?.key ?? '';
             if (given.get(bot) === key)
                 return false;
             given.set(bot, key);
-            bot.setPresence(presence?.raw ?? DEFAULT_PRESENCE);
             return true;
         },
+        startPresence(current) {
+            presenceBot = current;
+            rotation.set(presence);
+            rotation.start();
+        },
+        stopPresence: () => rotation.stop(),
+        get presenceFile() {
+            return presence ? presenceSite.file : null;
+        },
+        async runPresence(bot) {
+            if (!presence)
+                return;
+            const context = {
+                guilds: guildCount(bot),
+                ...translation(bot.ctx, null),
+            };
+            const failed = (error) => report({ ...presenceSite, error });
+            let activities = presence.activities;
+            if (typeof activities === 'function') {
+                try {
+                    activities = readActivities(await activities(context));
+                }
+                catch (error) {
+                    return failed(error);
+                }
+            }
+            for (const { name } of activities) {
+                if (typeof name !== 'function')
+                    continue;
+                try {
+                    checkText(await name(context));
+                }
+                catch (error) {
+                    failed(error);
+                }
+            }
+        },
         ready(bot) {
             const user = bot.ctx.cache.users.get(bot.ctx.self.userId);
             router.emit('ready', {

package/dist/cli/redis.js

@@ -10,11 +10,19 @@ import { RedisStoreBackend } from '../store/redis-backend.js';
  */
 export function redisStores(address, log, options = {}) {
     const client = new RedisClient(address, {
-        onError: message => log.warn(message),
+        // While checkRedis() asks, a failure is what stops the bot, said once
+        // by it: "trying again" would not be true.
+        onError: message => {
+            if (!checking.has(backend))
+                log.warn(message);
+        },
         onReconnect: () => log.reload(`Redis at ${client.where} is back`),
     });
-    return new RedisStoreBackend(client, options);
+    const backend = new RedisStoreBackend(client, options);
+    return backend;
 }
+/** The backends `checkRedis()` is asking right now. */
+const checking = new WeakSet();
 /** `a`, `a and b`, `a, b and c`. */
 const and = (items) => items.length <= 1
     ? (items[0] ?? '')
@@ -46,6 +54,7 @@ export async function checkRedis(project, backend, log) {
     const { stores, rankings } = project.redisStores();
     if (!backend || stores.length + rankings.length === 0)
         return true;
+    checking.add(backend);
     try {
         await backend.client.ping();
         return true;
@@ -54,4 +63,7 @@ export async function checkRedis(project, backend, log) {
         log.error(`${error instanceof Error ? error.message.replace(/ Trying again in \d+ s\.$/, '') : String(error)}`);
         return false;
     }
+    finally {
+        checking.delete(backend);
+    }
 }