@helyx/bot 0.4.46 → 0.6.1

package/dist/interactions.js

@@ -1,9 +1,11 @@
 import { lookup as lookupDns } from "node:dns/promises";
 import { HELYX_SERVICE_NAMES, NexusEconomyError, UserFacingInteractionError, } from "@helyx/sdk";
-import { canUseCommand } from "@helyx/core";
+import { canUseCommand, safeError } from "@helyx/core";
 import { commandRegistrationPolicy, contributionRegistrationPolicy, } from "./command-registration-policy.js";
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelSelectMenuBuilder, EmbedBuilder, Events, GuildMember, ApplicationIntegrationType, ChannelType, InteractionContextType, LabelBuilder, MessageFlags, MentionableSelectMenuBuilder, ModalBuilder, RoleSelectMenuBuilder, Routes, StringSelectMenuBuilder, SlashCommandBuilder, TextInputBuilder, TextInputStyle, UserSelectMenuBuilder, TextDisplayBuilder, PermissionFlagsBits, escapeMarkdown, } from "discord.js";
 import { collectCommandRegistrations, } from "./shared-commands.js";
+import { resolveDirectCommandPath } from "./command-path-contract.js";
+import { canAccessModule, PREMIUM_MODULE_UNAVAILABLE_MESSAGE, } from "./premium-access.js";
 const buttonStyles = {
     primary: ButtonStyle.Primary,
     secondary: ButtonStyle.Secondary,
@@ -108,11 +110,8 @@ export function installInteractions(client, modules, registration, logger, servi
                     if (!registered ||
                         !subcommand?.autocomplete ||
                         !ownerModuleId ||
-                        !(await authorizeAutocomplete(interaction, ownerModuleId, subcommand.permissionId ??
-                            [registered.contribution.name, groupName, subcommand.name]
-                                .filter(Boolean)
-                                .join("."), services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
-                            false, subcommand.authorization === "resource-scoped", isInstallationIndependentModule(modulesById, ownerModuleId), subcommand.authorization))) {
+                        !(await authorizeAutocomplete(interaction, ownerModuleId, resolveDirectCommandPath(registered.contribution, subcommand, groupName).permissionId, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
+                            false, subcommand.authorization === "resource-scoped", isInstallationIndependentModule(modulesById, ownerModuleId), subcommand.authorization, requiredCommandModule(modulesById, ownerModuleId)))) {
                         await response.respond([]);
                         return;
                     }
@@ -175,12 +174,7 @@ export function installInteractions(client, modules, registration, logger, servi
                         });
                         return;
                     }
-                    const commandId = subcommandName
-                        ? [command.name, groupName, subcommandName]
-                            .filter(Boolean)
-                            .join(".")
-                        : command.name;
-                    const permissionId = subcommand?.permissionId ?? command.permissionId ?? commandId;
+                    const { permissionId } = resolveDirectCommandPath(command, subcommand, groupName);
                     const owner = resolveCommandOwner(registered, subcommandName, groupName);
                     const ownerModuleId = owner?.moduleId ?? moduleId;
                     const installationIndependentCommand = isInstallationIndependentModule(modulesById, ownerModuleId);
@@ -197,7 +191,7 @@ export function installInteractions(client, modules, registration, logger, servi
                         await interaction.deferReply({ flags: MessageFlags.Ephemeral });
                     }
                     if (await authorizeCommand(interaction, ownerModuleId, permissionId, rateLimit, services, registration.selfAuthorizingGuildModuleIds?.has(ownerModuleId) ??
-                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName, installationIndependentCommand, authorization)) {
+                        false, subcommand?.authorization === "resource-scoped", owner?.moduleName, installationIndependentCommand, authorization, requiredCommandModule(modulesById, ownerModuleId))) {
                         const context = createCommandContext(interaction, services);
                         await execute(context);
                     }
@@ -224,12 +218,7 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
                 if (button &&
                     context &&
-                    button.contribution.authorization === "public") {
-                    await button.contribution.execute(context);
-                }
-                else if (button &&
-                    context &&
-                    (await authorizeComponent(interaction, button.moduleId, services, undefined, isInstallationIndependentModule(modulesById, button.moduleId)))) {
+                    (await authorizeComponent(interaction, button.moduleId, services, undefined, isInstallationIndependentModule(modulesById, button.moduleId), modulesById.get(button.moduleId)))) {
                     await button.contribution.execute(context);
                 }
             }
@@ -246,7 +235,7 @@ export function installInteractions(client, modules, registration, logger, servi
                     await interaction.deferReply({ flags: MessageFlags.Ephemeral });
                 }
                 if (modal &&
-                    (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId)))) {
+                    (await authorizeComponent(interaction, modal.moduleId, services, undefined, isInstallationIndependentModule(modulesById, modal.moduleId), modulesById.get(modal.moduleId)))) {
                     await modal.contribution.execute(createModalContext(interaction, services));
                 }
             }
@@ -271,7 +260,7 @@ export function installInteractions(client, modules, registration, logger, servi
                 }
                 if (select &&
                     context &&
-                    (await authorizeComponent(interaction, select.moduleId, services, undefined, isInstallationIndependentModule(modulesById, select.moduleId)))) {
+                    (await authorizeComponent(interaction, select.moduleId, services, undefined, isInstallationIndependentModule(modulesById, select.moduleId), modulesById.get(select.moduleId)))) {
                     await select.contribution.execute(context);
                 }
             }
@@ -515,6 +504,8 @@ function addCommandOption(builder, option) {
         guild_text: ChannelType.GuildText,
         guild_announcement: ChannelType.GuildAnnouncement,
         guild_category: ChannelType.GuildCategory,
+        guild_forum: ChannelType.GuildForum,
+        guild_media: ChannelType.GuildMedia,
     };
     builder.addChannelOption((optionBuilder) => {
         optionBuilder
@@ -862,19 +853,31 @@ export async function addChannelMessageReaction(client, channelId, messageId, em
     const message = await channel.messages.fetch(messageId);
     await message.react(emojiIdentifier);
 }
-async function authorizeComponent(interaction, moduleId, services, requiredModuleName, installationIndependent = false) {
+async function authorizeComponent(interaction, moduleId, services, requiredModuleName, installationIndependent = false, module) {
     if (installationIndependent)
         return true;
-    if (!(await moduleIsGloballyAvailable(services, moduleId))) {
+    const installations = interaction.guildId
+        ? services.get(HELYX_SERVICE_NAMES.installations)
+        : undefined;
+    const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
+        moduleIsGloballyAvailable(services, moduleId),
+        installations
+            ? installations.isModuleEnabled(interaction.guildId, moduleId)
+            : Promise.resolve(true),
+        interaction.guildId && module
+            ? canAccessModule(services, interaction.guildId, module)
+            : Promise.resolve(true),
+    ]);
+    if (!globallyAvailable) {
         await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
         return false;
     }
-    if (!interaction.guildId)
-        return true;
-    const installations = services.get(HELYX_SERVICE_NAMES.installations);
-    if (await installations.isModuleEnabled(interaction.guildId, moduleId)) {
-        return true;
+    if (!premiumAccessible) {
+        await replyEphemeralText(interaction, PREMIUM_MODULE_UNAVAILABLE_MESSAGE);
+        return false;
     }
+    if (moduleEnabled)
+        return true;
     await replyEphemeralText(interaction, requiredModuleName
         ? `This command needs ${requiredModuleName}. Ask a server administrator to enable it in the Helyx dashboard.`
         : "This module is disabled in this server. Ask a server administrator to enable it with `/helyx` or in the Helyx dashboard.");
@@ -887,22 +890,29 @@ async function replyEphemeralText(interaction, content) {
     }
     await interaction.reply({ content, flags: MessageFlags.Ephemeral });
 }
-export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName, installationIndependentCommand = false, authorization) {
+export async function authorizeCommand(interaction, moduleId, commandId, rateLimit, services, selfAuthorizingGuildCommand, resourceScopedCommand = false, requiredModuleName, installationIndependentCommand = false, authorization, module) {
     const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
     if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
         const installations = interaction.guildId
             ? services.get(HELYX_SERVICE_NAMES.installations)
             : undefined;
-        const [globallyAvailable, moduleEnabled] = await Promise.all([
+        const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
             moduleIsGloballyAvailable(services, moduleId),
             installations && !selfAuthorizingGuildCommand
                 ? installations.isModuleEnabled(interaction.guildId, moduleId)
                 : Promise.resolve(true),
+            interaction.guildId && module
+                ? canAccessModule(services, interaction.guildId, module)
+                : Promise.resolve(true),
         ]);
         if (!globallyAvailable) {
             await replyEphemeralText(interaction, GLOBAL_MODULE_UNAVAILABLE_MESSAGE);
             return false;
         }
+        if (!premiumAccessible) {
+            await replyEphemeralText(interaction, PREMIUM_MODULE_UNAVAILABLE_MESSAGE);
+            return false;
+        }
         if (!moduleEnabled) {
             await replyEphemeralText(interaction, requiredModuleName
                 ? `This command needs ${requiredModuleName}. Ask a server administrator to enable it in the Helyx dashboard.`
@@ -944,19 +954,22 @@ export async function authorizeCommand(interaction, moduleId, commandId, rateLim
     }
     return true;
 }
-async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand, installationIndependentCommand = false, authorization) {
+async function authorizeAutocomplete(interaction, moduleId, commandId, services, selfAuthorizingGuildCommand, resourceScopedCommand, installationIndependentCommand = false, authorization, module) {
     const bypassPlatformAuthorization = authorization === "public" || authorization === "self-authorized";
     if (!installationIndependentCommand && !selfAuthorizingGuildCommand) {
         const installations = interaction.guildId
             ? services.get(HELYX_SERVICE_NAMES.installations)
             : undefined;
-        const [globallyAvailable, moduleEnabled] = await Promise.all([
+        const [globallyAvailable, moduleEnabled, premiumAccessible] = await Promise.all([
             moduleIsGloballyAvailable(services, moduleId),
             installations && !selfAuthorizingGuildCommand
                 ? installations.isModuleEnabled(interaction.guildId, moduleId)
                 : Promise.resolve(true),
+            interaction.guildId && module
+                ? canAccessModule(services, interaction.guildId, module)
+                : Promise.resolve(true),
         ]);
-        if (!globallyAvailable || !moduleEnabled)
+        if (!globallyAvailable || !moduleEnabled || !premiumAccessible)
             return false;
     }
     if (bypassPlatformAuthorization ||
@@ -1053,27 +1066,37 @@ export function toReplyOptions(response) {
             ],
         };
     }
-    const embed = response.embed
-        ? new EmbedBuilder()
-            .setTitle(response.embed.title)
-            .setDescription(response.embed.description)
-            .setColor(response.embed.color ?? 0x7c3aed)
-        : undefined;
-    if (embed && response.embed?.footer)
-        embed.setFooter({ text: response.embed.footer });
-    if (embed && response.embed?.url)
-        embed.setURL(response.embed.url);
-    if (embed && response.embed?.author)
-        embed.setAuthor({
-            name: response.embed.author.name,
-            ...(response.embed.author.iconUrl
-                ? { iconURL: response.embed.author.iconUrl }
-                : {}),
-        });
-    if (embed && response.embed?.timestamp)
-        embed.setTimestamp(new Date(response.embed.timestamp));
-    if (embed && response.embed?.imageUrl)
-        embed.setImage(response.embed.imageUrl);
+    if (response.embed && response.embeds)
+        throw new Error("Message responses cannot use both embed and embeds");
+    const embeds = (response.embeds ?? (response.embed ? [response.embed] : [])).map((value) => {
+        const embed = new EmbedBuilder().setColor(value.color ?? 0x7c3aed);
+        if (value.title)
+            embed.setTitle(value.title);
+        if (value.description)
+            embed.setDescription(value.description);
+        if (value.footer)
+            embed.setFooter({
+                text: value.footer,
+                ...(value.footerIconUrl ? { iconURL: value.footerIconUrl } : {}),
+            });
+        if (value.url)
+            embed.setURL(value.url);
+        if (value.author)
+            embed.setAuthor({
+                name: value.author.name,
+                ...(value.author.url ? { url: value.author.url } : {}),
+                ...(value.author.iconUrl ? { iconURL: value.author.iconUrl } : {}),
+            });
+        if (value.timestamp)
+            embed.setTimestamp(new Date(value.timestamp));
+        if (value.imageUrl)
+            embed.setImage(value.imageUrl);
+        if (value.thumbnailUrl)
+            embed.setThumbnail(value.thumbnailUrl);
+        if (value.fields?.length)
+            embed.addFields(...value.fields);
+        return embed;
+    });
     const components = response.buttons?.length
         ? [
             new ActionRowBuilder().addComponents(response.buttons.map((button) => {
@@ -1096,15 +1119,20 @@ export function toReplyOptions(response) {
         : [];
     components.push(...selectRows);
     return {
-        ...(response.ephemeral || response.suppressEmbeds
+        ...(response.ephemeral ||
+            response.suppressEmbeds ||
+            response.suppressNotifications
             ? {
                 flags: (response.ephemeral ? MessageFlags.Ephemeral : 0) |
-                    (response.suppressEmbeds ? MessageFlags.SuppressEmbeds : 0),
+                    (response.suppressEmbeds ? MessageFlags.SuppressEmbeds : 0) |
+                    (response.suppressNotifications
+                        ? MessageFlags.SuppressNotifications
+                        : 0),
             }
             : {}),
         ...(allowedMentions ? { allowedMentions } : {}),
         ...(response.content === undefined ? {} : { content: response.content }),
-        ...(embed ? { embeds: [embed] } : {}),
+        ...(embeds.length > 0 ? { embeds } : {}),
         components,
     };
 }
@@ -1299,6 +1327,10 @@ function discordChannelType(type) {
         return ChannelType.GuildAnnouncement;
     if (type === "guild_category")
         return ChannelType.GuildCategory;
+    if (type === "guild_forum")
+        return ChannelType.GuildForum;
+    if (type === "guild_media")
+        return ChannelType.GuildMedia;
     return ChannelType.GuildText;
 }
 export function safeInteractionFailureMessage(error) {
@@ -1351,17 +1383,6 @@ async function sendFailure(interaction, error) {
         .reply({ content: message, flags: MessageFlags.Ephemeral })
         .catch(() => undefined);
 }
-function safeError(error) {
-    const value = error instanceof Error ? error : new Error(String(error));
-    return {
-        name: value.name,
-        message: value.message,
-        ...("code" in value &&
-            (typeof value.code === "string" || typeof value.code === "number")
-            ? { code: value.code }
-            : {}),
-    };
-}
 function interactionLogContext(interaction) {
     return {
         interactionId: interaction.id,

package/dist/management-module.d.ts

@@ -2,7 +2,7 @@ import { type ModuleDefinition } from "@helyx/sdk";
 export interface ManagementGuildResources {
     channels: readonly {
         id: string;
-        type: "guild_text" | "guild_announcement" | "guild_category";
+        type: "guild_text" | "guild_announcement" | "guild_category" | "guild_forum" | "guild_media";
     }[];
     roles: readonly {
         id: string;

package/dist/module-logging.js

@@ -1,4 +1,5 @@
 import { InstallationRepository, ModuleConfigurationRepository, ModuleLoggingPolicyRepository, } from "@helyx/database";
+import { safeError } from "@helyx/core";
 import { toReplyOptions } from "./interactions.js";
 import { createHash } from "node:crypto";
 const LOGGING_MODULE_ID = "helyx.logging";
@@ -108,8 +109,4 @@ function normalizeText(value, maximum, label) {
     }
     return normalized;
 }
-function safeError(error) {
-    const value = error instanceof Error ? error : new Error(String(error));
-    return { name: value.name, message: value.message };
-}
 //# sourceMappingURL=module-logging.js.map

package/dist/module-status-control.js

@@ -13,7 +13,7 @@ export async function mutateDashboardModuleStatus(input) {
         input.services.has(HELYX_SERVICE_NAMES.numericWriteBehind)
         ? input.services.get(HELYX_SERVICE_NAMES.numericWriteBehind)
         : null;
-    if (writeBehind)
+    if (change.enabled)
         await input.requireModuleAvailable();
     let mutationResult;
     const setEnabled = async () => {

package/dist/modules.d.ts

@@ -20,8 +20,10 @@ export declare function deriveSecureRandomSelectionKey(encodedDataEncryptionKey:
 export declare function platformServiceOptions(environment: PlatformServiceEnvironment, modules: readonly ModuleDefinition[]): {
     applicationId?: string;
     secureRandomSelectionKey?: Uint8Array;
+    inviteFingerprintKey?: Uint8Array;
     dashboardBaseUrl?: string;
 };
+export declare function deriveInviteFingerprintKey(selectionKey: Uint8Array): Uint8Array;
 export declare function loadConfiguredModules(specifiers: readonly string[], importer?: ModuleImporter): Promise<ModuleDefinition[]>;
 export declare function loadConfiguredModulePackages(specifiers: readonly string[], importer?: ModuleImporter, resolvePackageJson?: PackageJsonResolver, readPackageJson?: PackageJsonReader): Promise<ConfiguredModulePackage[]>;
 export declare function validateContributionParity(definition: ModuleDefinition): void;

package/dist/modules.js

@@ -4,10 +4,13 @@ import { createHmac } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
+import { assertCommandPathContract } from "./command-path-contract.js";
 const officialModulePackage = /^@helyx\/module-[a-z0-9][a-z0-9-]*$/u;
 const giveawaysModuleId = "helyx.giveaways";
+const inviteTrackingModuleId = "helyx.invite-tracking";
 export const secureRandomSelectionWorkerKeyName = "HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY";
 const secureRandomSelectionKeyContext = "helyx.secure-random-selection.worker.v1";
+const inviteFingerprintKeyContext = "helyx.discord-invite-fingerprint.v1";
 function decodeSecureRandomSelectionKey(encodedKey, variableName) {
     const key = Buffer.from(encodedKey, "base64");
     if (key.byteLength !== 32) {
@@ -30,25 +33,38 @@ export function platformServiceOptions(environment, modules) {
         : {};
     const internalSelectionKey = environment.HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY;
     if (internalSelectionKey) {
+        const selectionKey = decodeSecureRandomSelectionKey(internalSelectionKey, secureRandomSelectionWorkerKeyName);
         return {
             ...application,
             ...urls,
-            secureRandomSelectionKey: decodeSecureRandomSelectionKey(internalSelectionKey, secureRandomSelectionWorkerKeyName),
+            secureRandomSelectionKey: selectionKey,
+            inviteFingerprintKey: deriveInviteFingerprintKey(selectionKey),
         };
     }
     const encodedKey = environment.HELYX_DATA_ENCRYPTION_KEY;
     if (!encodedKey) {
-        if (modules.some(({ manifest }) => manifest.id === giveawaysModuleId)) {
-            throw new Error("HELYX_DATA_ENCRYPTION_KEY is required when Giveaways is loaded");
+        const keyRequired = modules.some(({ manifest }) => manifest.id === giveawaysModuleId ||
+            manifest.id === inviteTrackingModuleId);
+        if (keyRequired) {
+            throw new Error("HELYX_DATA_ENCRYPTION_KEY is required when Giveaways or Invite Tracking is loaded");
         }
         return { ...application, ...urls };
     }
+    const selectionKey = deriveSecureRandomSelectionKey(encodedKey);
     return {
         ...application,
         ...urls,
-        secureRandomSelectionKey: deriveSecureRandomSelectionKey(encodedKey),
+        secureRandomSelectionKey: selectionKey,
+        inviteFingerprintKey: deriveInviteFingerprintKey(selectionKey),
     };
 }
+export function deriveInviteFingerprintKey(selectionKey) {
+    if (selectionKey.byteLength !== 32)
+        throw new Error("Secure random selection key must contain exactly 32 bytes");
+    return createHmac("sha256", selectionKey)
+        .update(inviteFingerprintKeyContext, "utf8")
+        .digest();
+}
 function isModuleDefinition(value) {
     if (typeof value !== "object" || value === null)
         return false;
@@ -165,13 +181,20 @@ export function validateContributionParity(definition) {
         ...(definition.events?.guildEmojiUpdate ?? []),
     ].map(({ type }) => type);
     const executableLogs = (definition.logging?.events ?? []).map(({ id }) => id);
+    const executableSchedulableActions = [
+        ...new Set((definition.schedulableActions ?? []).map(({ id }) => id)),
+    ];
     const executableDashboardActions = (definition.dashboardActions ?? []).map(({ id }) => id);
     const executableManagedResources = (definition.managedResources ?? []).map(({ id }) => id);
     assertSameContributionIds(definition.manifest.contributions.commands, executableCommands, "commands");
     assertSameContributionIds(definition.manifest.contributions.events, executableEvents, "events");
     assertSameContributionIds(definition.manifest.contributions.logs ?? [], executableLogs, "logs");
+    assertSameContributionIds(definition.manifest.contributions.schedulableActions ?? [], executableSchedulableActions, "schedulable actions");
     assertSameContributionIds(definition.manifest.dashboard?.actions?.map(({ id }) => id) ?? [], executableDashboardActions, "dashboard actions");
     assertSameContributionIds(definition.manifest.dashboard?.resources?.map(({ id }) => id) ?? [], executableManagedResources, "dashboard resources");
+    if (definition.manifest.manifestVersion === "0.4") {
+        assertCommandPathContract(definition);
+    }
     validatePrivacyParity(definition);
 }
 function validatePrivacyParity(definition) {

package/dist/permissions-module.js

@@ -2,6 +2,7 @@ import { defineModule, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
 import { isCustomerSelectableModule } from "@helyx/module-manifest";
 import { PermissionFlagsBits } from "discord.js";
 import { canMutatePermissionPolicy, permissionMutationDenialMessage, } from "@helyx/core";
+import { collectCommandPermissionTargets } from "./command-path-contract.js";
 import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const MODULE_SELECT_ID = "helyx.permissions.module";
 const TARGET_SELECT_ID = "helyx.permissions.target";
@@ -129,7 +130,8 @@ export function createPermissionsModule(configurableModules) {
                         if (!module || !target)
                             throw new Error("Permission target expired");
                         const commandId = target === "__module__" ? undefined : target;
-                        if (commandId && !commandTargets(module).includes(commandId)) {
+                        if (commandId &&
+                            !commandTargets(module).some(({ id }) => id === commandId)) {
                             throw new Error("Selected command is unavailable");
                         }
                         const current = await context.services
@@ -437,17 +439,12 @@ function restrictedPolicy() {
     };
 }
 function commandTargets(module) {
-    const targets = (module.interactions?.commands ?? []).flatMap((command) => {
-        const nested = [
-            ...(command.subcommands ?? []).map((subcommand) => `${command.name}.${subcommand.name}`),
-            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => `${command.name}.${group.name}.${subcommand.name}`)),
-        ];
-        if (nested.length > 0)
-            return nested;
-        return [command.name];
-    });
-    targets.push(...(module.sharedCommands ?? []).map((command) => command.permissionId ?? `${command.family}.${command.path}`), ...(module.nexusCommands ?? []).map((command) => `nexus.${command.path}`));
-    return [...new Set(targets)];
+    return [
+        ...new Map(collectCommandPermissionTargets(module).map(({ id, name }) => [
+            id,
+            { id, label: name },
+        ])).values(),
+    ];
 }
 function modulePickerResponse(modules, requestedPage) {
     const pages = pageCount(modules.length, MODULE_PAGE_SIZE);
@@ -483,7 +480,7 @@ function targetPickerResponse(module, targets, requestedPage) {
         ephemeral: true,
         embed: {
             title: `${module.manifest.name} permissions`,
-            description: "Choose the whole module or one command. Command policies override the module policy." +
+            description: "Choose the whole module, a command, or a declared command operation. Target policies override the module policy." +
                 (pages > 1 ? ` Page ${String(page + 1)} of ${String(pages)}.` : ""),
             color: VIOLET,
         },
@@ -495,11 +492,11 @@ function targetPickerResponse(module, targets, requestedPage) {
                     {
                         label: "Entire module",
                         value: "__module__",
-                        description: "Default policy for every command",
+                        description: "Default policy for every command and operation",
                     },
                     ...visible.map((target) => ({
-                        label: `/${target.replaceAll(".", " ")}`,
-                        value: target,
+                        label: target.label,
+                        value: target.id,
                     })),
                 ],
             },

package/dist/premium-access.d.ts

@@ -0,0 +1,7 @@
+import { type ModuleDefinition, type ServiceAccess } from "@helyx/sdk";
+export declare const PREMIUM_MODULE_UNAVAILABLE_MESSAGE = "This Premium module is not assigned to this server. A Premium subscriber can assign a slot in Billing or with `/activate`.";
+export declare function moduleRequiresPremium(module: ModuleDefinition): boolean;
+export declare function requirePremiumProviderEnvironment(modules: readonly ModuleDefinition[], environment: "sandbox" | "live" | undefined): "sandbox" | "live" | undefined;
+export declare function canAccessModule(services: ServiceAccess, guildId: string, module: ModuleDefinition): Promise<boolean>;
+export declare function assertReviewedPremiumCatalogue(modules: readonly ModuleDefinition[]): void;
+//# sourceMappingURL=premium-access.d.ts.map

package/dist/premium-access.js

@@ -0,0 +1,38 @@
+import { getModuleTier, HELYX_PREMIUM_ENTITLEMENT_CAPABILITY, isReviewedPremiumModuleId, REVIEWED_PREMIUM_MODULE_IDS, } from "@helyx/module-manifest";
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+export const PREMIUM_MODULE_UNAVAILABLE_MESSAGE = "This Premium module is not assigned to this server. A Premium subscriber can assign a slot in Billing or with `/activate`.";
+export function moduleRequiresPremium(module) {
+    return getModuleTier(module.manifest) === "premium";
+}
+export function requirePremiumProviderEnvironment(modules, environment) {
+    if (!modules.some(moduleRequiresPremium))
+        return undefined;
+    if (!environment)
+        throw new Error("STRIPE_ENVIRONMENT is required when a reviewed Premium module is loaded");
+    return environment;
+}
+export async function canAccessModule(services, guildId, module) {
+    if (!moduleRequiresPremium(module))
+        return true;
+    if (!isReviewedPremiumModuleId(module.manifest.id))
+        return false;
+    if (typeof services.has === "function" &&
+        !services.has(HELYX_SERVICE_NAMES.entitlements))
+        return false;
+    const entitlements = services.get(HELYX_SERVICE_NAMES.entitlements);
+    return entitlements.has(guildId, HELYX_PREMIUM_ENTITLEMENT_CAPABILITY);
+}
+export function assertReviewedPremiumCatalogue(modules) {
+    const byId = new Map(modules.map((module) => [module.manifest.id, module]));
+    for (const module of modules) {
+        if (moduleRequiresPremium(module) &&
+            !isReviewedPremiumModuleId(module.manifest.id))
+            throw new Error(`Premium module has not passed catalogue review: ${module.manifest.id}`);
+    }
+    for (const moduleId of REVIEWED_PREMIUM_MODULE_IDS) {
+        const module = byId.get(moduleId);
+        if (module && !moduleRequiresPremium(module))
+            throw new Error(`Reviewed Premium module is missing its Premium manifest tier: ${moduleId}`);
+    }
+}
+//# sourceMappingURL=premium-access.js.map

package/dist/premium-activation-module.d.ts

@@ -0,0 +1,20 @@
+import type { BillingEnvironment, PremiumAllocationRepository } from "@helyx/database";
+import { type ModuleDefinition } from "@helyx/sdk";
+type AllocationService = Pick<PremiumAllocationRepository, "getAccountAllocation" | "inspectTarget" | "assignLowestAvailable" | "moveSlot" | "releaseSlot" | "auditDenied">;
+export interface PremiumGuildAuthority {
+    canManageGuild(input: {
+        guildId: string;
+        userId: string;
+    }): Promise<boolean>;
+}
+export interface PremiumActivationModuleOptions {
+    allocations: AllocationService;
+    authority: PremiumGuildAuthority;
+    provider: string;
+    providerEnvironment: BillingEnvironment;
+    reviewedPremiumModuleIds: readonly string[];
+    now?: () => Date;
+}
+export declare function createPremiumActivationModule(options: PremiumActivationModuleOptions): ModuleDefinition;
+export {};
+//# sourceMappingURL=premium-activation-module.d.ts.map