@helyx/bot 1.0.1 → 1.2.0

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

package/dist/moderation-case-disassociation.js

@@ -0,0 +1,83 @@
+import { AUTOMOD_CASE_LINK_CONTRACT_VERSION, AUTOMOD_CASE_LINK_PROVIDER_ID, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+const AUTOMOD_MODULE_ID = "helyx.automod";
+/** Adds Auto Moderation unlinking after the authoritative case transition. */
+export function decorateModerationCaseDisassociation(input) {
+    const provider = caseLinkProvider(input.modules);
+    if (!provider)
+        return input.service;
+    const service = input.service;
+    return {
+        createPendingCase: (request) => service.createPendingCase(request),
+        createConfirmedAutoModerationOffenceCase: (request) => service.createConfirmedAutoModerationOffenceCase(request),
+        createAdditionalPendingAttempt: (request) => service.createAdditionalPendingAttempt(request),
+        createCorrectionCase: (request) => service.createCorrectionCase(request),
+        settleActionAttempt: (request) => service.settleActionAttempt(request),
+        recordObservedAction: (request) => service.recordObservedAction(request),
+        listReconciliationCandidates: (request) => service.listReconciliationCandidates(request),
+        async disassociateCase(request) {
+            const result = await service.disassociateCase(request);
+            if (result.outcome !== "disassociated" &&
+                result.outcome !== "already_disassociated")
+                return result;
+            // Deliberately pass no former subject identity across the module boundary.
+            await provider.disassociateCase({ services: input.services }, {
+                guildId: request.guildId,
+                moderationCaseId: result.caseId,
+                occurredAt: request.occurredAt,
+            });
+            if (input.services.has(HELYX_SERVICE_NAMES.memberRoleGrants)) {
+                const grants = input.services.get(HELYX_SERVICE_NAMES.memberRoleGrants);
+                let cursor;
+                do {
+                    const released = await grants.releaseOwned({
+                        sourceModuleId: "helyx.moderation",
+                        selector: {
+                            kind: "scope",
+                            guildId: request.guildId,
+                            sourceScopeId: result.caseId,
+                        },
+                        batchKey: `${request.operationKey}:release-access`,
+                        occurredAt: request.occurredAt,
+                        reason: "Moderation case disassociated",
+                        limit: 100,
+                        ...(cursor ? { cursor } : {}),
+                    });
+                    cursor = released.nextCursor;
+                } while (cursor);
+            }
+            return result;
+        },
+        executeRetention: (request) => service.executeRetention(request),
+    };
+}
+function caseLinkProvider(modules) {
+    const providers = modules.flatMap((module) => module.autoModerationCaseLinkProvider
+        ? [
+            {
+                moduleId: module.manifest.id,
+                provider: module.autoModerationCaseLinkProvider,
+            },
+        ]
+        : []);
+    if (providers.length > 1)
+        throw new Error("Auto Moderation case-link ownership is ambiguous");
+    const registered = providers[0];
+    if (!registered)
+        return null;
+    if (registered.moduleId !== AUTOMOD_MODULE_ID ||
+        registered.provider.providerId !== AUTOMOD_CASE_LINK_PROVIDER_ID ||
+        registered.provider.contractVersion !== AUTOMOD_CASE_LINK_CONTRACT_VERSION)
+        throw new Error("Auto Moderation case-link registration is invalid");
+    return registered.provider;
+}
+export function installModerationCaseDisassociation(input) {
+    const current = input.services.get(HELYX_SERVICE_NAMES.atomicModerationCases);
+    if (!current)
+        return;
+    input.services.set(HELYX_SERVICE_NAMES.atomicModerationCases, decorateModerationCaseDisassociation({
+        modules: input.modules,
+        services: input.serviceAccess,
+        service: current,
+    }));
+}
+//# sourceMappingURL=moderation-case-disassociation.js.map

package/dist/moderation-platform-services.d.ts

@@ -0,0 +1,27 @@
+import type { ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import type { Client } from "discord.js";
+import { BotAutoModerationScannerRegistry } from "./auto-moderation-scanner-registry.js";
+import { EmbeddedAutoModerationScanner } from "./embedded-auto-moderation-scanner.js";
+import { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+export interface ModerationPlatformServiceHandle {
+    evidenceStore: TransientViolationEvidenceStore;
+    scannerRegistry: BotAutoModerationScannerRegistry;
+    embeddedScanner?: EmbeddedAutoModerationScanner;
+}
+/** Installs bounded moderation adapters; no module or Ecko lifecycle starts here. */
+export declare function installModerationPlatformServices(input: {
+    services: Map<string, unknown>;
+    serviceAccess: ServiceAccess;
+    client: Client;
+    modules: readonly ModuleDefinition[];
+    runtimeProfile: "hosted" | "self-hosted";
+    deploymentEnvironment?: string;
+    embedded?: {
+        workers: number;
+        maximumItems: number;
+        maximumBytes: number;
+        maximumItemsPerGuild: number;
+        refreshIntervalMs: number;
+    };
+}): ModerationPlatformServiceHandle;
+//# sourceMappingURL=moderation-platform-services.d.ts.map

package/dist/moderation-platform-services.js

@@ -0,0 +1,47 @@
+import { HELYX_SERVICE_NAMES } from "@helyx/sdk";
+import { BotAutoModerationScannerRegistry } from "./auto-moderation-scanner-registry.js";
+import { DiscordAutoModerationAdapter } from "./discord-auto-moderation-service.js";
+import { DiscordMessageEnforcementAdapter } from "./discord-message-enforcement-service.js";
+import { DiscordViolationEvidenceDeliveryAdapter, DiscordViolationThreadAdapter, } from "./discord-violation-thread-service.js";
+import { BotModerationActionRegistry } from "./moderation-action-registry.js";
+import { EmbeddedAutoModerationScanner } from "./embedded-auto-moderation-scanner.js";
+import { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+import { installModerationCaseDisassociation } from "./moderation-case-disassociation.js";
+/** Installs bounded moderation adapters; no module or Ecko lifecycle starts here. */
+export function installModerationPlatformServices(input) {
+    const evidenceStore = new TransientViolationEvidenceStore();
+    installModerationCaseDisassociation({
+        modules: input.modules,
+        services: input.services,
+        serviceAccess: input.serviceAccess,
+    });
+    const scannerRegistry = new BotAutoModerationScannerRegistry(input.modules, input.serviceAccess, input.runtimeProfile, evidenceStore, input.deploymentEnvironment);
+    const evidenceDelivery = new DiscordViolationEvidenceDeliveryAdapter(input.client, evidenceStore);
+    input.services.set(HELYX_SERVICE_NAMES.discordAutoModeration, new DiscordAutoModerationAdapter(input.client));
+    input.services.set(HELYX_SERVICE_NAMES.messageEnforcement, new DiscordMessageEnforcementAdapter(input.client));
+    input.services.set(HELYX_SERVICE_NAMES.violationThreads, new DiscordViolationThreadAdapter(input.client));
+    input.services.set(HELYX_SERVICE_NAMES.moderationActions, new BotModerationActionRegistry(input.modules, input.serviceAccess, evidenceDelivery));
+    input.services.set(HELYX_SERVICE_NAMES.automodScannerProvider, scannerRegistry);
+    const embeddedScanner = input.runtimeProfile === "self-hosted"
+        ? new EmbeddedAutoModerationScanner({
+            registry: scannerRegistry,
+            evidenceStore,
+            environment: input.deploymentEnvironment ?? "self-hosted",
+            poolLimits: {
+                workers: input.embedded?.workers ?? 1,
+                maximumItems: input.embedded?.maximumItems ?? 5_000,
+                maximumBytes: input.embedded?.maximumBytes ?? 64 * 1_024 * 1_024,
+                maximumItemsPerGuild: input.embedded?.maximumItemsPerGuild ?? 100,
+            },
+            refreshIntervalMs: input.embedded?.refreshIntervalMs ?? 300_000,
+        })
+        : undefined;
+    if (embeddedScanner)
+        input.services.set(HELYX_SERVICE_NAMES.automodScannerObservations, embeddedScanner);
+    return {
+        evidenceStore,
+        scannerRegistry,
+        ...(embeddedScanner ? { embeddedScanner } : {}),
+    };
+}
+//# sourceMappingURL=moderation-platform-services.js.map

package/dist/modules.d.ts

@@ -12,6 +12,10 @@ export interface ConfiguredModulePackage extends LoadedDefinition {
 }
 export declare const secureRandomSelectionWorkerKeyName = "HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY";
 interface PlatformServiceEnvironment extends Pick<BotEnvironment, "HELYX_DATA_ENCRYPTION_KEY"> {
+    HELYX_RUNTIME_PROFILE?: BotEnvironment["HELYX_RUNTIME_PROFILE"];
+    HELYX_MESSAGE_CONTENT_ENABLED?: boolean;
+    HELYX_GUILD_MEMBERS_ENABLED?: boolean;
+    HELYX_ECKO_TRANSPORT_SECRET?: string | undefined;
     DISCORD_CLIENT_ID?: string;
     HELYX_DASHBOARD_PUBLIC_URL?: string;
     HELYX_INTERNAL_SECURE_RANDOM_SELECTION_KEY?: string;
@@ -22,6 +26,8 @@ export declare function platformServiceOptions(environment: PlatformServiceEnvir
     secureRandomSelectionKey?: Uint8Array;
     inviteFingerprintKey?: Uint8Array;
     dashboardBaseUrl?: string;
+    runtimeProfile: "hosted" | "self-hosted";
+    availableDiscordCapabilities: readonly ("guild-members" | "message-content")[];
 };
 export declare function deriveInviteFingerprintKey(selectionKey: Uint8Array): Uint8Array;
 export declare function loadConfiguredModules(specifiers: readonly string[], importer?: ModuleImporter): Promise<ModuleDefinition[]>;