@helyx/bot 0.4.33 → 0.4.36

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.4.36
+
+### Patch Changes
+
+- Harden startup cleanup, lease ownership, database transaction handling, worker shutdown, and stale-work fencing across the hosted and self-hosted runtime.
+
+## 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

package/dist/cloud-management-module.js

@@ -1,6 +1,7 @@
 import { defineModule, } from "@helyx/sdk";
 import { Events } from "discord.js";
 import { ClientCloudDiscordDirectory, CloudConnectorUserError, } from "./cloud-connector.js";
+import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const CONNECT_MODAL_ID = "helyx.cloud.connect";
 const CONNECT_CODE_FIELD_ID = "helyx.cloud.connect.code";
 const DISCONNECT_MODAL_ID = "helyx.cloud.disconnect";
@@ -72,7 +73,7 @@ export function createCloudManagementModule(input) {
     };
     return defineModule({
         manifest: {
-            manifestVersion: "0.1",
+            ...INTERNAL_MODULE_MANIFEST_FIELDS,
             releaseStatus: "live",
             id: "helyx.cloud-connect",
             name: "Helyx Cloud Connect",
@@ -106,6 +107,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 +138,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 +149,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 +189,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 +229,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

@@ -4,13 +4,9 @@ import { type ActionReceipt, type SignedAssessmentEnvelope } from "@helyx/verifi
 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>;
@@ -155,6 +152,7 @@ export interface BotControlHandler {
         correlationId: string;
     }): Promise<OAuthConsumerCleanupResult>;
     sendSupportNotification(input: SupportNotificationInput): Promise<void>;
+    listAvailabilityModules(): Promise<AvailabilityModuleCatalogue>;
     listGuildPresence(input: {
         guildIds: readonly string[];
         correlationId: string;
@@ -541,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

@@ -7,9 +7,12 @@ import Fastify, {} from "fastify";
 import { createHash, timingSafeEqual } from "node:crypto";
 import { z, ZodError } from "zod";
 import { addChannelMessageReaction as addDiscordChannelMessageReaction, deleteChannelMessage as deleteDiscordChannelMessage, editChannelMessage as editDiscordChannelMessage, normalizeDiscordPermission, sendToChannel as sendDiscordMessageToChannel, } from "./interactions.js";
+import { runNestedGuildBarriers } from "./numeric-barriers.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 +261,7 @@ export class BotControlService {
     presenceShardCount;
     #modules;
     #dashboardModules;
+    #availabilityModules;
     #configurations;
     #installations;
     #permissions;
@@ -273,6 +277,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);
@@ -423,14 +428,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 = {};
@@ -442,11 +449,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] = {
@@ -470,6 +473,7 @@ export class BotControlService {
             ...resources,
             modules: structuredClone(this.#dashboardModules),
             moduleStatuses,
+            globallyDisabledModuleIds: disabledModules.ids,
             configurations,
             permissions,
             logging,
@@ -624,6 +628,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]) => ({
@@ -659,15 +664,11 @@ export class BotControlService {
             await setEnabled();
         }
         else {
-            const runBoundary = async (index) => {
-                const scope = scopes[index];
-                if (!scope) {
-                    await setEnabled();
-                    return;
-                }
-                await writeBehind.runGuildBarrier(scope, () => runBoundary(index + 1));
-            };
-            await runBoundary(0);
+            await runNestedGuildBarriers({
+                scopes,
+                writeBehind,
+                operation: setEnabled,
+            });
             for (const scope of scopes)
                 await writeBehind.flushGuild(scope);
             for (const scope of scopes)
@@ -677,6 +678,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 {
@@ -710,6 +712,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 ||
@@ -833,6 +836,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");
         }
@@ -877,6 +884,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) {
@@ -935,11 +943,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");
@@ -949,6 +959,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"), {
@@ -958,6 +969,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"), {
@@ -966,6 +978,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)
@@ -1061,6 +1074,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)
@@ -1368,6 +1389,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
@@ -1897,35 +1919,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

@@ -1,6 +1,7 @@
 import { defineModule, } from "@helyx/sdk";
 import { randomUUID } from "node:crypto";
 import { SHARD_CONTROL_TIMEOUT_MS, assertShardMessageSize, shardOperationsHealthResponseSchema, } from "./shard-contracts.js";
+import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
 const DEVELOPER_MODULE_ID = "helyx.developer-operations";
 const DEVELOPER_MODULE_NAME = "Helyx Developer Operations";
 const DEVELOPER_MODULE_VERSION = "0.2.0";
@@ -9,7 +10,7 @@ export function createDeveloperOperationsModule(input) {
     const approvedRoles = new Set(input.approvedRoleIds);
     return defineModule({
         manifest: {
-            manifestVersion: "0.1",
+            ...INTERNAL_MODULE_MANIFEST_FIELDS,
             releaseStatus: "live",
             id: DEVELOPER_MODULE_ID,
             name: DEVELOPER_MODULE_NAME,
@@ -33,6 +34,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 +83,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 +137,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;
@@ -162,8 +163,8 @@ export declare class DiscordGuildHealthInspection implements DiscordGuildHealthI
             resourceValidationValid: boolean | null;
             activationValid: boolean | null;
             catalogueMatches: boolean;
-            requiredCapabilities: readonly ("message-content" | "guild-members")[];
-            missingCapabilities: ("message-content" | "guild-members")[];
+            requiredCapabilities: readonly ("guild-members" | "message-content")[];
+            missingCapabilities: ("guild-members" | "message-content")[];
             missingPermissions: string[];
             healthStatus: "healthy" | "degraded" | "unhealthy";
             healthMessage: string | null;

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);