@helyx/bot 0.4.46 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # Changelog
 
+## 0.6.1
+
+### Patch Changes
+
+- Allow Premium slots to be released, reassigned and moved immediately without a
+  transfer cooldown, while preserving atomic entitlement projection and
+  final-source Premium module disablement.
+
+  Add fail-closed Premium quantity incident controls, recoverable allocation
+  management for removed servers, overlapping Stripe webhook-secret rotation and
+  restricted exception diagnostics. Complete the production environment
+  contract for every API and bot schema field.
+
+- Updated dependencies
+  - @helyx/config@1.0.0
+  - @helyx/database@1.0.0
+
+## 0.6.0
+
+### Minor Changes
+
+- 1dfbf5b: Add the reviewed Premium module catalogue and enforce its entitlement across
+  hosted command, interaction, event, scheduled-task, configuration and dashboard
+  mutation paths. Add account-owned Premium slot allocation, the `/activate`
+  Discord flow, final-source-loss repair and optional safe billing lifecycle
+  notifications. Add audited, privacy-aware Admin Premium overrides and
+  deterministic entitlement convergence for inactive subscriptions and quantity
+  reductions, while keeping billing and Premium-only commands out of generated
+  self-host projects.
+
+### Patch Changes
+
+- Updated dependencies [1dfbf5b]
+  - @helyx/config@0.7.0
+  - @helyx/database@0.12.0
+  - @helyx/module-manifest@0.9.0
+  - @helyx/platform@0.8.0
+
+## 0.5.1
+
+### Patch Changes
+
+- 579f2c4: Keep transport-public components behind module availability and enablement,
+  and classify dashboard permission operations separately from Discord commands.
+- Updated dependencies [579f2c4]
+- Updated dependencies [579f2c4]
+- Updated dependencies [579f2c4]
+  - @helyx/sdk@0.11.0
+  - @helyx/config@0.6.0
+  - @helyx/database@0.11.0
+
+## 0.5.0
+
+### Minor Changes
+
+- bbc4eee: Add the shared exact-progress, zoned-time, ordered-retention, multi-schedule, and durable cross-module role-ownership contracts required by the Events and Community Goals Testing modules.
+
+  Register the PostgreSQL progress and ownership services in core, deliver owned roles through bot roots and shard workers, and package the corresponding database migration and rollback.
+
+### Patch Changes
+
+- Updated dependencies [bbc4eee]
+- Updated dependencies
+  - @helyx/sdk@0.10.0
+  - @helyx/platform@0.7.0
+  - @helyx/database@0.10.0
+
+## 0.4.48
+
+### Patch Changes
+
+- Add declared command-operation permission targets, project them through both permission-management surfaces, and harden module lifecycle, health, visibility, bounded-work, optional-side-effect, command-permission, and Forms durable-workflow behavior. Preserve existing FAQ, Access Control, Achievements, Giveaways and Levels overrides through additive migrations while assigning every slash-command path its own permission identity.
+
+## 0.4.47
+
+### Patch Changes
+
+- Add the bounded Discord inspection, durable record scheduling and recurrence, trusted dashboard workspaces, rich-message composition, optional invite-attribution contracts, module deactivation/configuration hooks, and versioned schedulable-action registry required by the Analytics, Invite Tracking, Reminders, Birthdays, Role Expiry, Scheduler, Message Embedder, Auto-message, and Sticky Messages testing modules.
+
 ## 0.4.46
 
 ### Patch Changes

package/README.md

@@ -45,10 +45,10 @@ bot-specific `HELYX_STATUS_HEARTBEAT_SECRET`,
 `CF_ACCESS_CLIENT_ID`/`CF_ACCESS_CLIENT_SECRET` pair. Never reuse another
 producer's Access identity or heartbeat secret.
 
-Giveaways also requires the existing `HELYX_DATA_ENCRYPTION_KEY` so core can
-resume secure weighted-selection checkpoints without exposing the selection
-key to a module. Keep it stable across deployments; do not rotate it while a
-giveaway is drawing.
+Giveaways and Invite Tracking also require the existing
+`HELYX_DATA_ENCRYPTION_KEY`. Core uses it for secure weighted-selection
+checkpoints and stable invite-member fingerprints without exposing the key to
+a module. Keep it stable across deployments.
 
 Trivia uses questions already imported into PostgreSQL. Multiple Choice and
 Guess both run entirely from the saved question catalogue, and the bot runtime

package/dist/cloud-management-module.js

@@ -1,4 +1,5 @@
 import { defineModule, } from "@helyx/sdk";
+import { safeError } from "@helyx/core";
 import { Events } from "discord.js";
 import { ClientCloudDiscordDirectory, CloudConnectorUserError, } from "./cloud-connector.js";
 import { INTERNAL_MODULE_MANIFEST_FIELDS } from "./internal-module-manifest.js";
@@ -622,9 +623,4 @@ function restrictedPolicy() {
         deniedUserIds: [],
     };
 }
-function safeError(error) {
-    return error instanceof Error
-        ? { name: error.name, message: error.message }
-        : { name: "Error", message: String(error) };
-}
 //# sourceMappingURL=cloud-management-module.js.map

package/dist/command-path-contract.d.ts

@@ -0,0 +1,26 @@
+import type { CommandContribution, ModuleDefinition, SubcommandContribution } from "@helyx/sdk";
+export interface ExecutableCommandPath {
+    path: string;
+    permissionId: string;
+    explicitPermissionId: boolean;
+    name: string;
+    description: string;
+    source: "direct" | "shared" | "nexus";
+}
+export interface CommandPermissionTarget {
+    id: string;
+    name: string;
+    description: string;
+    kind: "command" | "operation";
+}
+export interface CommandPathContractIssue {
+    key: string;
+    message: string;
+}
+export declare const legacyCommandPathContractIssues: Readonly<Record<string, ReadonlySet<string>>>;
+export declare function collectExecutableCommandPaths(module: ModuleDefinition): ExecutableCommandPath[];
+export declare function collectCommandPermissionTargets(module: ModuleDefinition): CommandPermissionTarget[];
+export declare function resolveDirectCommandPath(command: CommandContribution, subcommand?: SubcommandContribution, groupName?: string | null): Pick<ExecutableCommandPath, "path" | "permissionId">;
+export declare function inspectCommandPathContract(module: ModuleDefinition): CommandPathContractIssue[];
+export declare function assertCommandPathContract(module: ModuleDefinition): void;
+//# sourceMappingURL=command-path-contract.d.ts.map

package/dist/command-path-contract.js

@@ -0,0 +1,157 @@
+export const legacyCommandPathContractIssues = Object.freeze({});
+export function collectExecutableCommandPaths(module) {
+    const paths = (module.interactions?.commands ?? []).flatMap((command) => collectDirectCommandPaths(command));
+    paths.push(...(module.sharedCommands ?? []).map((command) => {
+        const path = `${command.family}.${command.path}`;
+        return {
+            path,
+            permissionId: command.permissionId ?? path,
+            explicitPermissionId: command.permissionId !== undefined,
+            name: `/${command.family} ${command.path.replaceAll(".", " ")}`,
+            description: command.description,
+            source: "shared",
+        };
+    }), ...(module.nexusCommands ?? []).map((command) => {
+        const path = `nexus.${command.path}`;
+        return {
+            path,
+            permissionId: path,
+            explicitPermissionId: true,
+            name: `/nexus ${command.path.replaceAll(".", " ")}`,
+            description: command.description,
+            source: "nexus",
+        };
+    }));
+    return paths;
+}
+export function collectCommandPermissionTargets(module) {
+    return [
+        ...collectExecutableCommandPaths(module).map((command) => ({
+            id: command.permissionId,
+            name: command.name,
+            description: command.description,
+            kind: "command",
+        })),
+        ...(module.interactions?.commands ?? []).flatMap((command) => [
+            ...permissionOperations(command.permissionOperations),
+            ...(command.subcommands ?? []).flatMap((subcommand) => permissionOperations(subcommand.permissionOperations)),
+            ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.flatMap((subcommand) => permissionOperations(subcommand.permissionOperations))),
+        ]),
+        ...(module.sharedCommands ?? []).flatMap((command) => permissionOperations(command.permissionOperations)),
+        ...(module.nexusCommands ?? []).flatMap((command) => permissionOperations(command.permissionOperations)),
+    ];
+}
+export function resolveDirectCommandPath(command, subcommand, groupName) {
+    const path = [command.name, groupName, subcommand?.name]
+        .filter(Boolean)
+        .join(".");
+    return {
+        path,
+        permissionId: subcommand?.permissionId ?? command.permissionId ?? path,
+    };
+}
+export function inspectCommandPathContract(module) {
+    const issues = [];
+    const paths = collectExecutableCommandPaths(module);
+    const operations = collectCommandPermissionTargets(module).filter(({ kind }) => kind === "operation");
+    const pathsByPermissionId = new Map();
+    const seenPaths = new Set();
+    for (const command of paths) {
+        if (seenPaths.has(command.path)) {
+            issues.push({
+                key: `duplicate-command-path:${command.path}`,
+                message: `duplicate executable command path ${command.path}`,
+            });
+        }
+        seenPaths.add(command.path);
+        if (!command.explicitPermissionId) {
+            issues.push({
+                key: `missing-permission-id:${command.path}`,
+                message: `command ${command.path} has no explicit permission ID`,
+            });
+            continue;
+        }
+        const owners = pathsByPermissionId.get(command.permissionId) ?? [];
+        pathsByPermissionId.set(command.permissionId, [...owners, command.path]);
+        if (!Object.prototype.hasOwnProperty.call(module.defaultPermissions?.commands ?? {}, command.permissionId)) {
+            issues.push({
+                key: `missing-default-policy:${command.path}`,
+                message: `command ${command.path} has no explicit default policy for ${command.permissionId}`,
+            });
+        }
+    }
+    for (const operation of operations) {
+        if (operation.id.trim().length === 0 ||
+            operation.id.length > 100 ||
+            !/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/u.test(operation.id) ||
+            operation.name.trim().length === 0 ||
+            operation.name.length > 100 ||
+            operation.description.trim().length === 0) {
+            issues.push({
+                key: `invalid-permission-operation:${operation.id}`,
+                message: "command permission operations require a namespaced ID and a non-empty Discord-safe name and description",
+            });
+            continue;
+        }
+        const owners = pathsByPermissionId.get(operation.id) ?? [];
+        pathsByPermissionId.set(operation.id, [
+            ...owners,
+            `operation:${operation.name}`,
+        ]);
+        if (!Object.prototype.hasOwnProperty.call(module.defaultPermissions?.commands ?? {}, operation.id)) {
+            issues.push({
+                key: `missing-default-policy:operation:${operation.id}`,
+                message: `command operation ${operation.name} has no explicit default policy for ${operation.id}`,
+            });
+        }
+    }
+    for (const [permissionId, owners] of pathsByPermissionId) {
+        if (owners.length > 1) {
+            issues.push({
+                key: `duplicate-permission-id:${permissionId}`,
+                message: `permission ID ${permissionId} is shared by ${owners.join(", ")}`,
+            });
+        }
+    }
+    return issues.sort((left, right) => left.key.localeCompare(right.key, "en-GB"));
+}
+function permissionOperations(operations) {
+    return (operations ?? []).map((operation) => ({
+        ...operation,
+        kind: "operation",
+    }));
+}
+export function assertCommandPathContract(module) {
+    const issues = inspectCommandPathContract(module);
+    const actual = new Set(issues.map(({ key }) => key));
+    const expected = legacyCommandPathContractIssues[module.manifest.id] ?? new Set();
+    const unexpected = issues.filter(({ key }) => !expected.has(key));
+    const stale = [...expected].filter((key) => !actual.has(key));
+    if (unexpected.length === 0 && stale.length === 0)
+        return;
+    const details = [
+        ...unexpected.map(({ message }) => message),
+        ...stale.map((key) => `legacy command-path exception is no longer needed: ${key}`),
+    ];
+    throw new Error(`Module ${module.manifest.id} command-path contract failed:\n${details.join("\n")}`);
+}
+function collectDirectCommandPaths(command) {
+    const nested = [
+        ...(command.subcommands ?? []).map((subcommand) => directCommandPath(command, subcommand)),
+        ...(command.subcommandGroups ?? []).flatMap((group) => group.subcommands.map((subcommand) => directCommandPath(command, subcommand, group.name))),
+    ];
+    if (nested.length > 0 || !command.execute)
+        return nested;
+    return [directCommandPath(command)];
+}
+function directCommandPath(command, subcommand, groupName) {
+    const resolved = resolveDirectCommandPath(command, subcommand, groupName);
+    return {
+        ...resolved,
+        explicitPermissionId: (subcommand?.permissionId ?? command.permissionId) !== undefined,
+        name: `/${resolved.path.replaceAll(".", " ")}`,
+        description: subcommand?.description ?? command.description,
+        source: "direct",
+    };
+}
+//# sourceMappingURL=command-path-contract.js.map

package/dist/command-registration-policy.js

@@ -5,6 +5,7 @@ const platformGlobalModuleIds = new Set([
     "helyx.oauth",
     "helyx.permissions",
     "helyx.privacy",
+    "helyx.premium-activation",
 ]);
 const deploymentModuleIds = new Set(["helyx.cloud-connect"]);
 const internalGuildModuleIds = new Set(["helyx.developer-operations"]);

package/dist/control-permissions.js

@@ -9,6 +9,7 @@ export function dashboardActionPermissionId(module, actionId) {
     return selectDeclaredPermission(module, [
         `${namespace}.${actionId.replaceAll("-", ".")}`,
         `${namespace}.configure`,
+        `${namespace}.manage`,
     ]);
 }
 export function managedResourcePermissionId(module, resourceType, operation, actionId, declaredPermissionId) {

package/dist/control-server.d.ts

@@ -7,41 +7,9 @@ import { type BotModuleStatusMutationResult } from "./module-status-control.js";
 import { type FirstTimeCommandSetupHandler } from "./first-time-command-setup.js";
 import { type ShardHealthSnapshot } from "./shard-contracts.js";
 import { type DashboardPermissionState } from "./control-permissions.js";
-import { type DashboardCommandDefinition } from "./dashboard-commands.js";
+import { type DashboardModuleDefinition } from "./dashboard-module-projection.js";
 import { type AvailabilityModuleCatalogue } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
-interface DashboardLogEventDefinition {
-    id: string;
-    name: string;
-    description: string;
-    defaultEnabled: boolean;
-}
-interface DashboardActionDefinition {
-    id: string;
-    label: string;
-    description: string;
-    buttonLabel: string;
-    style: "primary" | "secondary" | "danger";
-}
-type DashboardResourceDefinition = NonNullable<NonNullable<ModuleDefinition["manifest"]["dashboard"]>["resources"]>[number];
-interface DashboardModuleDefinition {
-    id: string;
-    name: string;
-    version: string;
-    summary: string;
-    category: string;
-    icon: string;
-    availability: "available";
-    releaseStatus: "planned" | "testing" | "beta" | "live";
-    requiredPermissions: string[];
-    settings: readonly unknown[];
-    commands: DashboardCommandDefinition[];
-    logEvents: DashboardLogEventDefinition[];
-    actions: DashboardActionDefinition[];
-    achievementTriggers: NonNullable<ModuleDefinition["manifest"]["contributions"]["achievementTriggers"]>;
-    resources: readonly DashboardResourceDefinition[];
-    workspace?: NonNullable<ModuleDefinition["manifest"]["dashboard"]>["workspace"];
-}
 interface DashboardLoggingPolicy {
     eventId: string;
     enabled: boolean;
@@ -51,7 +19,7 @@ export interface BotControlGuildResources {
     channels: Array<{
         id: string;
         name: string;
-        type: "guild_text" | "guild_announcement" | "guild_category";
+        type: "guild_text" | "guild_announcement" | "guild_category" | "guild_forum" | "guild_media";
     }>;
     roles: Array<{
         id: string;

package/dist/control-server.js

@@ -1,4 +1,5 @@
 import { AuditRepository, GuildAccessPolicyRepository, GuildCommandActiveLeaseError, GuildCommandRevisionConflictError, GuildCommandSetupConflictError, InstallationRepository, ModuleLoggingPolicyRepository, OptimisticConcurrencyError, PermissionPolicyRepository, withTransaction, } from "@helyx/database";
+import { safeError } from "@helyx/core";
 import { DashboardActionValidationError, DEFAULT_GUILD_ACCESS_POLICY, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
 import { actionReceiptSchema, signedAssessmentEnvelopeSchema, } from "@helyx/verification-contracts";
 import { canAccessGuildDashboard, canMutatePermissionPolicy, canUseCommand, resolveHelyxAuthority, } from "@helyx/core";
@@ -8,12 +9,13 @@ 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 { mutateDashboardModuleStatus, } from "./module-status-control.js";
+import { canAccessModule, PREMIUM_MODULE_UNAVAILABLE_MESSAGE, } from "./premium-access.js";
 import { completeFirstTimeCommandSetup, } from "./first-time-command-setup.js";
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.js";
-import { dashboardCategoryLabel } from "./dashboard-category.js";
 import { assertVersion, dashboardActionPermissionId, declaredManagedResourcePermission, fromDashboardPolicy, managedResourcePermissionId, permissionPoliciesEqual, permissionPolicyKey, safeOptionalVersion, safeVersion, toDashboardPolicy, } from "./control-permissions.js";
 import { assertPermissionMutationAllowed, BotControlForbiddenError, } from "./control-errors.js";
-import { dashboardCommands, } from "./dashboard-commands.js";
+import { dashboardCommands } from "./dashboard-commands.js";
+import { mapDashboardModule, } from "./dashboard-module-projection.js";
 import { availabilityCatalogueDefinitions, availabilityCatalogue, dashboardModuleStatus, disabledModuleSummary, moduleAvailabilityService, moduleAvailabilityStates, statusCatalogueDefinitions, } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
 import { createPrivacyProviderRegistry, describePrivacyProviders, } from "./privacy-provider-registry.js";
@@ -147,7 +149,9 @@ export class DiscordGuildResourceDirectory {
                 channels: [...channels.values()]
                     .filter((channel) => channel?.type === ChannelType.GuildText ||
                     channel?.type === ChannelType.GuildAnnouncement ||
-                    channel?.type === ChannelType.GuildCategory)
+                    channel?.type === ChannelType.GuildCategory ||
+                    channel?.type === ChannelType.GuildForum ||
+                    channel?.type === ChannelType.GuildMedia)
                     .map((channel) => ({
                     id: channel.id,
                     name: channel.name,
@@ -155,7 +159,11 @@ export class DiscordGuildResourceDirectory {
                         ? "guild_announcement"
                         : channel.type === ChannelType.GuildCategory
                             ? "guild_category"
-                            : "guild_text",
+                            : channel.type === ChannelType.GuildForum
+                                ? "guild_forum"
+                                : channel.type === ChannelType.GuildMedia
+                                    ? "guild_media"
+                                    : "guild_text",
                 }))
                     .sort((left, right) => left.name.localeCompare(right.name)),
                 roles: [...roles.values()]
@@ -627,13 +635,13 @@ export class BotControlService {
             dashboardModuleIds: this.#dashboardModules.map(({ id }) => id),
             installations: this.#installations,
             services: this.#services,
-            requireModuleAvailable: () => this.#requireModuleAvailable(input.moduleId),
+            requireModuleAvailable: () => this.#requireModuleAccessible(input.guildId, input.moduleId),
         });
     }
     async completeFirstTimeCommandSetup(input) {
         for (const moduleIdValue of new Set(input.moduleIds)) {
             this.#requireDashboardModule(moduleIdValue);
-            await this.#requireModuleAvailable(moduleIdValue);
+            await this.#requireModuleAccessible(input.guildId, moduleIdValue);
         }
         return completeFirstTimeCommandSetup({
             installations: this.#installations,
@@ -643,7 +651,7 @@ export class BotControlService {
     }
     async updateConfiguration(input) {
         const module = this.#requireDashboardModule(input.moduleId);
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, input.moduleId);
         await this.#validateDiscordSettings(input.guildId, module, input.value);
         if (module.configuration?.validateUpdate) {
             try {
@@ -677,7 +685,7 @@ export class BotControlService {
     }
     async updatePermissions(input) {
         const module = this.#requireDashboardModule(input.moduleId);
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, 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 ||
@@ -802,8 +810,8 @@ export class BotControlService {
     }
     async updateLoggingPolicy(input) {
         await Promise.all([
-            this.#requireModuleAvailable(input.moduleId),
-            this.#requireModuleAvailable("helyx.logging"),
+            this.#requireModuleAccessible(input.guildId, input.moduleId),
+            this.#requireModuleAccessible(input.guildId, "helyx.logging"),
         ]);
         if (!this.#modules.has("helyx.logging")) {
             throw new BotControlNotFoundError("Logging is not installed");
@@ -849,7 +857,7 @@ export class BotControlService {
     }
     async executeDashboardAction(input) {
         const module = this.#requireDashboardModule(input.moduleId);
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, 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) {
@@ -908,13 +916,13 @@ export class BotControlService {
         })), relation.columns.map(({ key }) => key));
     }
     async previewManagedResource(input) {
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, 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);
+        await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         this.#requireManagedResourceOperation(module, input.resourceType, "create");
         const context = await this.#managedResourceContext(input, module, "create");
@@ -924,7 +932,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);
+        await this.#requireModuleAccessible(input.guildId, 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"), {
@@ -934,7 +942,7 @@ export class BotControlService {
         })), managedResourceColumnKeys(module, input.resourceType));
     }
     async deleteManagedResource(input) {
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, 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"), {
@@ -943,7 +951,7 @@ export class BotControlService {
         }));
     }
     async executeManagedResourceAction(input) {
-        await this.#requireModuleAvailable(input.moduleId);
+        await this.#requireModuleAccessible(input.guildId, input.moduleId);
         const { module, resource } = this.#prepareManagedResource(input);
         const declared = module.manifest.dashboard?.resources
             ?.find(({ id }) => id === input.resourceType)
@@ -1047,6 +1055,12 @@ export class BotControlService {
         if (availability && !(await availability.isAvailable(moduleIdValue)))
             throw new BotControlValidationError("This module is temporarily unavailable for all hosted servers.");
     }
+    async #requireModuleAccessible(guildId, moduleIdValue) {
+        await this.#requireModuleAvailable(moduleIdValue);
+        const module = this.#requireModule(moduleIdValue);
+        if (!(await canAccessModule(this.#services, guildId, module)))
+            throw new BotControlValidationError(PREMIUM_MODULE_UNAVAILABLE_MESSAGE);
+    }
     #requireDashboardModule(moduleIdValue) {
         const module = this.#requireModule(moduleIdValue);
         if (!module.manifest.dashboard)
@@ -1697,10 +1711,7 @@ export async function createBotControlServer(input) {
             return reply.code(mapped.status).send({ message: mapped.message });
         if (error instanceof BotControlTransportError)
             return reply.code(error.status).send({ message: error.message });
-        const safeError = error instanceof Error
-            ? { name: error.name, message: error.message }
-            : { name: "Error", message: "Unknown control failure" };
-        request.log.error({ error: safeError }, "Private bot control request failed");
+        request.log.error({ error: safeError(error) }, "Private bot control request failed");
         return reply.code(500).send({ message: "The control request failed" });
     });
     return server;
@@ -1879,27 +1890,4 @@ function validateManagedResourceActionValue(inputs, value) {
             throw new DashboardActionValidationError(`${input.label} is not a valid action value.`);
     }
 }
-function mapDashboardModule(module) {
-    const dashboard = module.manifest.dashboard;
-    return {
-        id: module.manifest.id,
-        name: module.manifest.name,
-        version: module.manifest.version,
-        summary: module.manifest.description,
-        category: dashboardCategoryLabel(dashboard.category),
-        icon: dashboard.icon,
-        availability: "available",
-        releaseStatus: module.manifest.releaseStatus,
-        requiredPermissions: [...module.manifest.permissions],
-        settings: dashboard.settings,
-        commands: dashboardCommands(module),
-        logEvents: (module.logging?.events ?? []).map((event) => ({ ...event })),
-        actions: (dashboard.actions ?? []).map((action) => ({ ...action })),
-        achievementTriggers: (module.manifest.contributions?.achievementTriggers ?? []).map((trigger) => structuredClone(trigger)),
-        resources: (dashboard.resources ?? []).map((resource) => structuredClone(resource)),
-        workspace: dashboard.workspace
-            ? structuredClone(dashboard.workspace)
-            : undefined,
-    };
-}
 //# sourceMappingURL=control-server.js.map

package/dist/dashboard-commands.d.ts

@@ -4,6 +4,7 @@ export interface DashboardCommandDefinition {
     id: string;
     name: string;
     description: string;
+    kind: "command" | "operation";
     defaultPreset: DashboardPermissionPolicy["preset"];
 }
 export declare function dashboardCommands(module: ModuleDefinition): DashboardCommandDefinition[];

package/dist/dashboard-commands.js

@@ -1,41 +1,12 @@
 import { emptyPolicy, toDashboardPolicy, } from "./control-permissions.js";
+import { collectCommandPermissionTargets } from "./command-path-contract.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.sharedCommands ?? []).map((command) => dashboardCommand(module, {
-        id: command.permissionId ?? `${command.family}.${command.path}`,
-        name: `/${command.family} ${command.path.replace(".", " ")}`,
+    const commands = collectCommandPermissionTargets(module).map((command) => dashboardCommand(module, {
+        id: command.id,
+        name: command.name,
         description: command.description,
-    })), ...(module.nexusCommands ?? []).map((command) => dashboardCommand(module, {
-        id: `nexus.${command.path}`,
-        name: `/nexus ${command.path.replace(".", " ")}`,
-        description: command.description,
-    })));
+        kind: command.kind,
+    }));
     return [
         ...new Map(commands.map((command) => [command.id, command])).values(),
     ];

package/dist/dashboard-module-projection.d.ts

@@ -0,0 +1,39 @@
+import { type ModuleTier } from "@helyx/module-manifest";
+import type { ModuleDefinition } from "@helyx/sdk";
+import { type DashboardCommandDefinition } from "./dashboard-commands.js";
+interface DashboardLogEventDefinition {
+    id: string;
+    name: string;
+    description: string;
+    defaultEnabled: boolean;
+}
+interface DashboardActionDefinition {
+    id: string;
+    label: string;
+    description: string;
+    buttonLabel: string;
+    style: "primary" | "secondary" | "danger";
+}
+type DashboardResourceDefinition = NonNullable<NonNullable<ModuleDefinition["manifest"]["dashboard"]>["resources"]>[number];
+export interface DashboardModuleDefinition {
+    id: string;
+    name: string;
+    version: string;
+    summary: string;
+    category: string;
+    icon: string;
+    availability: "available";
+    releaseStatus: "planned" | "testing" | "beta" | "live";
+    tier: ModuleTier;
+    requiredPermissions: string[];
+    settings: readonly unknown[];
+    commands: DashboardCommandDefinition[];
+    logEvents: DashboardLogEventDefinition[];
+    actions: DashboardActionDefinition[];
+    achievementTriggers: NonNullable<ModuleDefinition["manifest"]["contributions"]["achievementTriggers"]>;
+    resources: readonly DashboardResourceDefinition[];
+    workspace?: NonNullable<ModuleDefinition["manifest"]["dashboard"]>["workspace"];
+}
+export declare function mapDashboardModule(module: ModuleDefinition): DashboardModuleDefinition;
+export {};
+//# sourceMappingURL=dashboard-module-projection.d.ts.map