@helyx/bot 0.4.32 → 0.4.35

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 0.4.35
+
+### Patch Changes
+
+- 26b4c3e: Add versioned hidden module dependencies, automatic installation lifecycle,
+  delegated customer health, and transitive self-host build composition for the
+  Nexus foundation while preserving legacy manifest and catalogue behavior. Add
+  closed, owner-aware composition for the shared `/nexus` command namespace and
+  bounded Core reads for terminology, member history and confirmed member value
+  changes. Add resumable, idempotent role and server bulk-award jobs.
+  Add bounded Nexus privacy capture, a durable hashed erasure fence and atomic
+  member detachment that journals any remaining balance as a privacy burn before
+  removing account and bulk-recipient identifiers.
+  Generalise the durable Achievement contribution bus as member contributions
+  while retaining the existing service names as compatibility aliases.
+  Add the private Nexus Rewards Testing package, complete initial record schema
+  and an atomic timezone-aware Daily Claim path backed by the shared ledger.
+  Add reviewed, default-off Nexus eligibility metadata to existing contribution
+  catalogues and atomically apply configured fixed rewards with source, role,
+  rate-cap, replay, balance-cap and privacy safeguards.
+  Add definition-owned Achievement reward amounts and live repeatable-award
+  high-water processing so retries credit only newly committed occurrences.
+  Add the private Nexus Economy Testing package and its complete initial Exchange,
+  item, redemption, inventory, role-grant and durable fulfilment record schema.
+  Add a typed atomic Economy redemption path with exact replay, finite stock,
+  member limits, role eligibility, collectible inventory and durable fulfilment.
+  Add coalesced leased role fulfilment with reviewed Discord safety, observed
+  delivery reconciliation, bounded retries and Core-linked automatic refunds.
+- Updated dependencies [26b4c3e]
+  - @helyx/module-manifest@0.7.0
+  - @helyx/platform@0.6.0
+  - @helyx/sdk@0.8.0
+
+## 0.4.34
+
+### Patch Changes
+
+- Add fail-open production status heartbeat configuration and reporting support.
+
+## 0.4.33
+
+### Patch Changes
+
+- Add versioned OAuth consumer cleanup contracts, durable and resumable
+  revocation state, least-privilege provider scopes, and Creator Connections
+  cleanup dispatch. Promote the hosted-only Creator Connections module to live
+  availability with clear OAuth activation validation. Ignore shard responses
+  that finish after shutdown has already detached their worker.
+
 ## 0.4.32
 
 ### Patch Changes

package/dist/cloud-management-module.js

@@ -106,6 +106,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "connect",
                             description: "Connect this deployment using a one-use code",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -136,6 +137,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "status",
                             description: "Show this deployment's Cloud Connect status",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 20, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -146,6 +148,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "disconnect",
                             description: "Revoke this deployment's Cloud Connect identity",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -185,6 +188,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "rotate",
                             description: "Replace the saved Cloud Connect credential",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 3, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))
@@ -224,6 +228,7 @@ export function createCloudManagementModule(input) {
                         {
                             name: "support",
                             description: "Choose what Helyx support may inspect",
+                            acknowledgement: "immediate-modal",
                             rateLimit: { scope: "user", limit: 5, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await requireOwner(context)))

package/dist/control-server.d.ts

@@ -1,16 +1,12 @@
 import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
-import { type DashboardActionResult, type GuildAccessPolicy, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type PublicAchievementProjectionPage, type ServiceAccess } from "@helyx/sdk";
+import { type DashboardActionResult, type GuildAccessPolicy, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type OAuthConsumerCleanupResult, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type PublicAchievementProjectionPage, type ServiceAccess } from "@helyx/sdk";
 import { type ActionReceipt, type SignedAssessmentEnvelope } from "@helyx/verification-contracts";
 import { type Client } from "discord.js";
 import { type FastifyInstance } from "fastify";
 import { type ShardHealthSnapshot } from "./shard-contracts.js";
-import { type DashboardPermissionPolicy, type DashboardPermissionState } from "./control-permissions.js";
-interface DashboardCommandDefinition {
-    id: string;
-    name: string;
-    description: string;
-    defaultPreset: DashboardPermissionPolicy["preset"];
-}
+import { type DashboardPermissionState } from "./control-permissions.js";
+import { type DashboardCommandDefinition } from "./dashboard-commands.js";
+import { type AvailabilityModuleCatalogue } from "./module-availability-control.js";
 interface DashboardLogEventDefinition {
     id: string;
     name: string;
@@ -127,6 +123,7 @@ export interface BotControlState {
     roles: BotControlGuildResources["roles"];
     modules: DashboardModuleDefinition[];
     moduleStatuses: Record<string, "enabled" | "disabled" | "unavailable">;
+    globallyDisabledModuleIds: string[];
     configurations: Record<string, {
         version: number;
         value: Record<string, unknown>;
@@ -143,7 +140,19 @@ export interface DashboardGuildAccessState extends GuildAccessPolicy {
     updatedAt: string | null;
 }
 export interface BotControlHandler {
+    cleanupOAuthConsumer(input: {
+        consumerBindingId: string;
+        moduleId: string;
+        provider: "youtube" | "twitch";
+        guildId: string;
+        resourceType: string;
+        resourceId: string;
+        subjectUserId: string;
+        contractVersion: number;
+        correlationId: string;
+    }): Promise<OAuthConsumerCleanupResult>;
     sendSupportNotification(input: SupportNotificationInput): Promise<void>;
+    listAvailabilityModules(): Promise<AvailabilityModuleCatalogue>;
     listGuildPresence(input: {
         guildIds: readonly string[];
         correlationId: string;
@@ -339,6 +348,17 @@ export declare class BotControlService implements BotControlHandler {
         guildId: string;
         channelId: string;
     } | undefined, presenceOwnership?: GuildShardOwnership | undefined, presenceShardCount?: number | undefined);
+    cleanupOAuthConsumer(input: {
+        consumerBindingId: string;
+        moduleId: string;
+        provider: "youtube" | "twitch";
+        guildId: string;
+        resourceType: string;
+        resourceId: string;
+        subjectUserId: string;
+        contractVersion: number;
+        correlationId: string;
+    }): Promise<OAuthConsumerCleanupResult>;
     listGuildPresence(input: {
         guildIds: readonly string[];
         correlationId: string;
@@ -519,6 +539,7 @@ export declare class BotControlService implements BotControlHandler {
         correlationId: string;
         actorAuthenticatedAt?: string;
     }): Promise<ManagedResourceDetail | null>;
+    listAvailabilityModules(): Promise<AvailabilityModuleCatalogue>;
 }
 export declare function createBotControlServer(input: {
     service: BotControlHandler;

package/dist/control-server.js

@@ -9,7 +9,9 @@ import { z, ZodError } from "zod";
 import { addChannelMessageReaction as addDiscordChannelMessageReaction, deleteChannelMessage as deleteDiscordChannelMessage, editChannelMessage as editDiscordChannelMessage, normalizeDiscordPermission, sendToChannel as sendDiscordMessageToChannel, } from "./interactions.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
 import { dashboardCategoryLabel } from "./dashboard-category.js";
-import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, emptyPolicy, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
+import { dashboardCommands, } from "./dashboard-commands.js";
+import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, } from "./module-availability-control.js";
 const snowflake = z.string().regex(/^\d{17,20}$/u);
 const moduleId = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/u);
 const MAX_DISCORD_SETTING_SELECTIONS = 25;
@@ -258,6 +260,7 @@ export class BotControlService {
     presenceShardCount;
     #modules;
     #dashboardModules;
+    #availabilityModules;
     #configurations;
     #installations;
     #permissions;
@@ -273,6 +276,7 @@ export class BotControlService {
         this.#dashboardModules = modules
             .filter((module) => module.manifest.dashboard !== undefined)
             .map(mapDashboardModule);
+        this.#availabilityModules = availabilityCatalogueDefinitions(modules);
         this.#configurations = services.get(HELYX_SERVICE_NAMES.configuration);
         this.#installations = services.get(HELYX_SERVICE_NAMES.installations);
         this.#permissions = services.get(HELYX_SERVICE_NAMES.permissions);
@@ -286,6 +290,26 @@ export class BotControlService {
             })
             : []);
     }
+    async cleanupOAuthConsumer(input) {
+        const module = this.#modules.get(input.moduleId);
+        if (!module)
+            throw new BotControlNotFoundError("OAuth consumer module is unavailable");
+        const consumer = module.oauthConsumers?.find((candidate) => candidate.provider === input.provider &&
+            candidate.resourceType === input.resourceType &&
+            candidate.version === input.contractVersion);
+        if (!consumer)
+            throw new BotControlNotFoundError("OAuth consumer cleanup contract is unavailable");
+        return consumer.cleanup({
+            consumerBindingId: input.consumerBindingId,
+            provider: input.provider,
+            guildId: input.guildId,
+            resourceType: input.resourceType,
+            resourceId: input.resourceId,
+            subjectUserId: input.subjectUserId,
+            correlationId: input.correlationId,
+            services: this.#services,
+        });
+    }
     async listGuildPresence(input) {
         const guildIds = [...new Set(input.guildIds)];
         if (guildIds.length > 200)
@@ -403,14 +427,16 @@ export class BotControlService {
                 commandId: id,
             })),
         ]);
-        const [resources, installedModules, storedLoggingPolicies, runtime, storedConfigurations, storedPermissions,] = await Promise.all([
+        const [resources, installedModules, storedLoggingPolicies, runtime, storedConfigurations, storedPermissions, availabilityStates,] = await Promise.all([
             this.resources.getGuildResources(guildId),
             new InstallationRepository(this.database).listModules(guildId),
             new ModuleLoggingPolicyRepository(this.database).listForGuild(guildId),
             this.#inspectRuntimeCapabilities(),
             this.#readConfigurations(guildId, moduleIds),
             this.#readPermissionPolicies(guildId, permissionTargets),
+            moduleAvailabilityStates(this.#services, moduleIds),
         ]);
+        const disabledModules = disabledModuleSummary(availabilityStates);
         const installed = new Map(installedModules.map((module) => [module.moduleId, module]));
         const moduleStatuses = {};
         const configurations = {};
@@ -422,11 +448,7 @@ export class BotControlService {
         ]));
         for (const { dashboardModule, module } of dashboardEntries) {
             const installation = installed.get(dashboardModule.id);
-            moduleStatuses[dashboardModule.id] = installation
-                ? installation.enabled
-                    ? "enabled"
-                    : "disabled"
-                : "unavailable";
+            moduleStatuses[dashboardModule.id] = dashboardModuleStatus(disabledModules.set, dashboardModule.id, installation);
             const configuration = storedConfigurations.get(dashboardModule.id);
             if (configuration)
                 configurations[dashboardModule.id] = {
@@ -450,6 +472,7 @@ export class BotControlService {
             ...resources,
             modules: structuredClone(this.#dashboardModules),
             moduleStatuses,
+            globallyDisabledModuleIds: disabledModules.ids,
             configurations,
             permissions,
             logging,
@@ -604,6 +627,7 @@ export class BotControlService {
     }
     async setModuleStatus(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const scopes = Object.entries(module.records ?? {})
             .filter(([, collection]) => (collection.incrementableFields?.length ?? 0) > 0)
             .map(([collection]) => ({
@@ -657,6 +681,7 @@ export class BotControlService {
     }
     async updateConfiguration(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         await this.#validateDiscordSettings(input.guildId, module, input.value);
         if (module.configuration?.validateUpdate) {
             try {
@@ -690,6 +715,7 @@ export class BotControlService {
     }
     async updatePermissions(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const commands = dashboardCommands(module);
         const supplied = new Map(input.state.commands.map((command) => [command.commandId, command]));
         if (supplied.size !== input.state.commands.length ||
@@ -813,6 +839,10 @@ export class BotControlService {
         return this.#getPermissionState(input.guildId, module);
     }
     async updateLoggingPolicy(input) {
+        await Promise.all([
+            this.#requireModuleAvailable(input.moduleId),
+            this.#requireModuleAvailable("helyx.logging"),
+        ]);
         if (!this.#modules.has("helyx.logging")) {
             throw new BotControlNotFoundError("Logging is not installed");
         }
@@ -857,6 +887,7 @@ export class BotControlService {
     }
     async executeDashboardAction(input) {
         const module = this.#requireDashboardModule(input.moduleId);
+        await this.#requireModuleAvailable(input.moduleId);
         const declared = module.manifest.dashboard?.actions?.find(({ id }) => id === input.actionId);
         const action = module.dashboardActions?.find(({ id }) => id === input.actionId);
         if (!declared || !action) {
@@ -915,11 +946,13 @@ export class BotControlService {
         })), relation.columns.map(({ key }) => key));
     }
     async previewManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "preview");
         return resource.preview(await this.#managedResourceContext(input, module, "preview"), input.value);
     }
     async createManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "create");
         const context = await this.#managedResourceContext(input, module, "create");
@@ -929,6 +962,7 @@ export class BotControlService {
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.create(context, input.value, input.intent)), managedResourceColumnKeys(module, input.resourceType));
     }
     async updateManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "update");
         return normalizeManagedResourceDetail(managedResourceDetailSchema.parse(await resource.update(await this.#managedResourceContext(input, module, "update"), {
@@ -938,6 +972,7 @@ export class BotControlService {
         })), managedResourceColumnKeys(module, input.resourceType));
     }
     async deleteManagedResource(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "delete");
         return managedResourceDeleteResultSchema.parse(await resource.delete(await this.#managedResourceContext(input, module, "delete"), {
@@ -946,6 +981,7 @@ export class BotControlService {
         }));
     }
     async executeManagedResourceAction(input) {
+        await this.#requireModuleAvailable(input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         const declared = module.manifest.dashboard?.resources
             ?.find(({ id }) => id === input.resourceType)
@@ -1041,6 +1077,14 @@ export class BotControlService {
             throw new BotControlNotFoundError("Module is not installed");
         return module;
     }
+    listAvailabilityModules() {
+        return availabilityCatalogue(this.#availabilityModules);
+    }
+    async #requireModuleAvailable(moduleIdValue) {
+        const availability = moduleAvailabilityService(this.#services);
+        if (availability && !(await availability.isAvailable(moduleIdValue)))
+            throw new BotControlValidationError("This module is temporarily unavailable for all hosted servers.");
+    }
     #requireDashboardModule(moduleIdValue) {
         const module = this.#requireModule(moduleIdValue);
         if (!module.manifest.dashboard)
@@ -1213,6 +1257,23 @@ export async function createBotControlServer(input) {
     server.get("/health", (_request, reply) => readiness(reply));
     server.get("/v1/health", (_request, reply) => readiness(reply));
     server.post("/v1/verification/results", async (request) => input.service.acceptVerificationResult(signedAssessmentEnvelopeSchema.parse(request.body)));
+    server.post("/v1/oauth/consumers/cleanup", async (request) => {
+        const body = z
+            .object({
+            consumerBindingId: z.uuid(),
+            moduleId,
+            provider: z.enum(["youtube", "twitch"]),
+            guildId: snowflake,
+            resourceType: z.string().regex(/^[a-z][a-z0-9_-]*$/u),
+            resourceId,
+            subjectUserId: snowflake,
+            contractVersion: z.number().int().min(1).max(32_767),
+            correlationId: z.string().trim().min(1).max(200),
+        })
+            .strict()
+            .parse(request.body);
+        return input.service.cleanupOAuthConsumer(body);
+    });
     server.get("/v1/shards/health", async (request, reply) => {
         reply.header("Cache-Control", "no-store");
         if (!input.shardHealth)
@@ -1331,6 +1392,7 @@ export async function createBotControlServer(input) {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         return input.service.getGuildState(guildId);
     });
+    server.get("/v1/modules/availability-catalogue", () => input.service.listAvailabilityModules());
     server.post("/v1/guilds/:guildId/dashboard-access", async (request) => {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         const { actorUserId } = z
@@ -1860,35 +1922,6 @@ function mapDashboardModule(module) {
             : undefined,
     };
 }
-function dashboardCommands(module) {
-    const commands = (module.interactions?.commands ?? []).flatMap((command) => command.subcommands?.length
-        ? command.subcommands.map((subcommand) => {
-            const id = subcommand.permissionId ??
-                command.permissionId ??
-                `${command.name}.${subcommand.name}`;
-            return {
-                id,
-                name: `/${command.name} ${subcommand.name}`,
-                description: subcommand.description,
-                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[id] ??
-                    module.defaultPermissions?.module ??
-                    emptyPolicy()).preset,
-            };
-        })
-        : [
-            {
-                id: command.permissionId ?? command.name,
-                name: `/${command.name}`,
-                description: command.description,
-                defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[command.name] ??
-                    module.defaultPermissions?.module ??
-                    emptyPolicy()).preset,
-            },
-        ]);
-    return [
-        ...new Map(commands.map((command) => [command.id, command])).values(),
-    ];
-}
 function assertPermissionMutationAllowed(decision) {
     if (decision.allowed)
         return;

package/dist/dashboard-commands.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleDefinition } from "@helyx/sdk";
+import { type DashboardPermissionPolicy } from "./control-permissions.js";
+export interface DashboardCommandDefinition {
+    id: string;
+    name: string;
+    description: string;
+    defaultPreset: DashboardPermissionPolicy["preset"];
+}
+export declare function dashboardCommands(module: ModuleDefinition): DashboardCommandDefinition[];
+//# sourceMappingURL=dashboard-commands.d.ts.map

package/dist/dashboard-commands.js

@@ -0,0 +1,47 @@
+import { emptyPolicy, toDashboardPolicy, } from "./control-permissions.js";
+export function dashboardCommands(module) {
+    const commands = (module.interactions?.commands ?? []).flatMap((command) => {
+        const nested = [
+            ...(command.subcommands ?? []).map((subcommand) => dashboardCommand(module, {
+                id: subcommand.permissionId ??
+                    command.permissionId ??
+                    `${command.name}.${subcommand.name}`,
+                name: `/${command.name} ${subcommand.name}`,
+                description: subcommand.description,
+            })),
+            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => dashboardCommand(module, {
+                id: subcommand.permissionId ??
+                    command.permissionId ??
+                    `${command.name}.${group.name}.${subcommand.name}`,
+                name: `/${command.name} ${group.name} ${subcommand.name}`,
+                description: subcommand.description,
+            }))),
+        ];
+        if (nested.length > 0)
+            return nested;
+        return [
+            dashboardCommand(module, {
+                id: command.permissionId ?? command.name,
+                name: `/${command.name}`,
+                description: command.description,
+            }),
+        ];
+    });
+    commands.push(...(module.nexusCommands ?? []).map((command) => dashboardCommand(module, {
+        id: `nexus.${command.path}`,
+        name: `/nexus ${command.path.replace(".", " ")}`,
+        description: command.description,
+    })));
+    return [
+        ...new Map(commands.map((command) => [command.id, command])).values(),
+    ];
+}
+function dashboardCommand(module, command) {
+    return {
+        ...command,
+        defaultPreset: toDashboardPolicy(module.defaultPermissions?.commands[command.id] ??
+            module.defaultPermissions?.module ??
+            emptyPolicy()).preset,
+    };
+}
+//# sourceMappingURL=dashboard-commands.js.map

package/dist/developer-operations-module.js

@@ -33,6 +33,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "shards",
                             description: "Show bounded read-only shard health",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))
@@ -81,6 +82,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "bot",
                             description: "Show the bot build and installed module versions",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))
@@ -134,6 +136,7 @@ export function createDeveloperOperationsModule(input) {
                         {
                             name: "proc",
                             description: "Show safe process resource and uptime information",
+                            acknowledgement: "deferred-ephemeral",
                             rateLimit: { scope: "user", limit: 10, windowSeconds: 60 },
                             async execute(context) {
                                 if (!(await authorizeDeveloperCommand(context)))

package/dist/discord-guild-health.d.ts

@@ -1,9 +1,10 @@
+import { type ModuleManifest } from "@helyx/module-manifest";
 import type { DiscordGuildHealthInspectionService, DiscordGuildHealthUnavailable, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
 import { type Client } from "discord.js";
 export declare function moduleCatalogueMatches(packagedManifest: unknown, executableManifest: unknown): boolean;
 export declare function missingRequiredPermissions(grantedPermissions: readonly string[], requiredPermissions: readonly string[]): string[];
 export declare function hasRequiredModuleConfiguration(exposesConfiguration: boolean, savedConfiguration: unknown): boolean;
-export declare function isHealthInspectableModule(moduleId: string): boolean;
+export declare function isHealthInspectableModule(module: ModuleManifest | string): boolean;
 export declare class DiscordGuildHealthInspection implements DiscordGuildHealthInspectionService {
     #private;
     private readonly client;

package/dist/discord-guild-health.js

@@ -1,3 +1,4 @@
+import { hasDirectModuleHealthExposure, } from "@helyx/module-manifest";
 import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
 import { AuditLogEvent, GatewayIntentBits, } from "discord.js";
 import { isDeepStrictEqual } from "node:util";
@@ -21,8 +22,10 @@ export function missingRequiredPermissions(grantedPermissions, requiredPermissio
 export function hasRequiredModuleConfiguration(exposesConfiguration, savedConfiguration) {
     return !exposesConfiguration || savedConfiguration !== null;
 }
-export function isHealthInspectableModule(moduleId) {
-    return !INTERNAL_HELYX_MODULE_IDS.has(moduleId);
+export function isHealthInspectableModule(module) {
+    const moduleId = typeof module === "string" ? module : module.id;
+    return (!INTERNAL_HELYX_MODULE_IDS.has(moduleId) &&
+        (typeof module === "string" || hasDirectModuleHealthExposure(module)));
 }
 export class DiscordGuildHealthInspection {
     client;
@@ -270,7 +273,7 @@ export class DiscordGuildHealthInspection {
                 return overview;
             const items = [];
             const batchSize = Math.min(20, Math.max(1, input.batchSize ?? 20));
-            const inspectableModules = this.modules.filter((module) => isHealthInspectableModule(module.manifest.id));
+            const inspectableModules = this.modules.filter((module) => isHealthInspectableModule(module.manifest));
             for (let index = 0; index < inspectableModules.length; index += 1) {
                 const module = inspectableModules[index];
                 const state = await installations.getModuleState(input.guildId, module.manifest.id);