@helyx/bot 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import { parseBotEnvironment } from "@helyx/config";
 import { StatusHeartbeatReporter } from "@helyx/status-client";
 import { safeError, ServiceRegistry } from "@helyx/core";
-import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, HostedServerSafetyRepository, InteractionSessionRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
+import { checkDatabaseConnection, createDatabasePool, AuditRepository, GuildCommandRepository, HostedServerSafetyRepository, InteractionSessionRepository, EckoOperationsRepository, PremiumAllocationRepository, RateLimitRepository, runCoreMigrations, runConfiguredModuleMigrations, } from "@helyx/database";
 import { createRuntime } from "@helyx/framework";
 import { createPlatformServices, gamingStatisticsRecordOwner, achievementContributionRecordOwner, PostgresPrivacyProviderExecutor, PlatformMemberRoleGrantOwnershipService, PostgresMemberRoleGrantOwnershipStore, } from "@helyx/platform";
 import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
@@ -19,9 +19,10 @@ import { loadConfiguredModulePackages, platformServiceOptions, } from "./modules
 import { resolveModulePackageSpecifiers } from "./module-configuration.js";
 import { createPermissionsModule } from "./permissions-module.js";
 import { createManagementModule } from "./management-module.js";
-import { DiscordMessageDeliveryService, DiscordMemberEnforcementService, DiscordMemberRoleService, DiscordVerificationMemberService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordMessageDeliveryService, DiscordMemberRoleService, DiscordVerificationMemberService, DiscordResourceInspection, installModuleEvents, } from "./events.js";
+import { DiscordModerationMemberEnforcementAdapter } from "./discord-member-enforcement-service.js";
 import { DiscordModuleLoggingService } from "./module-logging.js";
-import { BotControlService, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
+import { BotControlService, BotControlTransportError, createBotControlServer, DiscordGuildResourceDirectory, } from "./control-server.js";
 import { HttpVerificationService } from "./verification-service.js";
 import { startShardSupervisor } from "./shard-supervisor.js";
 import { parseShardWorkerLaunchContract, startShardWorker, } from "./shard-worker.js";
@@ -30,6 +31,9 @@ import { shardHealthSnapshotSchema, } from "./shard-contracts.js";
 import { createSupportModule } from "./support-module.js";
 import { createOAuthModule } from "./oauth-module.js";
 import { createPrivacyModule } from "./privacy-module.js";
+import { installModerationPlatformServices } from "./moderation-platform-services.js";
+import { EckoEvidenceReceiver } from "./ecko-evidence-receiver.js";
+import { EckoTransportAuthenticator } from "./ecko-transport-auth.js";
 import { REVIEWED_PREMIUM_MODULE_IDS } from "@helyx/module-manifest";
 import { createPremiumActivationModule } from "./premium-activation-module.js";
 import { DiscordPremiumGuildAuthority } from "./premium-guild-authority.js";
@@ -120,8 +124,10 @@ async function startUnshardedBot(processEnvironment) {
         sslMode: environment.DATABASE_SSL,
         applicationName: "helyx-bot",
     });
+    const hostedOwnerObserver = new PostgresHostedGuildSafety(database);
+    const eckoOperations = new EckoOperationsRepository(database);
     const hostedSafety = environment.HELYX_HOSTED_MODERATION_ENABLED
-        ? new PostgresHostedGuildSafety(database)
+        ? hostedOwnerObserver
         : undefined;
     const developerModeration = environment.HELYX_HOSTED_MODERATION_ENABLED
         ? new HostedServerModerationClient(environment.HELYX_CLOUD_API_URL, environment.HELYX_BOT_CONTROL_SECRET)
@@ -226,7 +232,7 @@ async function startUnshardedBot(processEnvironment) {
         premiumCatalogueTimer.unref();
         const client = new Client({
             rest: discordRestOptions,
-            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED),
+            intents: gatewayIntentsForModules(featureModules, environment.HELYX_MESSAGE_CONTENT_ENABLED, environment.HELYX_GUILD_MEMBERS_ENABLED, environment.HELYX_RUNTIME_PROFILE),
             partials: [Partials.Message, Partials.Channel, Partials.Reaction],
             allowedMentions: { parse: [] },
         });
@@ -390,11 +396,26 @@ async function startUnshardedBot(processEnvironment) {
         platformServices.set(HELYX_SERVICE_NAMES.resourceAuthorization, new CoreResourceAuthorizationService(platformServices.get(HELYX_SERVICE_NAMES.permissions)));
         platformServices.set(HELYX_SERVICE_NAMES.discordMessages, new DiscordMessageDeliveryService(client));
         platformServices.set(HELYX_SERVICE_NAMES.discordOwnedMessages, new DiscordOwnedMessageDeletionService(client));
-        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordMemberEnforcementService(client));
+        platformServices.set(HELYX_SERVICE_NAMES.memberEnforcement, new DiscordModerationMemberEnforcementAdapter(client));
         const memberRoles = new DiscordMemberRoleService(client);
         platformServices.set(HELYX_SERVICE_NAMES.memberRoles, memberRoles);
         platformServices.set(HELYX_SERVICE_NAMES.memberRoleGrants, new PlatformMemberRoleGrantOwnershipService(new PostgresMemberRoleGrantOwnershipStore(database), memberRoles));
         platformServices.set(HELYX_SERVICE_NAMES.discordResources, new DiscordResourceInspection(client));
+        const moderationPlatformServices = await installModerationPlatformServices({
+            services: platformServices,
+            serviceAccess,
+            client,
+            modules: publicModules,
+            runtimeProfile: environment.HELYX_RUNTIME_PROFILE,
+            deploymentEnvironment: environment.HELYX_DEPLOYMENT_ENVIRONMENT,
+            embedded: {
+                workers: environment.HELYX_AUTOMOD_EMBEDDED_WORKERS,
+                maximumItems: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_ITEMS,
+                maximumBytes: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_BYTES,
+                maximumItemsPerGuild: environment.HELYX_AUTOMOD_EMBEDDED_QUEUE_ITEMS_PER_GUILD,
+                refreshIntervalMs: environment.HELYX_AUTOMOD_EMBEDDED_REFRESH_SECONDS * 1_000,
+            },
+        });
         platformServices.set(HELYX_SERVICE_NAMES.discordGuildHealth, new DiscordGuildHealthInspection(client, publicModules, serviceAccess));
         platformServices.set(HELYX_SERVICE_NAMES.discordAnalytics, new DiscordAnalyticsInspection(client));
         if (serviceOptions.inviteFingerprintKey)
@@ -416,10 +437,8 @@ async function startUnshardedBot(processEnvironment) {
             ...(cloudManagementModule ? [cloudManagementModule.manifest.id] : []),
             ...(operationsModule ? [operationsModule.manifest.id] : []),
         ]);
-        const prepareGuilds = installGuildTracking(client, database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID, hostedSafety, hostedInviteGate);
-        const hostedLeaveWorker = hostedSafety
-            ? new HostedServerLeaveWorker(database, client, bootstrapLogger)
-            : undefined;
+        const prepareGuilds = installGuildTracking(client, database, publicModules, bootstrapLogger, enabledCoreModuleIds, undefined, environment.HELYX_GUILD_RECONCILIATION_INTERVAL_SECONDS * 1_000, undefined, environment.DISCORD_CLIENT_ID, hostedSafety, hostedInviteGate, hostedOwnerObserver);
+        const hostedLeaveWorker = new HostedServerLeaveWorker(database, client, bootstrapLogger);
         const commandsReady = installInteractions(client, modules, {
             globalCommandMode: environment.HELYX_GLOBAL_COMMAND_MODE,
             ...(environment.DISCORD_INTERNAL_GUILD_ID
@@ -436,7 +455,10 @@ async function startUnshardedBot(processEnvironment) {
                 ...(operationsModule ? [operationsModule.manifest.id] : []),
             ]),
         }, bootstrapLogger, serviceAccess);
-        const moduleEvents = installModuleEvents(client, publicModules, bootstrapLogger, serviceAccess);
+        const moduleEvents = installModuleEvents(client, publicModules, bootstrapLogger, serviceAccess, {
+            runtimeProfile: environment.HELYX_RUNTIME_PROFILE,
+            evidenceStore: moderationPlatformServices.evidenceStore,
+        });
         const controlService = new BotControlService(database, [
             ...publicModules,
             gamingStatisticsRecordOwner,
@@ -498,6 +520,12 @@ async function startUnshardedBot(processEnvironment) {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "module_events.stop_failed", error: safeError(error) }, "Module event shutdown failed");
             });
+            await moderationPlatformServices.embeddedScanner
+                ?.stop()
+                .catch((error) => {
+                process.exitCode = 1;
+                bootstrapLogger.error({ event: "automod.embedded_stop_failed", error: safeError(error) }, "Embedded Auto Moderation scanner shutdown failed");
+            });
             await runtime.stop().catch((error) => {
                 process.exitCode = 1;
                 bootstrapLogger.error({ event: "runtime.stop_failed", error: safeError(error) }, "Runtime shutdown failed");
@@ -529,6 +557,11 @@ async function startUnshardedBot(processEnvironment) {
         process.once("SIGTERM", onSigterm);
         try {
             await runtime.start();
+            await moderationPlatformServices.embeddedScanner
+                ?.synchronize()
+                .catch((error) => {
+                bootstrapLogger.warn({ event: "automod.embedded_sync_failed", error: safeError(error) }, "Embedded Auto Moderation scanner started in Standard fallback");
+            });
             await client.login(environment.DISCORD_TOKEN);
             await commandsReady;
             hostedLeaveWorker?.start();
@@ -584,11 +617,38 @@ async function startUnshardedBot(processEnvironment) {
             }
             await cloudConnector.start();
             if (environment.HELYX_BOT_CONTROL_SECRET) {
+                const ecko = environment.HELYX_ECKO_TRANSPORT_SECRET
+                    ? {
+                        authenticator: new EckoTransportAuthenticator(environment.HELYX_DEPLOYMENT_ENVIRONMENT, [
+                            environment.HELYX_ECKO_TRANSPORT_SECRET,
+                            ...(environment.HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET
+                                ? [environment.HELYX_ECKO_TRANSPORT_PREVIOUS_SECRET]
+                                : []),
+                        ]),
+                        registry: moderationPlatformServices.scannerRegistry,
+                        evidence: new EckoEvidenceReceiver(moderationPlatformServices.evidenceStore, environment.HELYX_DEPLOYMENT_ENVIRONMENT, Buffer.from(environment.HELYX_ECKO_TRANSPORT_SECRET, "base64")),
+                        gateState: () => eckoOperations.readGate(),
+                        telemetry: {
+                            accept: (batch) => eckoOperations.acceptTelemetry(batch),
+                        },
+                    }
+                    : undefined;
                 controlServer = await createBotControlServer({
                     service: controlService,
                     secret: environment.HELYX_BOT_CONTROL_SECRET,
+                    deliverHostedServerLeave: (input) => hostedLeaveWorker.deliverOperation(input),
+                    refreshHostedServerOwner: async (guildId) => {
+                        const guild = client.guilds.cache.get(guildId);
+                        if (!guild)
+                            throw new BotControlTransportError(404, "The hosted server is not installed");
+                        return hostedOwnerObserver.refreshOwner(guild);
+                    },
                     logger: { level: environment.LOG_LEVEL },
+                    runtimeConfiguration: {
+                        hostedModerationEnabled: environment.HELYX_HOSTED_MODERATION_ENABLED,
+                    },
                     guildCommands: new GuildCommandReadService(database, environment.DISCORD_CLIENT_ID, () => guildCommandWorker?.getHealth(), environment.DISCORD_TOKEN, environment.HELYX_GUILD_COMMAND_WRITES_ENABLED, environment.HELYX_GUILD_COMMAND_WRITE_GUILD_IDS, environment.HELYX_GUILD_COMMAND_WRITE_SCOPE === "all", modules),
+                    ...(ecko ? { ecko } : {}),
                 });
                 await controlServer.listen({
                     host: "::",
@@ -667,7 +727,7 @@ function deploymentReference(processEnvironment) {
         processEnvironment.GIT_COMMIT_SHA;
     return value?.trim().slice(0, 12) || undefined;
 }
-export function gatewayIntentsForModules(modules, messageContentEnabled = false, guildMembersEnabled = false) {
+export function gatewayIntentsForModules(modules, messageContentEnabled = false, guildMembersEnabled = false, runtimeProfile = "hosted") {
     const intents = [GatewayIntentBits.Guilds];
     if (modules.some((module) => module.events?.messageReactionAdd?.length ||
         module.events?.messageReactionRemove?.length ||
@@ -675,8 +735,12 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false,
         module.events?.messageReactionRemoveEmoji?.length)) {
         intents.push(GatewayIntentBits.GuildMessageReactions);
     }
-    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.length);
-    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content"));
+    const hasPrivilegedMessageCreate = modules.some((module) => module.events?.privilegedMessageCreate?.some(({ featureId }) => !featureId || runtimeProfile === "self-hosted") ||
+        module.events?.privilegedMessageUpdate?.some(({ featureId }) => !featureId || runtimeProfile === "self-hosted"));
+    const requiresMessageContent = modules.some((module) => module.requiredDiscordCapabilities?.includes("message-content") ||
+        (runtimeProfile === "self-hosted" &&
+            module.manifest.manifestVersion === "0.5" &&
+            module.manifest.features.some((feature) => feature.requiredDiscordCapabilities.includes("message-content"))));
     if (((hasPrivilegedMessageCreate || requiresMessageContent) &&
         messageContentEnabled) ||
         modules.some((module) => module.events?.guildMessageCreate?.length ||
@@ -698,6 +762,12 @@ export function gatewayIntentsForModules(modules, messageContentEnabled = false,
     if (modules.some((module) => module.events?.guildVoiceSession?.length)) {
         intents.push(GatewayIntentBits.GuildVoiceStates);
     }
+    if (modules.some((module) => module.events?.discordAutoModerationRuleCreate?.length ||
+        module.events?.discordAutoModerationRuleUpdate?.length ||
+        module.events?.discordAutoModerationRuleDelete?.length))
+        intents.push(GatewayIntentBits.AutoModerationConfiguration);
+    if (modules.some((module) => module.events?.discordAutoModerationActionExecution?.length))
+        intents.push(GatewayIntentBits.AutoModerationExecution);
     if (modules.some((module) => module.events?.guildEmojiDelete?.length ||
         module.events?.guildEmojiUpdate?.length)) {
         intents.push(GatewayIntentBits.GuildExpressions);

package/dist/moderation-action-registry.d.ts

@@ -0,0 +1,11 @@
+import type { ModerationActionRegistryService, ModerationActionResultV2, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import type { DiscordViolationEvidenceDeliveryAdapter } from "./discord-violation-thread-service.js";
+/** Local closed registry. In sharded mode it is instantiated in each guild owner. */
+export declare class BotModerationActionRegistry implements ModerationActionRegistryService {
+    #private;
+    private readonly services;
+    private readonly evidenceDelivery?;
+    constructor(modules: readonly ModuleDefinition[], services: ServiceAccess, evidenceDelivery?: DiscordViolationEvidenceDeliveryAdapter | undefined);
+    execute(input: Parameters<ModerationActionRegistryService["execute"]>[0]): Promise<ModerationActionResultV2>;
+}
+//# sourceMappingURL=moderation-action-registry.d.ts.map

package/dist/moderation-action-registry.js

@@ -0,0 +1,375 @@
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE } from "@helyx/module-manifest";
+import { AUTOMOD_ENFORCEMENT_POLICY_CONTRACT_VERSION, AUTOMOD_ENFORCEMENT_POLICY_PROVIDER_ID, AUTOMOD_TIMEOUT_SECONDS, HELYX_SERVICE_NAMES, MODERATION_ACTION_CONTRACT_VERSION, MODERATION_ACTION_PROVIDER_ID, MODERATION_CONTRACT_LIMITS, } from "@helyx/sdk";
+const MODERATION_MODULE_ID = "helyx.moderation";
+const AUTOMOD_MODULE_ID = "helyx.automod";
+const ALLOWED_CALLER_MODULE_IDS = new Set([AUTOMOD_MODULE_ID]);
+const ID_PATTERN = /^\d{17,20}$/u;
+const OPERATION_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9:._/-]{0,199}$/u;
+const SAFE_CODE_PATTERN = /^[a-z0-9][a-z0-9._-]{0,99}$/u;
+/** Local closed registry. In sharded mode it is instantiated in each guild owner. */
+export class BotModerationActionRegistry {
+    services;
+    evidenceDelivery;
+    #actionProvider;
+    #policyProvider;
+    constructor(modules, services, evidenceDelivery) {
+        this.services = services;
+        this.evidenceDelivery = evidenceDelivery;
+        const actionProviders = modules.flatMap((module) => module.moderationActionProvider
+            ? [
+                {
+                    moduleId: module.manifest.id,
+                    provider: module.moderationActionProvider,
+                },
+            ]
+            : []);
+        if (actionProviders.length > 1)
+            throw new Error("Moderation action provider ownership is ambiguous");
+        const actionRegistration = actionProviders[0];
+        if (!actionRegistration) {
+            this.#actionProvider = null;
+        }
+        else {
+            if (actionRegistration.moduleId !== MODERATION_MODULE_ID ||
+                actionRegistration.provider.providerId !==
+                    MODERATION_ACTION_PROVIDER_ID ||
+                actionRegistration.provider.contractVersion !==
+                    MODERATION_ACTION_CONTRACT_VERSION ||
+                actionRegistration.provider.allowedCallerModuleIds.length < 1 ||
+                new Set(actionRegistration.provider.allowedCallerModuleIds).size !==
+                    actionRegistration.provider.allowedCallerModuleIds.length ||
+                actionRegistration.provider.allowedCallerModuleIds.some((moduleId) => !ALLOWED_CALLER_MODULE_IDS.has(moduleId)))
+                throw new Error("Moderation action provider registration is invalid");
+            this.#actionProvider = actionRegistration.provider;
+        }
+        const policyProviders = modules.flatMap((module) => module.autoModerationEnforcementPolicyProvider
+            ? [
+                {
+                    moduleId: module.manifest.id,
+                    provider: module.autoModerationEnforcementPolicyProvider,
+                },
+            ]
+            : []);
+        if (policyProviders.length > 1)
+            throw new Error("Auto Moderation policy provider ownership is ambiguous");
+        const policyRegistration = policyProviders[0];
+        if (!policyRegistration) {
+            this.#policyProvider = null;
+        }
+        else {
+            if (policyRegistration.moduleId !== AUTOMOD_MODULE_ID ||
+                policyRegistration.provider.providerId !==
+                    AUTOMOD_ENFORCEMENT_POLICY_PROVIDER_ID ||
+                policyRegistration.provider.contractVersion !==
+                    AUTOMOD_ENFORCEMENT_POLICY_CONTRACT_VERSION)
+                throw new Error("Auto Moderation policy provider registration is invalid");
+            this.#policyProvider = policyRegistration.provider;
+        }
+    }
+    async execute(input) {
+        if (!this.#actionProvider ||
+            !this.#policyProvider ||
+            input.providerId !== MODERATION_ACTION_PROVIDER_ID ||
+            input.contractVersion !== MODERATION_ACTION_CONTRACT_VERSION)
+            return rejected("module_unavailable");
+        if (input.callerModuleId !== input.request.callerModuleId ||
+            !ALLOWED_CALLER_MODULE_IDS.has(input.callerModuleId) ||
+            !this.#actionProvider.allowedCallerModuleIds.includes(input.callerModuleId))
+            return rejected("caller_not_allowed");
+        if (!isValidRequest(input.request))
+            return rejected("invalid_request");
+        const installations = this.services.get(HELYX_SERVICE_NAMES.installations);
+        const availability = this.services.has(HELYX_SERVICE_NAMES.moduleAvailability)
+            ? this.services.get(HELYX_SERVICE_NAMES.moduleAvailability)
+            : null;
+        try {
+            const modulesAvailable = (await installations.isModuleEnabled(input.request.guildId, MODERATION_MODULE_ID)) &&
+                (await installations.isModuleEnabled(input.request.guildId, input.callerModuleId)) &&
+                (!availability ||
+                    ((await availability.isAvailable(MODERATION_MODULE_ID)) &&
+                        (await availability.isAvailable(input.callerModuleId))));
+            if (!modulesAvailable)
+                return rejected("module_unavailable");
+            if (input.request.detectionSource === "enhanced" &&
+                !(await enhancedFeatureAllowed(this.services, input.request.guildId)))
+                return rejected("feature_unavailable");
+            const policyContext = { services: this.services };
+            const resolution = await this.#policyProvider.resolve(policyContext, input.request);
+            if (resolution.outcome === "rejected")
+                return rejected(mapPolicyRejection(resolution.code));
+            if (!isValidPolicy(resolution))
+                return rejected("invalid_request");
+            if (resolution.configurationRevision !== input.request.configurationRevision)
+                return rejected("stale_revision");
+            const policy = copyPolicy(resolution);
+            const evidenceClaims = {
+                caseIds: new Set(),
+                threadIds: new Set(),
+            };
+            const requestServices = createRequestBoundServices(this.services, evidenceClaims);
+            return await this.#actionProvider.execute({
+                services: requestServices,
+                violationEvidence: {
+                    deliver: async (delivery) => {
+                        if (!input.request.evidenceReference ||
+                            delivery.guildId !== input.request.guildId ||
+                            !ID_PATTERN.test(delivery.threadId) ||
+                            !OPERATION_KEY_PATTERN.test(delivery.caseId) ||
+                            !OPERATION_KEY_PATTERN.test(delivery.operationKey) ||
+                            !evidenceClaims.caseIds.has(delivery.caseId) ||
+                            !evidenceClaims.threadIds.has(delivery.threadId))
+                            return { outcome: "evidence_unavailable" };
+                        if (!this.evidenceDelivery)
+                            return { outcome: "evidence_unavailable" };
+                        return await this.evidenceDelivery.deliverEvidence({
+                            guildId: delivery.guildId,
+                            threadId: delivery.threadId,
+                            evidenceReference: input.request.evidenceReference,
+                            operationKey: delivery.operationKey,
+                        });
+                    },
+                },
+            }, {
+                ...input.request,
+                policy,
+                revalidatePolicy: async () => {
+                    try {
+                        const current = await this.#policyProvider?.resolve(policyContext, input.request);
+                        return Boolean(current &&
+                            current.outcome === "eligible" &&
+                            isValidPolicy(current) &&
+                            samePolicy(policy, current) &&
+                            (input.request.detectionSource !== "enhanced" ||
+                                (await enhancedFeatureAllowed(this.services, input.request.guildId))));
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            });
+        }
+        catch {
+            return rejected("module_unavailable");
+        }
+    }
+}
+function isValidRequest(request) {
+    return (OPERATION_KEY_PATTERN.test(request.operationKey) &&
+        (request.detectionSource === "native" ||
+            request.detectionSource === "enhanced") &&
+        ID_PATTERN.test(request.guildId) &&
+        ID_PATTERN.test(request.subjectUserId) &&
+        OPERATION_KEY_PATTERN.test(request.sourceEventId) &&
+        request.occurredAt instanceof Date &&
+        !Number.isNaN(request.occurredAt.getTime()) &&
+        OPERATION_KEY_PATTERN.test(request.ruleId) &&
+        request.configurationRevision.length > 0 &&
+        request.configurationRevision.length <= 200 &&
+        SAFE_CODE_PATTERN.test(request.reasonCode) &&
+        ["low", "medium", "high", "critical"].includes(request.severity) &&
+        ["exact", "native_equivalent", "high", "medium", "low"].includes(request.confidenceClass) &&
+        (request.sourceMessage === null ||
+            (ID_PATTERN.test(request.sourceMessage.channelId) &&
+                (request.sourceMessage.messageId === null ||
+                    ID_PATTERN.test(request.sourceMessage.messageId)))) &&
+        isValidEvidenceReference(request) &&
+        ((request.requestKind === "detection" &&
+            request.observedAction === undefined) ||
+            (request.requestKind === "observation" &&
+                isValidObservedAction(request.observedAction))));
+}
+function isValidObservedAction(action) {
+    if (!action || typeof action !== "object" || !("type" in action))
+        return false;
+    return (action.type === "discord_native_block_message" ||
+        (action.type === "discord_native_timeout" &&
+            AUTOMOD_TIMEOUT_SECONDS.includes(action.durationSeconds)));
+}
+/**
+ * The Moderation provider gets request-scoped views of the two services that
+ * establish the case and thread. Evidence delivery is then limited to IDs
+ * returned by those services during this exact action invocation.
+ */
+function createRequestBoundServices(services, claims) {
+    return {
+        has: (name) => services.has(name),
+        get: (name) => {
+            if (name === HELYX_SERVICE_NAMES.atomicModerationCases) {
+                const service = services.get(name);
+                const bound = {
+                    createPendingCase: async (input) => {
+                        const result = await service.createPendingCase(input);
+                        if (result.outcome === "created" || result.outcome === "replayed")
+                            claims.caseIds.add(result.caseId);
+                        return result;
+                    },
+                    createConfirmedAutoModerationOffenceCase: async (input) => {
+                        const result = await service.createConfirmedAutoModerationOffenceCase(input);
+                        if (result.outcome === "created" || result.outcome === "replayed")
+                            claims.caseIds.add(result.caseId);
+                        return result;
+                    },
+                    createAdditionalPendingAttempt: (input) => service.createAdditionalPendingAttempt(input),
+                    createCorrectionCase: (input) => service.createCorrectionCase(input),
+                    settleActionAttempt: (input) => service.settleActionAttempt(input),
+                    recordObservedAction: (input) => service.recordObservedAction(input),
+                    listReconciliationCandidates: (input) => service.listReconciliationCandidates(input),
+                    disassociateCase: (input) => service.disassociateCase(input),
+                    executeRetention: (input) => service.executeRetention(input),
+                };
+                return bound;
+            }
+            if (name === HELYX_SERVICE_NAMES.violationThreads) {
+                const service = services.get(name);
+                const bound = {
+                    inspectConfiguration: (input) => service.inspectConfiguration(input),
+                    createAccessRole: (input) => service.createAccessRole(input),
+                    configureParent: (input) => service.configureParent(input),
+                    create: async (input) => {
+                        const result = await service.create(input);
+                        if (result.outcome === "created" ||
+                            result.outcome === "already_exists")
+                            claims.threadIds.add(result.threadId);
+                        return result;
+                    },
+                    addMember: (input) => service.addMember(input),
+                    removeMember: (input) => service.removeMember(input),
+                    send: (input) => service.send(input),
+                    close: (input) => service.close(input),
+                    reconcile: (input) => service.reconcile(input),
+                };
+                return bound;
+            }
+            return services.get(name);
+        },
+    };
+}
+function isValidPolicy(policy) {
+    return (policy.policyFingerprint.length > 0 &&
+        policy.policyFingerprint.length <= 200 &&
+        Number.isSafeInteger(policy.ruleRevision) &&
+        policy.ruleRevision > 0 &&
+        policy.configurationRevision.length > 0 &&
+        policy.configurationRevision.length <= 200 &&
+        policy.windowStartsAt instanceof Date &&
+        !Number.isNaN(policy.windowStartsAt.getTime()) &&
+        typeof policy.openViolationThread === "boolean" &&
+        validRoleIds(policy.globalIgnoredRoleIds, MODERATION_CONTRACT_LIMITS.ignoredRolesPerScope) &&
+        validRoleIds(policy.ruleIgnoredRoleIds, MODERATION_CONTRACT_LIMITS.ignoredRolesPerScope) &&
+        Boolean(policy.actionPolicy) &&
+        isValidAction(policy.actionPolicy.first) &&
+        isValidAction(policy.actionPolicy.second) &&
+        isValidAction(policy.actionPolicy.thirdAndLater));
+}
+function isValidAction(action) {
+    if (!action || typeof action !== "object" || !("type" in action))
+        return false;
+    switch (action.type) {
+        case "case_only":
+        case "delete_message":
+        case "warn":
+        case "kick":
+            return true;
+        case "timeout":
+            return AUTOMOD_TIMEOUT_SECONDS.includes(action.durationSeconds);
+        case "ban":
+            return [0, 3_600, 21_600, 86_400, 259_200, 604_800].includes(action.deleteMessageSeconds);
+        case "demote":
+            return (action.roleIds.length > 0 &&
+                validRoleIds(action.roleIds, MODERATION_CONTRACT_LIMITS.automaticDemotionRoles));
+    }
+}
+function isValidEvidenceReference(request) {
+    const reference = request.evidenceReference;
+    if (!reference)
+        return true;
+    if (reference.key.trim().length < 1 ||
+        reference.key.length > 160 ||
+        reference.sourceEventId !== request.sourceEventId ||
+        reference.guildId !== request.guildId ||
+        reference.authorUserId !== request.subjectUserId ||
+        request.sourceMessage === null ||
+        reference.channelId !== request.sourceMessage.channelId ||
+        reference.messageId !== request.sourceMessage.messageId)
+        return false;
+    return (reference.source === "discord_auto_moderation" ||
+        (reference.source === "enhanced_scanner" &&
+            reference.configurationRevision === request.configurationRevision));
+}
+function validRoleIds(roleIds, maximum) {
+    return (roleIds.length <= maximum &&
+        new Set(roleIds).size === roleIds.length &&
+        roleIds.every((roleId) => ID_PATTERN.test(roleId)));
+}
+function copyPolicy(policy) {
+    return {
+        ...policy,
+        windowStartsAt: new Date(policy.windowStartsAt),
+        globalIgnoredRoleIds: Object.freeze([...policy.globalIgnoredRoleIds]),
+        ruleIgnoredRoleIds: Object.freeze([...policy.ruleIgnoredRoleIds]),
+        actionPolicy: Object.freeze({
+            first: copyAction(policy.actionPolicy.first),
+            second: copyAction(policy.actionPolicy.second),
+            thirdAndLater: copyAction(policy.actionPolicy.thirdAndLater),
+        }),
+    };
+}
+function copyAction(action) {
+    return action.type === "demote"
+        ? { ...action, roleIds: Object.freeze([...action.roleIds]) }
+        : { ...action };
+}
+function samePolicy(expected, current) {
+    return (expected.policyFingerprint === current.policyFingerprint &&
+        expected.ruleRevision === current.ruleRevision &&
+        expected.configurationRevision === current.configurationRevision &&
+        expected.windowStartsAt.getTime() === current.windowStartsAt.getTime() &&
+        expected.openViolationThread === current.openViolationThread &&
+        sameStrings(expected.globalIgnoredRoleIds, current.globalIgnoredRoleIds) &&
+        sameStrings(expected.ruleIgnoredRoleIds, current.ruleIgnoredRoleIds) &&
+        sameAction(expected.actionPolicy.first, current.actionPolicy.first) &&
+        sameAction(expected.actionPolicy.second, current.actionPolicy.second) &&
+        sameAction(expected.actionPolicy.thirdAndLater, current.actionPolicy.thirdAndLater));
+}
+function sameAction(expected, current) {
+    if (expected.type !== current.type)
+        return false;
+    if (expected.type === "timeout" && current.type === "timeout")
+        return expected.durationSeconds === current.durationSeconds;
+    if (expected.type === "ban" && current.type === "ban")
+        return expected.deleteMessageSeconds === current.deleteMessageSeconds;
+    if (expected.type === "demote" && current.type === "demote")
+        return sameStrings(expected.roleIds, current.roleIds);
+    return true;
+}
+function sameStrings(expected, current) {
+    return (expected.length === current.length &&
+        expected.every((value, index) => value === current[index]));
+}
+function mapPolicyRejection(code) {
+    switch (code) {
+        case "source_unresolved":
+            return "invalid_request";
+        case "source_exempt":
+            return "subject_exempt";
+        default:
+            return code;
+    }
+}
+async function enhancedFeatureAllowed(services, guildId) {
+    if (!services.has(HELYX_SERVICE_NAMES.featureAccess))
+        return false;
+    const access = await services
+        .get(HELYX_SERVICE_NAMES.featureAccess)
+        .check({
+        guildId,
+        moduleId: AUTOMOD_MODULE_ID,
+        featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+    })
+        .catch(() => ({ decision: "dependency_unhealthy" }));
+    return access.decision === "granted";
+}
+function rejected(code) {
+    return { outcome: "rejected", code };
+}
+//# sourceMappingURL=moderation-action-registry.js.map

package/dist/moderation-case-disassociation.d.ts

@@ -0,0 +1,13 @@
+import { type AtomicModerationCaseService, type ModuleDefinition, type ServiceAccess } from "@helyx/sdk";
+/** Adds Auto Moderation unlinking after the authoritative case transition. */
+export declare function decorateModerationCaseDisassociation(input: {
+    modules: readonly ModuleDefinition[];
+    services: ServiceAccess;
+    service: AtomicModerationCaseService;
+}): AtomicModerationCaseService;
+export declare function installModerationCaseDisassociation(input: {
+    modules: readonly ModuleDefinition[];
+    services: Map<string, unknown>;
+    serviceAccess: ServiceAccess;
+}): void;
+//# sourceMappingURL=moderation-case-disassociation.d.ts.map