chapterjs 0.1.2 → 0.1.4

package/dist/events/registry.js

@@ -0,0 +1,839 @@
+// Every event user code can listen to. An event is one entry here: its
+// name, the gateway events it comes from, the intents that make Discord
+// send them, and how to build what the handler receives. Adding an event is
+// adding an entry; the router and the loader never change.
+import { InviteType } from '../discord/types/invite.js';
+import { dataOf } from '../structures/base.js';
+import { storesOf } from '../structures/guild.js';
+import { toCamelCase } from '../util/case.js';
+import { GetChannel, GetUser } from '../discord/endpoints.js';
+import { GatewayIntent } from '../discord/intents.js';
+const I = GatewayIntent;
+const findGuild = (ctx, id) => ctx.cache.guilds.get(id) ?? null;
+/** The server of a context that has it. */
+const ofGuild = ({ guild }) => guild;
+const channel = (on) => ({
+    on,
+    build: (ctx, data) => {
+        const found = ctx.cache.channels.get(data.id);
+        return found ? { channel: found } : null;
+    },
+});
+const deletedChannel = (on) => ({
+    on,
+    before: (ctx, data) => ctx.cache.channels.get(data.id) ?? null,
+    build: (_ctx, _data, { before }) => before ? { channel: before } : null,
+});
+/**
+ * Discord refused what an event needs before it can be given to its files:
+ * the channel it happened in, or the user who did it.
+ */
+export class MissingForEvent extends Error {
+    what;
+    cause;
+    constructor(what, cause) {
+        super(`Discord refused the ${what} of an event.`);
+        this.what = what;
+        this.cause = cause;
+    }
+}
+/** What is being asked to Discord, for each bot, by `channel:id` or `user:id`. */
+const asking = new WeakMap();
+/** Asks Discord once for something several events may wait for. */
+function askOnce(ctx, key, ask) {
+    let pending = asking.get(ctx);
+    if (!pending)
+        asking.set(ctx, (pending = new Map()));
+    const running = pending.get(key);
+    if (running)
+        return running;
+    const answer = ask().finally(() => pending.delete(key));
+    pending.set(key, answer);
+    return answer;
+}
+/**
+ * The channel of what happened in a server, asked to Discord when the bot
+ * does not know it (a thread it never saw, for example): one request, then
+ * it is remembered.
+ *
+ * Everything that happens in that channel meanwhile waits for the same
+ * answer, so it costs one request and is delivered in the order it
+ * happened: a message is never deleted before it was sent.
+ */
+const channelOf = (ctx, data) => {
+    const guildId = data.guild_id;
+    const id = data.channel_id;
+    if (!guildId || ctx.cache.channels.has(id))
+        return undefined;
+    return askOnce(ctx, `channel:${id}`, () => ctx.rest
+        .request(GetChannel, [id])
+        .then(raw => ctx.entities.channel(raw, guildId))
+        .catch((error) => {
+        throw new MissingForEvent('channel', error);
+    }));
+};
+/** A user the bot does not know, asked to Discord once, then remembered. */
+const fetchUser = (ctx, id) => askOnce(ctx, `user:${id}`, () => ctx.rest
+    .request(GetUser, [id])
+    .then(raw => ctx.entities.user(raw))
+    .catch((error) => {
+    throw new MissingForEvent('user', error);
+}));
+/**
+ * The channel of what happened, and who did it when Discord only gives
+ * their id and the bot does not know them: one request, then remembered.
+ * Resolves to the user, which `build` receives as `prepared`, so it is
+ * there even when the bot can remember no user right now.
+ */
+const placeAndUser = (ctx, data, userId) => {
+    const channel = channelOf(ctx, data);
+    const known = userId ? ctx.cache.users.get(userId) : undefined;
+    const user = userId && !known ? fetchUser(ctx, userId) : undefined;
+    if (!channel && !user)
+        return undefined;
+    return Promise.all([channel, user]).then(([, fetched]) => fetched ?? known);
+};
+/** Who did it: what `prepare` got, or else what the bot knows. */
+const userFrom = (ctx, prepared, id) => prepared ?? ctx.cache.users.get(id) ?? null;
+/** Where something happened in a server or in private, as the bot knows it. */
+const placeOf = (ctx, data) => {
+    const found = ctx.cache.channels.get(data.channel_id);
+    const guildId = data.guild_id ?? found?.guildId ?? null;
+    return {
+        channelId: data.channel_id,
+        channel: found?.isTextBased() ? found : null,
+        guildId,
+        guild: guildId ? (ctx.cache.guilds.get(guildId) ?? null) : null,
+    };
+};
+/** A message the bot remembers. */
+const rememberedMessage = (channel, id) => channel?.messages.get(id) ?? null;
+/** A member the bot remembers. */
+const rememberedMember = (guild, userId) => guild?.members.get(userId) ?? null;
+/**
+ * Whether a file wants something that happened in a server or in private:
+ * it listens there, and in a server what it is promised is there.
+ */
+const wantedPlace = (context, where, needsMember = false) => {
+    const inGuild = context.guildId !== null;
+    if (!listensThere(where, inGuild))
+        return false;
+    if (!inGuild)
+        return true;
+    return (context.guild !== null &&
+        context.channel !== null &&
+        (!needsMember || context.member != null));
+};
+/**
+ * Private messages, bots and webhooks only reach the files that asked for
+ * them. This is also what makes the types true: in a server, the server
+ * and the channel are there, and without `bots` so is the member who wrote.
+ */
+/** Whether a file listens where something happened. */
+const listensThere = (where, inGuild) => (inGuild ? where !== 'dm' : where === 'dm' || where === 'both');
+/** The intents of messages, for where a file listens. */
+const messagesIn = (where) => (where === 'dm' ? 0 : I.GuildMessages) |
+    (where === 'dm' || where === 'both' ? I.DirectMessages : 0);
+const PLACES = ['guild', 'dm', 'both'];
+const wantedMessage = ({ message }, options) => {
+    const inGuild = message.guildId !== null;
+    if (!listensThere(options.where, inGuild))
+        return false;
+    // In a server, the server and the channel are promised.
+    if (inGuild && (message.guild === null || message.channel === null)) {
+        return false;
+    }
+    if (options.bots === true)
+        return true;
+    if (message.author.bot || message.webhookId !== null)
+        return false;
+    return !inGuild || message.member !== null;
+};
+const message = (on) => ({
+    on,
+    prepare: channelOf,
+    build: (ctx, data) => ({
+        message: ctx.entities.message(data, data.guild_id),
+    }),
+});
+const member = (on) => ({
+    on,
+    build: (ctx, data) => {
+        const guild = findGuild(ctx, data.guild_id);
+        if (!guild)
+            return null;
+        const { guild_id: guildId, ...raw } = data;
+        // The member comes with the event: it is there whatever the bot
+        // remembers of the members of the server.
+        const member = guild.members.get(data.user.id) ??
+            ctx.entities.member(guildId, raw);
+        return { member, guild };
+    },
+});
+const role = (on) => ({
+    on,
+    build: (ctx, data) => {
+        const guild = findGuild(ctx, data.guild_id);
+        const found = guild?.roles.get(data.role.id);
+        return guild && found ? { role: found, guild } : null;
+    },
+});
+const ban = (on) => ({
+    on,
+    build: (ctx, data) => {
+        const guild = findGuild(ctx, data.guild_id);
+        return guild ? { user: ctx.entities.user(data.user), guild } : null;
+    },
+});
+/**
+ * The emojis of a server that changed, from the list Discord sends: the
+ * emojis before (read by `before`) and after are compared one by one.
+ */
+const emojis = (pick) => ({
+    on: 'GUILD_EMOJIS_UPDATE',
+    before: (ctx, data) => new Map(findGuild(ctx, data.guild_id)?.emojis ?? []),
+    build: (ctx, data, { before }) => {
+        const guild = findGuild(ctx, data.guild_id);
+        if (!guild)
+            return null;
+        const old = before;
+        const ids = new Set([...old.keys(), ...guild.emojis.keys()]);
+        const changed = [];
+        for (const id of ids) {
+            const emoji = pick(guild.emojis.get(id), old.get(id));
+            if (emoji)
+                changed.push({ emoji, guild });
+        }
+        return changed;
+    },
+});
+/** The server and the channel of an invite; `null` outside servers. */
+const inviteChannel = (ctx, data) => {
+    const guild = data.guild_id ? findGuild(ctx, data.guild_id) : null;
+    const channel = guild?.channels.get(data.channel_id);
+    // An invite leads to a channel, never to a thread.
+    if (!guild || !channel || channel.isThread())
+        return null;
+    return { guild, channel };
+};
+/** The intents of reactions, for where a file listens. */
+const reactionsIn = (where) => (where === 'dm' ? 0 : I.GuildMessageReactions) |
+    (where === 'dm' || where === 'both' ? I.DirectMessageReactions : 0);
+/** The intents of polls, for where a file listens. */
+const pollsIn = (where) => (where === 'dm' ? 0 : I.GuildMessagePolls) |
+    (where === 'dm' || where === 'both' ? I.DirectMessagePolls : 0);
+const cleared = (on) => ({
+    on,
+    prepare: channelOf,
+    build: (ctx, data) => {
+        const place = placeOf(ctx, data);
+        return {
+            emoji: 'emoji' in data ? toCamelCase(data.emoji) : null,
+            messageId: data.message_id,
+            message: rememberedMessage(place.channel, data.message_id),
+            ...place,
+        };
+    },
+});
+const vote = (on) => ({
+    on,
+    prepare: (ctx, data) => placeAndUser(ctx, data, data.user_id),
+    build: (ctx, data, { prepared }) => {
+        const place = placeOf(ctx, data);
+        const user = userFrom(ctx, prepared, data.user_id);
+        if (!user)
+            return null;
+        return {
+            answerId: data.answer_id,
+            user,
+            member: rememberedMember(place.guild, data.user_id),
+            messageId: data.message_id,
+            message: rememberedMessage(place.channel, data.message_id),
+            ...place,
+        };
+    },
+});
+/** A thread and its server; `null` when the bot does not know it. */
+const threadOf = (ctx, data) => {
+    const guild = findGuild(ctx, data.guild_id);
+    const thread = ctx.cache.channels.get(data.id);
+    return guild && thread?.isThread() ? { thread, guild } : null;
+};
+/** A voice state as handlers read it. */
+const stateOf = (entry) => toCamelCase(entry.state);
+/**
+ * The voice events, from what someone's voice state was (read by `before`)
+ * and is now: each event picks the change it is about.
+ */
+const voice = (pick) => ({
+    on: 'VOICE_STATE_UPDATE',
+    before: (ctx, data) => {
+        const guild = data.guild_id ? findGuild(ctx, data.guild_id) : null;
+        return guild ? storesOf(guild).voiceStates.get(data.user_id) : undefined;
+    },
+    build: (ctx, data, { before }) => {
+        const guild = data.guild_id ? findGuild(ctx, data.guild_id) : null;
+        if (!guild)
+            return null;
+        const now = storesOf(guild).voiceStates.get(data.user_id);
+        const picked = pick(before, now);
+        // In a server, the member comes with the event.
+        const member = data.member
+            ? ctx.entities.member(guild.id, data.member)
+            : guild.members.get(data.user_id);
+        if (!picked || !member)
+            return null;
+        return { ...picked, member, guild };
+    },
+});
+const scheduled = (on) => ({
+    on,
+    build: (ctx, data) => {
+        const guild = findGuild(ctx, data.guild_id);
+        if (!guild)
+            return null;
+        if (data.creator)
+            ctx.entities.user(data.creator);
+        return { scheduledEvent: toCamelCase(data), guild };
+    },
+});
+const interested = (on) => ({
+    on,
+    prepare: (ctx, data) => ctx.cache.users.has(data.user_id)
+        ? undefined
+        : fetchUser(ctx, data.user_id),
+    build: (ctx, data, { prepared }) => {
+        const guild = findGuild(ctx, data.guild_id);
+        const user = userFrom(ctx, prepared, data.user_id);
+        if (!guild || !user)
+            return null;
+        return {
+            scheduledEventId: data.guild_scheduled_event_id,
+            user,
+            member: rememberedMember(guild, data.user_id),
+            guild,
+        };
+    },
+});
+/**
+ * The events, by name. `ready` has no source: it is not a gateway event but
+ * the moment the bot has finished connecting.
+ */
+export const EVENTS = {
+    ready: { intents: 0, sources: [] },
+    messageCreate: {
+        guildOf: ({ message }) => message.guild,
+        // Without Message Content, the messages of others come empty.
+        intents: ({ where }) => messagesIn(where) | I.MessageContent,
+        options: { bots: 'boolean', where: PLACES },
+        accepts: wantedMessage,
+        sources: [message('MESSAGE_CREATE')],
+    },
+    messageUpdate: {
+        guildOf: ({ message }) => message.guild,
+        intents: ({ where }) => messagesIn(where) | I.MessageContent,
+        options: { bots: 'boolean', where: PLACES },
+        accepts: wantedMessage,
+        sources: [message('MESSAGE_UPDATE')],
+    },
+    messageDelete: {
+        guildOf: ofGuild,
+        intents: ({ where }) => messagesIn(where),
+        options: { where: PLACES },
+        accepts: ({ guildId, guild, channel }, options) => listensThere(options.where, guildId !== null) &&
+            // In a server, the server and the channel are promised.
+            (guildId === null || (guild !== null && channel !== null)),
+        sources: [
+            {
+                on: 'MESSAGE_DELETE',
+                prepare: channelOf,
+                before: (ctx, data) => {
+                    const found = ctx.cache.channels.get(data.channel_id);
+                    return found?.isTextBased()
+                        ? (found.messages.get(data.id) ?? null)
+                        : null;
+                },
+                build: (ctx, data, { before }) => ({
+                    messageId: data.id,
+                    ...placeOf(ctx, data),
+                    message: before,
+                }),
+            },
+            {
+                // Messages deleted together: one occurrence each.
+                on: 'MESSAGE_DELETE_BULK',
+                prepare: channelOf,
+                before: (ctx, data) => {
+                    const found = ctx.cache.channels.get(data.channel_id);
+                    return data.ids.map(id => found?.isTextBased() ? (found.messages.get(id) ?? null) : null);
+                },
+                build: (ctx, data, { before }) => {
+                    const place = placeOf(ctx, data);
+                    const messages = before;
+                    return data.ids.map((messageId, index) => ({
+                        messageId,
+                        ...place,
+                        message: messages[index] ?? null,
+                    }));
+                },
+            },
+        ],
+    },
+    memberJoin: {
+        guildOf: ofGuild,
+        intents: I.GuildMembers,
+        sources: [member('GUILD_MEMBER_ADD')],
+    },
+    memberUpdate: {
+        guildOf: ofGuild,
+        intents: I.GuildMembers,
+        sources: [member('GUILD_MEMBER_UPDATE')],
+    },
+    memberLeave: {
+        guildOf: ofGuild,
+        intents: I.GuildMembers,
+        // "The member as it was" is a member the bot remembered.
+        remembers: { members: 1000 },
+        sources: [
+            {
+                on: 'GUILD_MEMBER_REMOVE',
+                before: (ctx, data) => findGuild(ctx, data.guild_id)?.members.get(data.user.id) ?? null,
+                build: (ctx, data, { before }) => {
+                    const guild = findGuild(ctx, data.guild_id);
+                    if (!guild)
+                        return null;
+                    return {
+                        user: ctx.entities.user(data.user),
+                        guild,
+                        member: before,
+                    };
+                },
+            },
+        ],
+    },
+    guildJoin: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [
+            {
+                on: 'GUILD_CREATE',
+                build: (ctx, data, { joined }) => {
+                    const guild = joined ? findGuild(ctx, data.id) : null;
+                    return guild ? { guild } : null;
+                },
+            },
+        ],
+    },
+    guildLeave: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [
+            {
+                on: 'GUILD_DELETE',
+                before: (ctx, data) => findGuild(ctx, data.id),
+                // With `unavailable`, an outage: the bot is still in the server.
+                build: (_ctx, data, { before }) => before && !data.unavailable ? { guild: before } : null,
+            },
+        ],
+    },
+    channelCreate: {
+        guildOf: ({ channel }) => channel.guild,
+        intents: I.Guilds,
+        sources: [channel('CHANNEL_CREATE'), channel('THREAD_CREATE')],
+    },
+    channelUpdate: {
+        guildOf: ({ channel }) => channel.guild,
+        intents: I.Guilds,
+        sources: [channel('CHANNEL_UPDATE'), channel('THREAD_UPDATE')],
+    },
+    channelDelete: {
+        guildOf: ({ channel }) => channel.guild,
+        intents: I.Guilds,
+        sources: [
+            deletedChannel('CHANNEL_DELETE'),
+            deletedChannel('THREAD_DELETE'),
+        ],
+    },
+    roleCreate: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [role('GUILD_ROLE_CREATE')],
+    },
+    roleUpdate: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [role('GUILD_ROLE_UPDATE')],
+    },
+    roleDelete: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [
+            {
+                on: 'GUILD_ROLE_DELETE',
+                before: (ctx, data) => findGuild(ctx, data.guild_id)?.roles.get(data.role_id) ?? null,
+                build: (ctx, data, { before }) => {
+                    const guild = findGuild(ctx, data.guild_id);
+                    // Every role of a server is known: one that is not never was.
+                    if (!guild || !before)
+                        return null;
+                    return { roleId: data.role_id, guild, role: before };
+                },
+            },
+        ],
+    },
+    guildUpdate: {
+        guildOf: ofGuild,
+        intents: I.Guilds,
+        sources: [
+            {
+                on: 'GUILD_UPDATE',
+                build: (ctx, data) => {
+                    const guild = findGuild(ctx, data.id);
+                    return guild ? { guild } : null;
+                },
+            },
+        ],
+    },
+    banAdd: {
+        guildOf: ofGuild,
+        intents: I.GuildModeration,
+        sources: [ban('GUILD_BAN_ADD')],
+    },
+    banRemove: {
+        guildOf: ofGuild,
+        intents: I.GuildModeration,
+        sources: [ban('GUILD_BAN_REMOVE')],
+    },
+    emojiCreate: {
+        guildOf: ofGuild,
+        intents: I.GuildExpressions,
+        sources: [emojis((now, old) => (old ? null : now))],
+    },
+    emojiUpdate: {
+        guildOf: ofGuild,
+        intents: I.GuildExpressions,
+        sources: [
+            emojis((now, old) => old &&
+                now &&
+                JSON.stringify(dataOf(old)) !== JSON.stringify(dataOf(now))
+                ? now
+                : null),
+        ],
+    },
+    emojiDelete: {
+        guildOf: ofGuild,
+        intents: I.GuildExpressions,
+        sources: [emojis((now, old) => (now ? null : old))],
+    },
+    inviteCreate: {
+        guildOf: ofGuild,
+        intents: I.GuildInvites,
+        sources: [
+            {
+                on: 'INVITE_CREATE',
+                prepare: channelOf,
+                build: (ctx, data) => {
+                    const place = inviteChannel(ctx, data);
+                    if (!place)
+                        return null;
+                    const { inviter, channel_id: channelId, guild_id: guildId, ...rest } = data;
+                    const invite = ctx.entities.invite({
+                        ...rest,
+                        type: InviteType.Guild,
+                        guild: { id: guildId },
+                        channel: { id: channelId },
+                        ...(inviter ? { inviter } : {}),
+                    });
+                    return { invite, ...place };
+                },
+            },
+        ],
+    },
+    inviteDelete: {
+        guildOf: ofGuild,
+        intents: I.GuildInvites,
+        sources: [
+            {
+                on: 'INVITE_DELETE',
+                prepare: channelOf,
+                build: (ctx, data) => {
+                    const place = inviteChannel(ctx, data);
+                    return place ? { code: data.code, ...place } : null;
+                },
+            },
+        ],
+    },
+    auditLogEntryCreate: {
+        guildOf: ofGuild,
+        intents: I.GuildModeration,
+        sources: [
+            {
+                on: 'GUILD_AUDIT_LOG_ENTRY_CREATE',
+                build: (ctx, data) => {
+                    const guild = findGuild(ctx, data.guild_id);
+                    if (!guild)
+                        return null;
+                    const { guild_id: _guildId, ...entry } = data;
+                    return { entry: toCamelCase(entry), guild };
+                },
+            },
+        ],
+    },
+    reactionAdd: {
+        guildOf: ofGuild,
+        intents: ({ where }) => reactionsIn(where),
+        options: { bots: 'boolean', where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where, true) &&
+            (options.bots === true || !context.user.bot),
+        sources: [
+            {
+                on: 'MESSAGE_REACTION_ADD',
+                // In a server, who reacted comes with the event.
+                prepare: (ctx, data) => placeAndUser(ctx, data, data.member?.user ? null : data.user_id),
+                build: (ctx, data, { prepared }) => {
+                    const place = placeOf(ctx, data);
+                    const member = data.member && data.guild_id
+                        ? ctx.entities.member(data.guild_id, data.member)
+                        : null;
+                    const user = member?.user ?? userFrom(ctx, prepared, data.user_id);
+                    if (!user)
+                        return null;
+                    return {
+                        emoji: toCamelCase(data.emoji),
+                        user,
+                        member,
+                        burst: data.burst,
+                        messageId: data.message_id,
+                        message: rememberedMessage(place.channel, data.message_id),
+                        messageAuthorId: data.message_author_id ?? null,
+                        ...place,
+                    };
+                },
+            },
+        ],
+    },
+    reactionRemove: {
+        guildOf: ofGuild,
+        intents: ({ where }) => reactionsIn(where),
+        options: { bots: 'boolean', where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where) &&
+            (options.bots === true || !context.user.bot),
+        sources: [
+            {
+                on: 'MESSAGE_REACTION_REMOVE',
+                prepare: (ctx, data) => placeAndUser(ctx, data, data.user_id),
+                build: (ctx, data, { prepared }) => {
+                    const place = placeOf(ctx, data);
+                    const user = userFrom(ctx, prepared, data.user_id);
+                    if (!user)
+                        return null;
+                    return {
+                        emoji: toCamelCase(data.emoji),
+                        user,
+                        member: rememberedMember(place.guild, data.user_id),
+                        burst: data.burst,
+                        messageId: data.message_id,
+                        message: rememberedMessage(place.channel, data.message_id),
+                        ...place,
+                    };
+                },
+            },
+        ],
+    },
+    reactionClear: {
+        guildOf: ofGuild,
+        intents: ({ where }) => reactionsIn(where),
+        options: { where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where),
+        sources: [
+            cleared('MESSAGE_REACTION_REMOVE_ALL'),
+            cleared('MESSAGE_REACTION_REMOVE_EMOJI'),
+        ],
+    },
+    pollVoteAdd: {
+        guildOf: ofGuild,
+        intents: ({ where }) => pollsIn(where),
+        options: { where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where),
+        sources: [vote('MESSAGE_POLL_VOTE_ADD')],
+    },
+    pollVoteRemove: {
+        guildOf: ofGuild,
+        intents: ({ where }) => pollsIn(where),
+        options: { where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where),
+        sources: [vote('MESSAGE_POLL_VOTE_REMOVE')],
+    },
+    typingStart: {
+        guildOf: ofGuild,
+        intents: ({ where }) => (where === 'dm' ? 0 : I.GuildMessageTyping) |
+            (where === 'dm' || where === 'both' ? I.DirectMessageTyping : 0),
+        options: { where: PLACES },
+        accepts: (context, options) => wantedPlace(context, options.where, true),
+        sources: [
+            {
+                on: 'TYPING_START',
+                prepare: (ctx, data) => placeAndUser(ctx, data, data.member?.user ? null : data.user_id),
+                build: (ctx, data, { prepared }) => {
+                    const member = data.member && data.guild_id
+                        ? ctx.entities.member(data.guild_id, data.member)
+                        : null;
+                    const user = member?.user ?? userFrom(ctx, prepared, data.user_id);
+                    if (!user)
+                        return null;
+                    return {
+                        user,
+                        member,
+                        startedAt: new Date(data.timestamp * 1000),
+                        ...placeOf(ctx, data),
+                    };
+                },
+            },
+        ],
+    },
+    threadMemberJoin: {
+        guildOf: ofGuild,
+        // Without it, Discord only says when the bot itself joins a thread.
+        intents: I.GuildMembers,
+        sources: [
+            {
+                on: 'THREAD_MEMBERS_UPDATE',
+                prepare: (ctx, data) => data.added_members?.length
+                    ? channelOf(ctx, { channel_id: data.id, guild_id: data.guild_id })
+                    : undefined,
+                build: (ctx, data) => {
+                    const place = threadOf(ctx, data);
+                    if (!place)
+                        return null;
+                    const joined = [];
+                    for (const added of data.added_members ?? []) {
+                        // Each one comes with its member in this event.
+                        if (!added.member?.user)
+                            continue;
+                        const member = ctx.entities.member(data.guild_id, added.member);
+                        joined.push({ member, user: member.user, ...place });
+                    }
+                    return joined;
+                },
+            },
+        ],
+    },
+    threadMemberLeave: {
+        guildOf: ofGuild,
+        intents: I.GuildMembers,
+        sources: [
+            {
+                on: 'THREAD_MEMBERS_UPDATE',
+                prepare: (ctx, data) => data.removed_member_ids?.length
+                    ? channelOf(ctx, { channel_id: data.id, guild_id: data.guild_id })
+                    : undefined,
+                build: (ctx, data) => {
+                    const place = threadOf(ctx, data);
+                    if (!place)
+                        return null;
+                    return (data.removed_member_ids ?? []).map(userId => ({
+                        userId,
+                        user: ctx.cache.users.get(userId) ?? null,
+                        member: rememberedMember(place.guild, userId),
+                        ...place,
+                    }));
+                },
+            },
+        ],
+    },
+    voiceJoin: {
+        guildOf: ofGuild,
+        intents: I.GuildVoiceStates,
+        sources: [
+            voice((was, now) => !was && now ? { channel: now.channel, voice: stateOf(now) } : null),
+        ],
+    },
+    voiceLeave: {
+        guildOf: ofGuild,
+        intents: I.GuildVoiceStates,
+        sources: [
+            voice((was, now) => was && !now ? { channel: was.channel, voice: stateOf(was) } : null),
+        ],
+    },
+    voiceMove: {
+        guildOf: ofGuild,
+        intents: I.GuildVoiceStates,
+        sources: [
+            voice((was, now) => was && now && was.channel.id !== now.channel.id
+                ? { from: was.channel, to: now.channel, voice: stateOf(now) }
+                : null),
+        ],
+    },
+    voiceUpdate: {
+        guildOf: ofGuild,
+        intents: I.GuildVoiceStates,
+        sources: [
+            voice((was, now) => was &&
+                now &&
+                was.channel.id === now.channel.id &&
+                JSON.stringify(was.state) !== JSON.stringify(now.state)
+                ? {
+                    channel: now.channel,
+                    voice: stateOf(now),
+                    before: stateOf(was),
+                }
+                : null),
+        ],
+    },
+    presenceUpdate: {
+        guildOf: ofGuild,
+        intents: I.GuildPresences,
+        sources: [
+            {
+                on: 'PRESENCE_UPDATE',
+                build: (ctx, data) => {
+                    const guild = findGuild(ctx, data.guild_id);
+                    if (!guild)
+                        return null;
+                    const { user: sent, guild_id: _guildId, ...presence } = data;
+                    // Discord may only send the id of the user.
+                    const raw = sent;
+                    const user = raw.username !== undefined
+                        ? ctx.entities.user(raw)
+                        : (ctx.cache.users.get(raw.id) ?? null);
+                    return {
+                        userId: raw.id,
+                        user,
+                        member: rememberedMember(guild, raw.id),
+                        presence: toCamelCase(presence),
+                        guild,
+                    };
+                },
+            },
+        ],
+    },
+    scheduledEventCreate: {
+        guildOf: ofGuild,
+        intents: I.GuildScheduledEvents,
+        sources: [scheduled('GUILD_SCHEDULED_EVENT_CREATE')],
+    },
+    scheduledEventUpdate: {
+        guildOf: ofGuild,
+        intents: I.GuildScheduledEvents,
+        sources: [scheduled('GUILD_SCHEDULED_EVENT_UPDATE')],
+    },
+    scheduledEventDelete: {
+        guildOf: ofGuild,
+        intents: I.GuildScheduledEvents,
+        sources: [scheduled('GUILD_SCHEDULED_EVENT_DELETE')],
+    },
+    scheduledEventUserAdd: {
+        guildOf: ofGuild,
+        intents: I.GuildScheduledEvents,
+        sources: [interested('GUILD_SCHEDULED_EVENT_USER_ADD')],
+    },
+    scheduledEventUserRemove: {
+        guildOf: ofGuild,
+        intents: I.GuildScheduledEvents,
+        sources: [interested('GUILD_SCHEDULED_EVENT_USER_REMOVE')],
+    },
+};
+export const EVENT_NAMES = Object.keys(EVENTS);
+export function isEventName(name) {
+    return typeof name === 'string' && Object.hasOwn(EVENTS, name);
+}