@helyx/bot 0.4.9 → 0.4.11

package/dist/index.d.ts

@@ -9,5 +9,5 @@ export interface BotHandle {
 export declare function startBot(processEnvironment?: NodeJS.ProcessEnv): Promise<BotHandle>;
 export declare function resolveBotWorkerEntryPoint(entryUrl?: string): string;
 export declare function readBotVersion(): string;
-export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[]): GatewayIntentBits[];
+export declare function gatewayIntentsForModules(modules: readonly ModuleDefinition[], messageContentEnabled?: boolean): GatewayIntentBits[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -18,7 +18,7 @@ import { loadConfiguredModulePackages, platformServiceOptions, } from "./modules
 import { resolveModulePackageSpecifiers } from "./module-configuration.js";
 import { createPermissionsModule } from "./permissions-module.js";
 import { createManagementModule } from "./management-module.js";
-import { DiscordMemberRoleService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordMessageDeliveryService, DiscordMemberEnforcementService, DiscordMemberRoleService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
 import { DiscordModuleLoggingService } from "./module-logging.js";
 import { BotControlService, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
 import { startShardSupervisor } from "./shard-supervisor.js";
@@ -29,6 +29,7 @@ import { createSupportModule } from "./support-module.js";
 import { DiscordOwnedMessageDeletionService } from "./discord-owned-message-service.js";
 import { CoreResourceAuthorizationService } from "./resource-authorization.js";
 import { createLocalScheduledTaskRoute, createScheduledTaskRunner, schedulerOperationalHealth, } from "./scheduled-task-runner.js";
+import { createLocalNumericWriteBehind } from "./numeric-write-behind.js";
 export { loadConfiguredModulePackages } from "./modules.js";
 export { resolveModulePackageSpecifiers } from "./module-configuration.js";
 export * from "./control-server.js";
@@ -125,7 +126,7 @@ async function startUnshardedBot(processEnvironment) {
         }, "Module databases ready");
         const featureModules = modulePackages.map(({ definition }) => definition);
         const client = new Client({
-            intents: gatewayIntentsForModules(featureModules),
+            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED),
             partials: [Partials.Message, Partials.Channel, Partials.Reaction],
             allowedMentions: { parse: [] },
         });
@@ -234,15 +235,25 @@ async function startUnshardedBot(processEnvironment) {
             ...publicModules,
             ...(operationsModule ? [operationsModule] : []),
         ];
-        const platformServices = new Map(createPlatformServices(database, publicModules, platformServiceOptions(environment, publicModules)));
+        const platformServices = new Map();
+        const serviceAccess = new ServiceRegistry(platformServices);
+        for (const [name, service] of createPlatformServices(database, publicModules, {
+            ...platformServiceOptions(environment, publicModules),
+            activationServices: serviceAccess,
+        })) {
+            platformServices.set(name, service);
+        }
+        const numericWriteBehind = createLocalNumericWriteBehind(platformServices, publicModules);
+        platformServices.set(HELYX_SERVICE_NAMES.numericWriteBehind, numericWriteBehind);
         platformServices.set(HELYX_SERVICE_NAMES.resourceAuthorization, new CoreResourceAuthorizationService(platformServices.get(HELYX_SERVICE_NAMES.permissions)));
+        platformServices.set(HELYX_SERVICE_NAMES.discordMessages, new DiscordMessageDeliveryService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordOwnedMessages, new DiscordOwnedMessageDeletionService(client));
+        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordMemberEnforcementService(client));
         platformServices.set(HELYX_SERVICE_NAMES.memberRoles, new DiscordMemberRoleService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordResources, new DiscordResourceInspection(client));
         if (featureModules.some(({ manifest }) => manifest.id === "helyx.logging")) {
             platformServices.set(HELYX_SERVICE_NAMES.moduleLogging, new DiscordModuleLoggingService(client, database, publicModules, bootstrapLogger));
         }
-        const serviceAccess = new ServiceRegistry(platformServices);
         const runtime = createRuntime({
             modules,
             logger: bootstrapLogger,
@@ -305,14 +316,29 @@ async function startUnshardedBot(processEnvironment) {
                     process.exitCode = 1;
                     bootstrapLogger.error({ event: "control.stop_failed", error: safeError(error) }, "Private bot control shutdown failed");
                 });
-            try {
-                await moduleEvents.stop();
-                await runtime.stop();
-            }
-            catch (error) {
+            await moduleEvents.stop().catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "module_events.stop_failed", error: safeError(error) }, "Module event shutdown failed");
+            });
+            await runtime.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "runtime.stop_failed", error: safeError(error) }, "Runtime shutdown failed");
-            }
+            });
+            await numericWriteBehind
+                .stop()
+                .then(({ drained }) => {
+                if (drained)
+                    return;
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "numeric_write_behind.shutdown_not_drained" }, "Numeric write-behind exceeded its bounded shutdown drain");
+            })
+                .catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({
+                    event: "numeric_write_behind.shutdown_failed",
+                    error: safeError(error),
+                }, "Numeric write-behind shutdown failed");
+            });
             await client.destroy();
             await closeDatabase();
         }
@@ -364,13 +390,26 @@ async function startUnshardedBot(processEnvironment) {
             await cloudConnector.stop().catch(() => undefined);
             if (controlServer)
                 await controlServer.close().catch(() => undefined);
-            try {
-                await moduleEvents.stop();
-                await runtime.stop();
-            }
-            catch (stopError) {
+            await moduleEvents.stop().catch((stopError) => {
+                bootstrapLogger.error({
+                    event: "module_events.cleanup_failed",
+                    error: safeError(stopError),
+                }, "Module event cleanup failed");
+            });
+            await runtime.stop().catch((stopError) => {
                 bootstrapLogger.error({ event: "runtime.cleanup_failed", error: safeError(stopError) }, "Runtime cleanup failed");
-            }
+            });
+            const numericCleanup = await numericWriteBehind
+                .stop()
+                .catch((stopError) => {
+                bootstrapLogger.error({
+                    event: "numeric_write_behind.cleanup_failed",
+                    error: safeError(stopError),
+                }, "Numeric write-behind cleanup failed");
+                return { drained: false };
+            });
+            if (!numericCleanup.drained)
+                bootstrapLogger.error({ event: "numeric_write_behind.cleanup_not_drained" }, "Numeric write-behind cleanup did not drain");
             await client.destroy();
             throw error;
         }
@@ -407,16 +446,27 @@ function deploymentReference(processEnvironment) {
         processEnvironment.GIT_COMMIT_SHA;
     return value?.trim().slice(0, 12) || undefined;
 }
-export function gatewayIntentsForModules(modules) {
+export function gatewayIntentsForModules(modules, messageContentEnabled = false) {
     const intents = [GatewayIntentBits.Guilds];
     if (modules.some((module) => module.events?.messageReactionAdd?.length ||
         module.events?.messageReactionRemove?.length)) {
         intents.push(GatewayIntentBits.GuildMessageReactions);
     }
-    if (modules.some((module) => module.events?.messageDelete?.length)) {
+    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.length);
+    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
+    if (((hasPrivilegedMessageCreate || requiresMessageContent) &&
+        messageContentEnabled) ||
+        modules.some((module) => module.events?.guildMessageCreate?.length ||
+            module.events?.messageDelete?.length)) {
         intents.push(GatewayIntentBits.GuildMessages);
     }
-    if (modules.some((module) => module.events?.guildMemberAdd?.length)) {
+    if ((hasPrivilegedMessageCreate || requiresMessageContent) &&
+        messageContentEnabled) {
+        intents.push(GatewayIntentBits.MessageContent);
+    }
+    if (modules.some((module) => module.requiredDiscordCapabilities?.includes("guild-members") ||
+        module.events?.guildMemberAdd?.length ||
+        module.events?.guildMemberRemove?.length)) {
         intents.push(GatewayIntentBits.GuildMembers);
     }
     if (modules.some((module) => module.events?.guildEmojiDelete?.length ||

package/dist/interactions.js

@@ -17,14 +17,18 @@ export function installInteractions(client, modules, registration, logger, servi
     if (guildCommands.length > 0 && !registration.internalGuildId) {
         throw new Error("DISCORD_INTERNAL_GUILD_ID is required when guild commands are loaded");
     }
-    const buttons = uniqueMap(modules.flatMap((module) => (module.interactions?.buttons ?? []).map((contribution) => ({
+    const buttonItems = modules.flatMap((module) => (module.interactions?.buttons ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
-    }))), ({ contribution }) => contribution.customId, "button custom ID");
-    const modals = uniqueMap(modules.flatMap((module) => (module.interactions?.modals ?? []).map((contribution) => ({
+    })));
+    const buttons = uniqueMap(buttonItems.filter(({ contribution }) => contribution.customId !== undefined), ({ contribution }) => contribution.customId, "button custom ID");
+    const buttonPrefixes = componentPrefixes(buttonItems, "button");
+    const modalItems = modules.flatMap((module) => (module.interactions?.modals ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
-    }))), ({ contribution }) => contribution.customId, "modal custom ID");
+    })));
+    const modals = uniqueMap(modalItems.filter(({ contribution }) => contribution.customId !== undefined), ({ contribution }) => contribution.customId, "modal custom ID");
+    const modalPrefixes = componentPrefixes(modalItems, "modal");
     const selects = uniqueMap(modules.flatMap((module) => (module.interactions?.selects ?? []).map((contribution) => ({
         moduleId: module.manifest.id,
         contribution,
@@ -124,7 +128,8 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
             }
             else if (interaction.isButton()) {
-                const button = buttons.get(interaction.customId);
+                const button = buttons.get(interaction.customId) ??
+                    resolveComponentPrefix(buttonPrefixes, interaction.customId);
                 const context = button
                     ? createContext(interaction, services)
                     : undefined;
@@ -132,6 +137,11 @@ export function installInteractions(client, modules, registration, logger, servi
                     button?.contribution.acknowledgement === "deferred-ephemeral") {
                     await context.deferReply?.(true);
                 }
+                if (button &&
+                    interaction.isButton() &&
+                    button.contribution.acknowledgement === "deferred-update") {
+                    await interaction.deferUpdate();
+                }
                 if (button &&
                     context &&
                     (await authorizeComponent(interaction, button.moduleId, services))) {
@@ -139,7 +149,8 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
             }
             else if (interaction.isModalSubmit()) {
-                const modal = modals.get(interaction.customId);
+                const modal = modals.get(interaction.customId) ??
+                    resolveComponentPrefix(modalPrefixes, interaction.customId);
                 if (modal &&
                     (await authorizeComponent(interaction, modal.moduleId, services))) {
                     await modal.contribution.execute(createModalContext(interaction, services));
@@ -205,6 +216,9 @@ export function toCommandDefinition(registered) {
     if (!!command.execute === !!command.subcommands?.length) {
         throw new Error(`Command ${command.name} must define either execute or subcommands`);
     }
+    if (command.options?.length && command.subcommands?.length) {
+        throw new Error(`Command ${command.name} cannot define both direct options and subcommands`);
+    }
     const contextTypes = {
         guild: InteractionContextType.Guild,
         bot_dm: InteractionContextType.BotDM,
@@ -219,6 +233,9 @@ export function toCommandDefinition(registered) {
         .setDescription(command.description)
         .setContexts(command.contexts.map((context) => contextTypes[context]))
         .setIntegrationTypes(command.integrationTypes.map((integrationType) => integrationTypes[integrationType]));
+    for (const option of command.options ?? []) {
+        addCommandOption(builder, option);
+    }
     for (const subcommand of command.subcommands ?? []) {
         builder.addSubcommand((subcommandBuilder) => {
             subcommandBuilder
@@ -260,6 +277,13 @@ function addCommandOption(builder, option) {
             .setRequired(option.required ?? false));
         return;
     }
+    if (option.type === "user") {
+        builder.addUserOption((optionBuilder) => optionBuilder
+            .setName(option.name)
+            .setDescription(option.description)
+            .setRequired(option.required ?? false));
+        return;
+    }
     if (option.type === "role") {
         builder.addRoleOption((optionBuilder) => optionBuilder
             .setName(option.name)
@@ -291,9 +315,43 @@ export function uniqueMap(items, keyOf, label) {
     }
     return result;
 }
+function componentPrefixes(items, label) {
+    const prefixes = [];
+    for (const item of items) {
+        const { customId, customIdPrefix } = item.contribution;
+        if ((customId === undefined) === (customIdPrefix === undefined)) {
+            throw new Error(`${label} contribution must declare exactly one custom ID or prefix`);
+        }
+        const route = customId ?? customIdPrefix;
+        if (route.length < 1 ||
+            route.length > 100 ||
+            !/^[A-Za-z0-9._:-]+$/u.test(route)) {
+            throw new Error(`${label} custom ID routing value is invalid`);
+        }
+        if (customIdPrefix !== undefined)
+            prefixes.push(item);
+    }
+    for (let index = 0; index < prefixes.length; index += 1) {
+        const prefix = prefixes[index].contribution.customIdPrefix;
+        if (prefixes.some((candidate, candidateIndex) => candidateIndex !== index &&
+            (candidate.contribution.customIdPrefix ?? "").startsWith(prefix))) {
+            throw new Error(`Ambiguous ${label} custom ID prefix: ${prefix}`);
+        }
+    }
+    return prefixes;
+}
+function resolveComponentPrefix(items, customId) {
+    if (customId.length < 1 ||
+        customId.length > 100 ||
+        !/^[A-Za-z0-9._:-]+$/u.test(customId)) {
+        return undefined;
+    }
+    return items.find(({ contribution }) => customId.startsWith(contribution.customIdPrefix ?? ""));
+}
 function createContext(interaction, services) {
     return {
         interactionId: interaction.id,
+        ...("customId" in interaction ? { customId: interaction.customId } : {}),
         userId: interaction.user.id,
         userDisplayName: interaction.user.globalName ?? interaction.user.username,
         userRoleIds: interaction.member instanceof GuildMember
@@ -322,6 +380,9 @@ function createContext(interaction, services) {
         ...(interaction.isMessageComponent()
             ? {
                 updateResponse: async (response) => interaction.update(toUpdateOptions(response)).then(() => undefined),
+                editSourceMessage: async (response) => interaction.webhook
+                    .editMessage(interaction.message.id, toUpdateOptions(response))
+                    .then(() => undefined),
             }
             : {}),
         showModal: async (modal) => interaction.showModal(toModal(modal)).then(() => undefined),
@@ -336,6 +397,16 @@ function createCommandContext(interaction, services) {
         ...createContext(interaction, services),
         getStringOption: (name) => interaction.options.getString(name),
         getBooleanOption: (name) => interaction.options.getBoolean(name),
+        getUserOption: (name) => {
+            const user = interaction.options.getUser(name);
+            return user
+                ? {
+                    id: user.id,
+                    displayName: user.globalName ?? user.username,
+                    isBot: user.bot,
+                }
+                : null;
+        },
         getRoleOption: (name) => {
             const role = interaction.options.getRole(name);
             return role ? { id: role.id, name: role.name } : null;
@@ -397,6 +468,7 @@ function createModalContext(interaction, services) {
         : undefined;
     return {
         interactionId: interaction.id,
+        customId: interaction.customId,
         userId: interaction.user.id,
         userDisplayName: interaction.user.globalName ?? interaction.user.username,
         userRoleIds: interaction.member instanceof GuildMember
@@ -701,19 +773,10 @@ function toSelectRows(response) {
     return rows;
 }
 export function toUpdateOptions(response) {
-    const options = toReplyOptions({
+    return toReplyOptions({
         ...response,
         ephemeral: false,
     });
-    return response.componentsV2
-        ? {
-            ...options,
-            // Discord requires legacy fields to be cleared when an existing
-            // message is first converted to Components V2.
-            content: null,
-            embeds: [],
-        }
-        : options;
 }
 function toAllowedUserMentions(userIds) {
     if (userIds === undefined)

package/dist/management-module.js

@@ -18,6 +18,7 @@ const VALUE_MODAL_ID = "helyx.management.value.modal";
 const VALUE_FIELD_ID = "value";
 const SESSION_PURPOSE = "modules.manage";
 const PAGE_SIZE = 25;
+const MAX_DISCORD_SETTING_SELECTIONS = 25;
 const SESSION_LIFETIME_MS = 15 * 60 * 1_000;
 const VIOLET = 0x7c3aed;
 const SUCCESS = 0x16a34a;
@@ -177,7 +178,14 @@ export function createManagementModule(configurableModules, resources) {
                             return;
                         }
                         try {
-                            module.configuration?.validate(value);
+                            const validated = module.configuration?.validate(value);
+                            if (validated && module.configuration?.validateUpdate) {
+                                await module.configuration.validateUpdate({
+                                    guildId: context.serverId,
+                                    value: validated,
+                                    services: context.services,
+                                });
+                            }
                         }
                         catch (error) {
                             await context.reply(validationResponse(error instanceof Error
@@ -563,8 +571,12 @@ function settingValueResponse(setting) {
                 {
                     type: "discord-channel",
                     customId: VALUE_SELECT_ID,
-                    placeholder: "Choose a channel",
+                    placeholder: setting.multiple
+                        ? "Choose channels"
+                        : "Choose a channel",
                     channelTypes: setting.channelTypes,
+                    minValues: 1,
+                    maxValues: setting.multiple ? MAX_DISCORD_SETTING_SELECTIONS : 1,
                 },
             ],
         };
@@ -631,6 +643,8 @@ function initialDraft(module, existing) {
     return result;
 }
 function emptyValue(setting) {
+    if (setting.type === "discord-channel" && setting.multiple)
+        return [];
     if (setting.type === "discord-role" && setting.multiple)
         return [];
     if (setting.type === "string" ||
@@ -655,10 +669,13 @@ function selectedValue(setting, values) {
         return values[0];
     }
     if (setting.type === "discord-channel") {
-        if (values.length !== 1 || !isSnowflake(values[0])) {
-            throw new Error("Selected channel is invalid");
+        if (values.length < 1 ||
+            values.length > (setting.multiple ? MAX_DISCORD_SETTING_SELECTIONS : 1) ||
+            new Set(values).size !== values.length ||
+            values.some((value) => !isSnowflake(value))) {
+            throw new Error("Selected channel value is invalid");
         }
-        return values[0];
+        return setting.multiple ? [...values] : values[0];
     }
     if (setting.type === "discord-role") {
         if (values.length < 1 ||
@@ -723,9 +740,21 @@ async function validateDiscordSettings(directory, guildId, module, values) {
         if (configured === "" || configured === undefined)
             continue;
         if (setting.type === "discord-channel") {
-            const channel = typeof configured === "string" ? channels.get(configured) : undefined;
-            if (!channel || !setting.channelTypes.includes(channel.type)) {
-                return `${setting.label} must be an available supported Discord channel.`;
+            if (setting.multiple !== Array.isArray(configured)) {
+                return `${setting.label} has an invalid Discord channel selection.`;
+            }
+            const configuredChannels = Array.isArray(configured)
+                ? configured
+                : [configured];
+            if (configuredChannels.length > MAX_DISCORD_SETTING_SELECTIONS ||
+                new Set(configuredChannels).size !== configuredChannels.length ||
+                configuredChannels.some((channelId) => {
+                    if (typeof channelId !== "string")
+                        return true;
+                    const channel = channels.get(channelId);
+                    return !channel || !setting.channelTypes.includes(channel.type);
+                })) {
+                return `${setting.label} must contain available supported Discord channels.`;
             }
         }
         if (setting.type === "discord-role") {
@@ -776,8 +805,11 @@ function settingStatus(setting, value) {
     }
     if (setting.type === "boolean")
         return value === true ? "Enabled" : "Disabled";
-    if (setting.type === "discord-channel")
-        return "Channel selected";
+    if (setting.type === "discord-channel") {
+        return Array.isArray(value)
+            ? `${String(value.length)} channels selected`
+            : "Channel selected";
+    }
     if (setting.type === "discord-role") {
         return Array.isArray(value)
             ? `${String(value.length)} roles selected`

package/dist/message-classification.d.ts

@@ -0,0 +1,5 @@
+import { type Message } from "discord.js";
+import type { GuildMessageClassification } from "@helyx/sdk";
+export declare function classifyGuildMessage(message: Pick<Message, "attachments" | "content" | "embeds" | "flags" | "stickers">): GuildMessageClassification;
+export declare const unavailableGuildMessageClassification: GuildMessageClassification;
+//# sourceMappingURL=message-classification.d.ts.map

package/dist/message-classification.js

@@ -0,0 +1,75 @@
+import { MessageFlags } from "discord.js";
+const LINK_PATTERN = /https?:\/\/[^\s<>]+/giu;
+const GIF_LINK_PATTERN = /(?:https?:\/\/[^\s<>]*(?:\.gif(?:[?#][^\s<>]*)?|giphy\.com|tenor\.com|media\.discordapp\.net[^\s<>]*\.gif))/giu;
+const CUSTOM_EMOJI_PATTERN = /<a?:[a-zA-Z0-9_]{2,32}:\d{17,20}>/gu;
+const UNICODE_EMOJI_PATTERN = /(?:\p{Regional_Indicator}{2}|[0-9#*]\uFE0F?\u20E3|\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})?(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})?)*)/gu;
+export function classifyGuildMessage(message) {
+    const kinds = new Set();
+    const content = message.content.trim();
+    const withoutLinks = content.replace(LINK_PATTERN, " ").trim();
+    const withoutEmoji = withoutLinks
+        .replace(CUSTOM_EMOJI_PATTERN, " ")
+        .replace(UNICODE_EMOJI_PATTERN, " ")
+        .replace(/\u200D|\uFE0F|\p{Emoji_Modifier}|\s/gu, "");
+    if (matches(LINK_PATTERN, content))
+        kinds.add("link");
+    if (withoutLinks.length > 0 &&
+        withoutEmoji.length === 0 &&
+        (matches(CUSTOM_EMOJI_PATTERN, withoutLinks) ||
+            matches(UNICODE_EMOJI_PATTERN, withoutLinks)))
+        kinds.add("emoji");
+    else if (withoutEmoji.length > 0)
+        kinds.add("text");
+    const voiceMessage = message.flags.has(MessageFlags.IsVoiceMessage);
+    if (voiceMessage)
+        kinds.add("voice-message");
+    for (const attachment of message.attachments.values()) {
+        const contentType = attachment.contentType?.toLowerCase() ?? "";
+        const filename = attachment.name.toLowerCase();
+        if (voiceMessage)
+            continue;
+        if (contentType === "image/gif" || filename.endsWith(".gif"))
+            kinds.add("gif");
+        else if (contentType.startsWith("image/"))
+            kinds.add("image");
+        else
+            kinds.add("file");
+    }
+    for (const embed of message.embeds) {
+        const urls = [embed.url, embed.image?.url, embed.thumbnail?.url]
+            .filter((value) => Boolean(value))
+            .join(" ");
+        if (matches(GIF_LINK_PATTERN, urls))
+            kinds.add("gif");
+        else if (embed.image || embed.thumbnail)
+            kinds.add("image");
+    }
+    if (matches(GIF_LINK_PATTERN, content))
+        kinds.add("gif");
+    if (message.stickers.size > 0)
+        kinds.add("sticker");
+    return {
+        available: true,
+        kinds: [
+            "text",
+            "emoji",
+            "link",
+            "image",
+            "gif",
+            "file",
+            "sticker",
+            "voice-message",
+        ].filter((kind) => kinds.has(kind)),
+    };
+}
+export const unavailableGuildMessageClassification = {
+    available: false,
+    kinds: [],
+};
+function matches(pattern, value) {
+    pattern.lastIndex = 0;
+    const result = pattern.test(value);
+    pattern.lastIndex = 0;
+    return result;
+}
+//# sourceMappingURL=message-classification.js.map

package/dist/modules.js

@@ -90,12 +90,21 @@ async function loadDefinitions(specifiers, importer) {
     return orderedManifests.map((manifest) => byId.get(manifest.id));
 }
 export function validateContributionParity(definition) {
+    const requiredDiscordCapabilities = definition.requiredDiscordCapabilities ?? [];
+    if (new Set(requiredDiscordCapabilities).size !==
+        requiredDiscordCapabilities.length ||
+        requiredDiscordCapabilities.some((capability) => capability !== "guild-members" && capability !== "message-content")) {
+        throw new Error("Module requests an unsupported or duplicate Discord capability");
+    }
     const executableCommands = (definition.interactions?.commands ?? []).map(({ name }) => name);
     const executableEvents = [
+        ...(definition.events?.privilegedMessageCreate ?? []),
+        ...(definition.events?.guildMessageCreate ?? []),
         ...(definition.events?.messageReactionAdd ?? []),
         ...(definition.events?.messageReactionRemove ?? []),
         ...(definition.events?.messageDelete ?? []),
         ...(definition.events?.guildMemberAdd ?? []),
+        ...(definition.events?.guildMemberRemove ?? []),
         ...(definition.events?.guildRoleDelete ?? []),
         ...(definition.events?.guildRoleUpdate ?? []),
         ...(definition.events?.channelDelete ?? []),

package/dist/numeric-write-behind-proxy.d.ts

@@ -0,0 +1,62 @@
+import { type NumericWriteBehindCommittedBatch, type NumericWriteBehindEnqueueInput, type NumericWriteBehindMemberScope, type NumericWriteBehindScope, type NumericWriteBehindService } from "@helyx/sdk";
+import { type ShardIdentity } from "./shard-contracts.js";
+export declare class WorkerNumericWriteBehindProxy implements NumericWriteBehindService {
+    #private;
+    constructor(identity: ShardIdentity);
+    enqueue(input: NumericWriteBehindEnqueueInput): Promise<{
+        outcome: "accepted" | "cooldown" | "suppressed" | "paused" | "capacity" | "unavailable";
+    }>;
+    pendingMemberSnapshot(input: NumericWriteBehindMemberScope): Promise<{
+        increments: Readonly<Record<string, number>>;
+        maxima: Readonly<Record<string, Date>>;
+        oldestAcceptedAt: Date | null;
+    }>;
+    flushMember(input: NumericWriteBehindMemberScope): Promise<void>;
+    flushGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+    }): Promise<void>;
+    flushSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }): Promise<void>;
+    flushModule(input: NumericWriteBehindScope): Promise<void>;
+    runMemberBarrier<Result>(input: NumericWriteBehindMemberScope, operation: () => Promise<Result>): Promise<Result>;
+    runGuildBarrier<Result>(input: NumericWriteBehindScope & {
+        guildId: string;
+    }, operation: () => Promise<Result>): Promise<Result>;
+    runSubjectBarrier<Result>(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }, operation: () => Promise<Result>): Promise<Result>;
+    suppressSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+        cutoff: Date;
+    }): Promise<{
+        suppressionId: string;
+        discarded: number;
+    }>;
+    suppressGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+    }): Promise<{
+        suppressionId: string;
+        discarded: number;
+    }>;
+    releaseGuild(input: NumericWriteBehindScope & {
+        guildId: string;
+        suppressionId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
+    releaseSubject(input: NumericWriteBehindScope & {
+        subjectId: string;
+        suppressionId: string;
+    }): Promise<{
+        released: boolean;
+    }>;
+    clearMemberCooldown(input: NumericWriteBehindMemberScope): Promise<void>;
+    clearSubjectCooldown(input: NumericWriteBehindScope & {
+        subjectId: string;
+    }): Promise<void>;
+    subscribeCommitted(input: NumericWriteBehindScope, handler: (batch: NumericWriteBehindCommittedBatch) => void | Promise<void>): () => void;
+    stop(): void;
+}
+export declare function encodeNumericIpcValue(input: unknown): unknown;
+//# sourceMappingURL=numeric-write-behind-proxy.d.ts.map