@helyx/bot 0.4.9 → 0.4.13

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 0.4.13
+
+### Patch Changes
+
+- Add the hosted-only Stage 11 Verification foundation: bounded signed challenge
+  contracts, restricted persistence and privacy traversal, shard-safe bot
+  delivery, delegated investigation permissions, verifier configuration and
+  health, and explicit exclusion from every self-hosted composition.
+- Updated dependencies
+  - @helyx/control-protocol@0.3.0
+  - @helyx/module-manifest@0.6.0
+  - @helyx/config@0.5.0
+  - @helyx/database@0.6.0
+  - @helyx/sdk@0.5.0
+  - @helyx/platform@0.4.0
+  - @helyx/core@0.1.12
+  - @helyx/framework@0.1.12
+
+## 0.4.12
+
+### Patch Changes
+
+- Repair hosted guild presence after removal, restart and shard reassignment with
+  bounded fenced reconciliation and customer-safe dashboard states.
+- Exit with failure after an unexpected coordinated-shard lease shutdown so the
+  service orchestrator replaces the stopped supervisor automatically.
+- Retry one transient lease-renewal transport failure within the existing
+  fencing window while still failing closed on an actual ownership mismatch.
+- Updated dependencies
+  - @helyx/config@0.4.4
+  - @helyx/database@0.5.1
+  - @helyx/platform@0.3.1
+
+## 0.4.11
+
+### Patch Changes
+
+- Add the reusable Stage 8 Levels foundations: privacy-bounded guild message
+  events with optional transient type classification, optional Discord-user
+  command options, multiple channel settings, bounded ranked numeric records,
+  idempotent numeric mutation receipts, and core-owned write-behind accumulation
+  across local and coordinated shard compositions.
+- Updated dependencies
+  - @helyx/database@0.5.0
+  - @helyx/module-manifest@0.5.0
+  - @helyx/control-protocol@0.2.0
+  - @helyx/sdk@0.4.0
+  - @helyx/platform@0.3.0
+  - @helyx/core@0.1.11
+  - @helyx/framework@0.1.11
+
+## 0.4.10
+
+### Patch Changes
+
+- Add the shared session, Discord event, resource inspection, enforcement,
+  privacy and hosted/self-hosted composition support required by the Account Gate
+  Testing module.
+- Updated dependencies
+  - @helyx/config@0.4.3
+  - @helyx/database@0.4.4
+  - @helyx/sdk@0.3.5
+  - @helyx/platform@0.2.8
+  - @helyx/core@0.1.10
+  - @helyx/framework@0.1.10
+
 ## 0.4.9
 
 ### Patch Changes

package/dist/cloud-control-dispatcher.js

@@ -146,11 +146,12 @@ export class CloudControlDispatcher {
                 break;
             }
             case "guild.module.resource.action.execute.v1": {
-                const input = parseOperationInput(request.operation, request.input);
+                const { actorAuthenticatedAt, ...input } = parseOperationInput(request.operation, request.input);
                 result = await this.control.executeManagedResourceAction({
                     ...input,
                     actorUserId: requiredActor(actorUserId),
                     correlationId,
+                    ...(actorAuthenticatedAt ? { actorAuthenticatedAt } : {}),
                 });
                 break;
             }

package/dist/control-server.d.ts

@@ -1,5 +1,6 @@
-import { type DatabasePool } from "@helyx/database";
+import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
 import { type DashboardActionResult, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, 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";
@@ -63,7 +64,7 @@ export interface BotControlGuildResources {
     channels: Array<{
         id: string;
         name: string;
-        type: "guild_text" | "guild_announcement";
+        type: "guild_text" | "guild_announcement" | "guild_category";
     }>;
     roles: Array<{
         id: string;
@@ -71,7 +72,14 @@ export interface BotControlGuildResources {
         colour: string;
     }>;
 }
+export type BotGuildPresenceState = "installed" | "not_installed" | "unknown" | "unavailable";
+export interface BotGuildPresenceObservation {
+    guildId: string;
+    state: BotGuildPresenceState;
+    observedAt: string;
+}
 export interface BotControlGuildResourceDirectory {
+    listGuildPresence(guildIds: readonly string[]): Promise<BotGuildPresenceObservation[]>;
     getGuildResources(guildId: string): Promise<BotControlGuildResources>;
     sendToChannel(channelId: string, response: MessageResponse): Promise<{
         messageId: string;
@@ -85,6 +93,7 @@ export interface BotControlGuildResourceDirectory {
 export declare class DiscordGuildResourceDirectory implements BotControlGuildResourceDirectory {
     private readonly client;
     constructor(client: Client);
+    listGuildPresence(guildIds: readonly string[]): Promise<BotGuildPresenceObservation[]>;
     getGuildResources(guildId: string): Promise<BotControlGuildResources>;
     sendToChannel(channelId: string, response: MessageResponse): Promise<{
         messageId: string;
@@ -104,6 +113,9 @@ export interface SupportNotificationInput {
     source: "dashboard_bug" | "dashboard_support" | "dashboard_security" | "discord_command";
 }
 export interface BotControlState {
+    discordCapabilities?: {
+        messageContent: boolean;
+    };
     channels: BotControlGuildResources["channels"];
     roles: BotControlGuildResources["roles"];
     modules: DashboardModuleDefinition[];
@@ -117,7 +129,18 @@ export interface BotControlState {
 }
 export interface BotControlHandler {
     sendSupportNotification(input: SupportNotificationInput): Promise<void>;
+    listGuildPresence(input: {
+        guildIds: readonly string[];
+        correlationId: string;
+    }): Promise<BotGuildPresenceObservation[]>;
     getGuildState(guildId: string): Promise<BotControlState>;
+    canAccessManagedResource(input: {
+        guildId: string;
+        moduleId: string;
+        resourceType: string;
+        operation: "list" | "read";
+        actorUserId: string;
+    }): Promise<boolean>;
     setModuleStatus(input: {
         guildId: string;
         moduleId: string;
@@ -237,7 +260,9 @@ export interface BotControlHandler {
         value: Readonly<Record<string, ManagedResourceValue>>;
         actorUserId: string;
         correlationId: string;
+        actorAuthenticatedAt?: string;
     }): Promise<ManagedResourceDetail | null>;
+    acceptVerificationResult(envelope: SignedAssessmentEnvelope): Promise<ActionReceipt>;
     listPrivacyProviders(): Promise<readonly {
         id: string;
         version: number;
@@ -269,11 +294,18 @@ export declare class BotControlService implements BotControlHandler {
     private readonly database;
     private readonly resources;
     private readonly supportNotifications?;
+    private readonly presenceOwnership?;
+    private readonly presenceShardCount?;
     constructor(database: DatabasePool, modules: readonly ModuleDefinition[], resources: BotControlGuildResourceDirectory, services: ServiceAccess, privacyExecutor?: PrivacyProviderExecutor, supportNotifications?: {
         guildId: string;
         channelId: string;
-    } | undefined);
+    } | undefined, presenceOwnership?: GuildShardOwnership | undefined, presenceShardCount?: number | undefined);
+    listGuildPresence(input: {
+        guildIds: readonly string[];
+        correlationId: string;
+    }): Promise<BotGuildPresenceObservation[]>;
     sendSupportNotification(input: SupportNotificationInput): Promise<void>;
+    acceptVerificationResult(envelopeInput: SignedAssessmentEnvelope): Promise<ActionReceipt>;
     listPrivacyProviders(): Promise<readonly {
         id: string;
         version: number;
@@ -296,6 +328,13 @@ export declare class BotControlService implements BotControlHandler {
         cursor?: string;
     }): Promise<PrivacyErasePage>;
     getGuildState(guildId: string): Promise<BotControlState>;
+    canAccessManagedResource(input: {
+        guildId: string;
+        moduleId: string;
+        resourceType: string;
+        operation: "list" | "read";
+        actorUserId: string;
+    }): Promise<boolean>;
     setModuleStatus(input: {
         guildId: string;
         moduleId: string;
@@ -415,6 +454,7 @@ export declare class BotControlService implements BotControlHandler {
         value: Readonly<Record<string, ManagedResourceValue>>;
         actorUserId: string;
         correlationId: string;
+        actorAuthenticatedAt?: string;
     }): Promise<ManagedResourceDetail | null>;
 }
 export declare function createBotControlServer(input: {

package/dist/control-server.js

@@ -1,5 +1,6 @@
 import { AuditRepository, InstallationRepository, ModuleLoggingPolicyRepository, OptimisticConcurrencyError, PermissionPolicyRepository, withTransaction, } from "@helyx/database";
 import { DashboardActionValidationError, HELYX_SERVICE_NAMES, ModuleStateValidationError, } from "@helyx/sdk";
+import { actionReceiptSchema, signedAssessmentEnvelopeSchema, } from "@helyx/verification-contracts";
 import { canUseCommand } from "@helyx/core";
 import { ChannelType, PermissionFlagsBits } from "discord.js";
 import Fastify, {} from "fastify";
@@ -9,6 +10,7 @@ import { addChannelMessageReaction as addDiscordChannelMessageReaction, deleteCh
 import { SHARD_HEALTH_STALE_MS, } from "./shard-contracts.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;
 const configurationValue = z.record(z.string(), z.union([
     z.null(),
     z.string(),
@@ -48,7 +50,7 @@ const resourceCursor = z.string().min(1).max(2_048);
 const resourceActionId = z.string().regex(/^[a-z][a-z0-9_-]*$/u);
 const managedResourceFilters = z
     .record(z.string().regex(/^[a-z][a-zA-Z0-9_]*$/u), z.string().trim().min(1).max(100))
-    .refine((value) => Object.keys(value).length <= 5);
+    .refine((value) => Object.keys(value).length <= 8);
 const managedResourceValue = z.custom((value) => isBoundedManagedResourceValue(value), "Managed resource value exceeds the transport limits");
 const managedResourceObject = z
     .record(z.string().min(1).max(100), managedResourceValue)
@@ -97,6 +99,24 @@ export class DiscordGuildResourceDirectory {
     constructor(client) {
         this.client = client;
     }
+    listGuildPresence(guildIds) {
+        const observedAt = new Date().toISOString();
+        const ready = this.client.isReady();
+        return Promise.resolve(guildIds.map((guildId) => {
+            const guild = this.client.guilds.cache.get(guildId);
+            return {
+                guildId,
+                state: !ready
+                    ? "unknown"
+                    : !guild
+                        ? "not_installed"
+                        : guild.available
+                            ? "installed"
+                            : "unavailable",
+                observedAt,
+            };
+        }));
+    }
     async getGuildResources(guildId) {
         try {
             const guild = await this.client.guilds.fetch(guildId);
@@ -107,13 +127,16 @@ export class DiscordGuildResourceDirectory {
             return {
                 channels: [...channels.values()]
                     .filter((channel) => channel?.type === ChannelType.GuildText ||
-                    channel?.type === ChannelType.GuildAnnouncement)
+                    channel?.type === ChannelType.GuildAnnouncement ||
+                    channel?.type === ChannelType.GuildCategory)
                     .map((channel) => ({
                     id: channel.id,
                     name: channel.name,
                     type: channel.type === ChannelType.GuildAnnouncement
                         ? "guild_announcement"
-                        : "guild_text",
+                        : channel.type === ChannelType.GuildCategory
+                            ? "guild_category"
+                            : "guild_text",
                 }))
                     .sort((left, right) => left.name.localeCompare(right.name)),
                 roles: [...roles.values()]
@@ -200,6 +223,8 @@ export class BotControlService {
     database;
     resources;
     supportNotifications;
+    presenceOwnership;
+    presenceShardCount;
     #modules;
     #dashboardModules;
     #configurations;
@@ -207,10 +232,12 @@ export class BotControlService {
     #permissions;
     #services;
     #privacyProviders;
-    constructor(database, modules, resources, services, privacyExecutor, supportNotifications) {
+    constructor(database, modules, resources, services, privacyExecutor, supportNotifications, presenceOwnership, presenceShardCount) {
         this.database = database;
         this.resources = resources;
         this.supportNotifications = supportNotifications;
+        this.presenceOwnership = presenceOwnership;
+        this.presenceShardCount = presenceShardCount;
         this.#modules = new Map(modules.map((module) => [module.manifest.id, module]));
         this.#dashboardModules = modules
             .filter((module) => module.manifest.dashboard !== undefined)
@@ -223,11 +250,45 @@ export class BotControlService {
             ? modules
                 .filter((module) => module.privacy !== undefined)
                 .map((module) => {
-                const provider = module.privacy.create(privacyExecutor);
+                const provider = module.privacy.create(privacyExecutor, this.#services);
                 return [provider.id, provider];
             })
             : []);
     }
+    async listGuildPresence(input) {
+        const guildIds = [...new Set(input.guildIds)];
+        if (guildIds.length > 200)
+            throw new BotControlValidationError("Guild presence requests cannot exceed 200 guilds");
+        const observations = await this.resources.listGuildPresence(guildIds);
+        const returned = new Set(observations.map(({ guildId }) => guildId));
+        const complete = guildIds.map((guildId) => observations.find((item) => item.guildId === guildId) ?? {
+            guildId,
+            state: "unknown",
+            observedAt: new Date().toISOString(),
+        });
+        if (observations.some(({ guildId }) => !guildIds.includes(guildId)) ||
+            returned.size !== observations.length)
+            throw new BotControlTransportError(502, "The guild presence response was invalid");
+        const absent = complete
+            .filter(({ state }) => state === "not_installed")
+            .map(({ guildId }) => guildId);
+        if (absent.length > 0) {
+            const repository = new InstallationRepository(this.database);
+            if (this.presenceOwnership)
+                await repository.adoptGuildsForReconciliation({
+                    guildIds: absent,
+                    ownership: this.presenceOwnership,
+                    shardCount: this.presenceShardCount,
+                });
+            await repository.markGuildsRemovedForReconciliation({
+                guildIds: absent,
+                ...(this.presenceOwnership
+                    ? { ownership: this.presenceOwnership }
+                    : {}),
+            });
+        }
+        return complete;
+    }
     async sendSupportNotification(input) {
         if (!this.supportNotifications)
             throw new BotControlNotFoundError("The support notification channel is not configured");
@@ -262,6 +323,15 @@ export class BotControlService {
             },
         }, input.notificationId);
     }
+    acceptVerificationResult(envelopeInput) {
+        if (!this.#services.has(HELYX_SERVICE_NAMES.verification))
+            throw new BotControlTransportError(503, "Verification result handling is unavailable");
+        const envelope = signedAssessmentEnvelopeSchema.parse(envelopeInput);
+        return this.#services
+            .get(HELYX_SERVICE_NAMES.verification)
+            .acceptResult(envelope)
+            .then((receipt) => actionReceiptSchema.parse(receipt));
+    }
     listPrivacyProviders() {
         return Promise.resolve([...this.#privacyProviders.values()]
             .map((provider) => ({
@@ -290,10 +360,11 @@ export class BotControlService {
         });
     }
     async getGuildState(guildId) {
-        const [resources, installedModules, storedLoggingPolicies] = await Promise.all([
+        const [resources, installedModules, storedLoggingPolicies, runtime] = await Promise.all([
             this.resources.getGuildResources(guildId),
             new InstallationRepository(this.database).listModules(guildId),
             new ModuleLoggingPolicyRepository(this.database).listForGuild(guildId),
+            this.#inspectRuntimeCapabilities(),
         ]);
         const installed = new Map(installedModules.map((module) => [module.moduleId, module]));
         const moduleStatuses = {};
@@ -332,6 +403,9 @@ export class BotControlService {
             });
         }));
         return {
+            discordCapabilities: {
+                messageContent: runtime.messageContent,
+            },
             ...resources,
             modules: structuredClone(this.#dashboardModules),
             moduleStatuses,
@@ -340,9 +414,42 @@ export class BotControlService {
             logging,
         };
     }
+    async canAccessManagedResource(input) {
+        try {
+            const { module } = await this.#prepareManagedResource(input);
+            this.#requireManagedResourceOperation(module, input.resourceType, input.operation);
+            await this.#authorizeAction(input.guildId, module, input.actorUserId, managedResourcePermissionId(module, input.resourceType, input.operation));
+            return true;
+        }
+        catch (error) {
+            if (error instanceof BotControlForbiddenError)
+                return false;
+            throw error;
+        }
+    }
+    async #inspectRuntimeCapabilities() {
+        if (!this.#services.has(HELYX_SERVICE_NAMES.discordResources))
+            return { messageContent: false };
+        const inspector = this.#services.get(HELYX_SERVICE_NAMES.discordResources);
+        if (typeof inspector.inspectRuntimeCapabilities !== "function")
+            return { messageContent: false };
+        const runtime = await inspector.inspectRuntimeCapabilities();
+        return { messageContent: runtime.messageContent };
+    }
     async setModuleStatus(input) {
-        this.#requireDashboardModule(input.moduleId);
-        await this.#installations.setModuleEnabled({
+        const module = this.#requireDashboardModule(input.moduleId);
+        const scopes = Object.entries(module.records ?? {})
+            .filter(([, collection]) => (collection.incrementableFields?.length ?? 0) > 0)
+            .map(([collection]) => ({
+            moduleId: input.moduleId,
+            collection,
+            guildId: input.guildId,
+        }));
+        const writeBehind = scopes.length > 0 &&
+            this.#services.has(HELYX_SERVICE_NAMES.numericWriteBehind)
+            ? this.#services.get(HELYX_SERVICE_NAMES.numericWriteBehind)
+            : null;
+        const setEnabled = () => this.#installations.setModuleEnabled({
             guildId: input.guildId,
             moduleId: input.moduleId,
             enabled: input.enabled,
@@ -352,11 +459,56 @@ export class BotControlService {
                 source: "dashboard",
             },
         });
+        if (!writeBehind) {
+            await setEnabled();
+        }
+        else if (input.enabled) {
+            for (const scope of scopes) {
+                const suppression = await writeBehind.suppressGuild(scope);
+                await writeBehind.releaseGuild({
+                    ...scope,
+                    suppressionId: suppression.suppressionId,
+                });
+            }
+            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);
+            for (const scope of scopes)
+                await writeBehind.flushGuild(scope);
+            for (const scope of scopes)
+                await writeBehind.suppressGuild(scope);
+        }
         return this.getGuildState(input.guildId);
     }
     async updateConfiguration(input) {
         const module = this.#requireDashboardModule(input.moduleId);
         await this.#validateDiscordSettings(input.guildId, module, input.value);
+        if (module.configuration?.validateUpdate) {
+            try {
+                const value = module.configuration.validate(input.value);
+                await module.configuration.validateUpdate({
+                    guildId: input.guildId,
+                    value,
+                    services: this.#services,
+                });
+            }
+            catch (error) {
+                if (error instanceof ModuleStateValidationError)
+                    throw error;
+                throw new DashboardActionValidationError(error instanceof Error
+                    ? error.message
+                    : "The module rejected these settings.");
+            }
+        }
         const saved = await this.#configurations.update({
             guildId: input.guildId,
             moduleId: input.moduleId,
@@ -603,15 +755,13 @@ export class BotControlService {
         }));
     }
     async executeManagedResourceAction(input) {
-        const module = this.#requireDashboardModule(input.moduleId);
+        const { module, resource } = await this.#prepareManagedResource(input);
         const declared = module.manifest.dashboard?.resources
             ?.find(({ id }) => id === input.resourceType)
             ?.actions?.find(({ id }) => id === input.actionId);
-        const resource = this.#requireManagedResource(module, input.resourceType);
         this.#requireManagedResourceOperation(module, input.resourceType, "action");
         if (!declared)
             throw new BotControlNotFoundError("Managed resource action is not declared by this module");
-        await this.#requireEnabledManagedResource(input.guildId, input.moduleId);
         const permissionId = managedResourcePermissionId(module, input.resourceType, "action", input.actionId, declared.permissionId);
         const context = await this.#managedResourceContext(input, module, "action", permissionId);
         validateManagedResourceActionValue(declared.inputs ?? [], input.value);
@@ -628,7 +778,8 @@ export class BotControlService {
     async #prepareManagedResource(input) {
         const module = this.#requireDashboardModule(input.moduleId);
         const resource = this.#requireManagedResource(module, input.resourceType);
-        await this.#requireEnabledManagedResource(input.guildId, input.moduleId);
+        if (!resource.availableWhileDisabled)
+            await this.#requireEnabledManagedResource(input.guildId, input.moduleId);
         return { module, resource };
     }
     #requireManagedResource(module, resourceType) {
@@ -667,6 +818,10 @@ export class BotControlService {
         return {
             guildId: input.guildId,
             actor,
+            ...("actorAuthenticatedAt" in input &&
+                typeof input.actorAuthenticatedAt === "string"
+                ? { actorAuthenticatedAt: input.actorAuthenticatedAt }
+                : {}),
             correlationId: input.correlationId,
             services: this.#services,
             sendToChannel: (channelId, response) => this.resources.sendToChannel(channelId, response),
@@ -734,14 +889,25 @@ export class BotControlService {
             if (setting.type === "discord-channel") {
                 if (configured === "" || configured === undefined)
                     continue;
-                const channel = typeof configured === "string" ? channels.get(configured) : null;
-                if (!channel || !setting.channelTypes.includes(channel.type))
-                    throw new BotControlValidationError(`${setting.label} must be an available supported Discord channel`);
+                if (Boolean(setting.multiple) !== Array.isArray(configured))
+                    throw new BotControlValidationError(`${setting.label} has an invalid Discord channel selection`);
+                const configuredChannels = Array.isArray(configured)
+                    ? configured
+                    : [configured];
+                if (configuredChannels.length > MAX_DISCORD_SETTING_SELECTIONS ||
+                    new Set(configuredChannels).size !== configuredChannels.length ||
+                    configuredChannels.some((channelId) => {
+                        if (typeof channelId !== "string")
+                            return true;
+                        const channel = channels.get(channelId);
+                        return !channel || !setting.channelTypes.includes(channel.type);
+                    }))
+                    throw new BotControlValidationError(`${setting.label} must contain available supported Discord channels`);
             }
             if (setting.type === "discord-role") {
                 if (configured === "" || configured === undefined)
                     continue;
-                if (setting.multiple !== Array.isArray(configured))
+                if (Boolean(setting.multiple) !== Array.isArray(configured))
                     throw new BotControlValidationError(`${setting.label} has an invalid Discord role selection`);
                 const configuredRoles = Array.isArray(configured)
                     ? configured
@@ -810,6 +976,7 @@ 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.get("/v1/shards/health", async (request, reply) => {
         reply.header("Cache-Control", "no-store");
         if (!input.shardHealth)
@@ -874,6 +1041,18 @@ export async function createBotControlServer(input) {
         await input.service.sendSupportNotification(body);
         return reply.code(204).send();
     });
+    server.post("/v1/guilds/presence", async (request) => {
+        const body = z
+            .object({
+            guildIds: z.array(snowflake).min(1).max(200),
+            correlationId: z.uuid(),
+        })
+            .strict()
+            .parse(request.body);
+        return {
+            items: await input.service.listGuildPresence(body),
+        };
+    });
     server.post("/v1/privacy/capture", async (request) => {
         const body = z
             .object({
@@ -882,11 +1061,13 @@ export async function createBotControlServer(input) {
             requestId: z.uuid(),
             subjectUserId: snowflake,
             cutoffAt: z.coerce.date(),
+            operation: z.enum(["capture", "residual_scan"]).optional(),
             cursor: z.string().min(1).max(2_048).optional(),
         })
             .strict()
             .parse(request.body);
-        const { cursor, ...value } = body;
+        const { cursor, operation: _operation, ...value } = body;
+        void _operation;
         return input.service.capturePrivacy({
             ...value,
             ...(cursor ? { cursor } : {}),
@@ -914,6 +1095,28 @@ export async function createBotControlServer(input) {
         const { guildId } = z.object({ guildId: snowflake }).parse(request.params);
         return input.service.getGuildState(guildId);
     });
+    server.post("/v1/guilds/:guildId/modules/:moduleId/resources/:resourceType/access", async (request) => {
+        const params = z
+            .object({
+            guildId: snowflake,
+            moduleId,
+            resourceType: z.string().regex(/^[a-z][a-z0-9-]*$/u),
+        })
+            .parse(request.params);
+        const body = z
+            .object({
+            operation: z.enum(["list", "read"]),
+            actorUserId: snowflake,
+        })
+            .strict()
+            .parse(request.body);
+        return {
+            allowed: await input.service.canAccessManagedResource({
+                ...params,
+                ...body,
+            }),
+        };
+    });
     server.put("/v1/guilds/:guildId/modules/:moduleId/status", async (request) => {
         const params = z
             .object({ guildId: snowflake, moduleId })
@@ -1101,12 +1304,19 @@ export async function createBotControlServer(input) {
             .extend({
             expectedRevision: z.number().int().min(0),
             value: managedResourceObject.optional().default({}),
+            actorAuthenticatedAt: z.iso.datetime({ offset: true }).optional(),
         })
             .strict()
             .parse(request.body);
         return input.service.executeManagedResourceAction({
             ...params,
-            ...body,
+            actorUserId: body.actorUserId,
+            correlationId: body.correlationId,
+            expectedRevision: body.expectedRevision,
+            value: body.value,
+            ...(body.actorAuthenticatedAt === undefined
+                ? {}
+                : { actorAuthenticatedAt: body.actorAuthenticatedAt }),
         });
     });
     server.put("/v1/guilds/:guildId/modules/:moduleId/configuration", async (request) => {