@helyx/module-automod 1.0.1

package/dist/events.js

@@ -0,0 +1,371 @@
+import { AUTOMOD_SCANNER_LIMITS, AUTOMOD_TIMEOUT_SECONDS, HELYX_SERVICE_NAMES, MODERATION_ACTION_CONTRACT_VERSION, MODERATION_ACTION_PROVIDER_ID, } from "@helyx/sdk";
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE } from "@helyx/module-manifest";
+import { AUTOMOD_MODULE_ID } from "./constants.js";
+import { countAutoModerationReceipt } from "./receipt-statistics.js";
+import { enforcementActionFamily, enforcementClaimFingerprint, enforcementClaimKey, } from "./domain.js";
+import { AutoModerationRepository, } from "./repository.js";
+export function createAutoModerationEvents(publication) {
+    return {
+        privilegedMessageCreate: [
+            {
+                type: "discord.privileged-message-create",
+                featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+                isEligible: async (context) => eligibleObservation(context),
+                execute: (context) => {
+                    const source = context.source;
+                    if (!source?.resolved || !source.member.present)
+                        return Promise.resolve();
+                    context.services
+                        .get(HELYX_SERVICE_NAMES.automodScannerObservations)
+                        .observe({
+                        guildId: context.serverId,
+                        channelId: context.channelId,
+                        parentChannelId: source.parentChannelId,
+                        messageId: context.messageId,
+                        authorUserId: context.userId,
+                        memberRoleIds: source.member.roleIds,
+                        content: context.content,
+                        source: "user",
+                        type: "create",
+                        version: context.messageId,
+                        observedAt: snowflakeTime(context.messageId).toISOString(),
+                    });
+                    return Promise.resolve();
+                },
+            },
+        ],
+        privilegedMessageUpdate: [
+            {
+                type: "discord.privileged-message-update",
+                featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+                execute: (context) => {
+                    if (!context.content.present ||
+                        !eligibleSource(context.source) ||
+                        !context.services.has(HELYX_SERVICE_NAMES.automodScannerObservations))
+                        return Promise.resolve();
+                    const scanner = context.services.get(HELYX_SERVICE_NAMES.automodScannerObservations);
+                    if (!scanner.isConfigured(context.serverId))
+                        return Promise.resolve();
+                    scanner.observe({
+                        guildId: context.serverId,
+                        channelId: context.channelId,
+                        parentChannelId: context.source.parentChannelId,
+                        messageId: context.messageId,
+                        authorUserId: context.source.userId,
+                        memberRoleIds: context.source.member.roleIds,
+                        content: context.content.value,
+                        source: "user",
+                        type: "edit",
+                        version: context.observationVersion,
+                        observedAt: context.observedAt.toISOString(),
+                    });
+                    return Promise.resolve();
+                },
+            },
+        ],
+        discordAutoModerationRuleCreate: [
+            {
+                type: "discord.auto-moderation-rule-create",
+                execute: (context) => publication.observeNativeRule(context.services, context.rule, context.serverId, context.rule.ruleId),
+            },
+        ],
+        discordAutoModerationRuleUpdate: [
+            {
+                type: "discord.auto-moderation-rule-update",
+                execute: (context) => publication.observeNativeRule(context.services, context.rule, context.serverId, context.rule.ruleId),
+            },
+        ],
+        discordAutoModerationRuleDelete: [
+            {
+                type: "discord.auto-moderation-rule-delete",
+                execute: (context) => publication.observeNativeRule(context.services, null, context.serverId, context.rule.ruleId),
+            },
+        ],
+        discordAutoModerationActionExecution: [
+            {
+                type: "discord.auto-moderation-action-execution",
+                execute: handleNativeAction,
+            },
+        ],
+    };
+}
+function eligibleObservation(context) {
+    if (!eligibleSource(context.source) ||
+        context.content.length < 1 ||
+        context.content.length > AUTOMOD_SCANNER_LIMITS.messageCharacters ||
+        Buffer.byteLength(context.content, "utf8") >
+            AUTOMOD_SCANNER_LIMITS.messageUtf8Bytes ||
+        !context.services.has(HELYX_SERVICE_NAMES.automodScannerObservations))
+        return Promise.resolve(false);
+    return Promise.resolve(context.services
+        .get(HELYX_SERVICE_NAMES.automodScannerObservations)
+        .isConfigured(context.serverId));
+}
+function eligibleSource(source) {
+    return Boolean(source?.resolved &&
+        source.member.present &&
+        !source.userIsBot &&
+        !source.userIsSystem &&
+        !source.webhookId);
+}
+function snowflakeTime(messageId) {
+    try {
+        return new Date(Number(BigInt(messageId) >> 22n) + 1_420_070_400_000);
+    }
+    catch {
+        return new Date();
+    }
+}
+async function handleNativeAction(context) {
+    const repository = new AutoModerationRepository(context.services);
+    const rule = await repository.findByNativeRuleId(context.serverId, context.ruleId);
+    if (!rule || rule.status !== "published")
+        return;
+    const claimKey = enforcementClaimKey({
+        guildId: context.serverId,
+        configurationRevision: rule.configurationRevision,
+        subjectUserId: context.userId,
+        messageId: context.messageId,
+        channelId: context.channelId,
+        sourceEventId: context.executionId,
+    });
+    const claimActionFamily = enforcementActionFamily(rule.draft.actionPolicy);
+    const eventKey = `${context.executionId}:${context.action.type}`;
+    const request = nativeRequest(context, rule, claimKey);
+    const claim = await repository.claimEnforcement({
+        guildId: context.serverId,
+        claimKey,
+        rule,
+        subjectUserId: context.userId,
+        channelId: context.channelId,
+        messageId: context.messageId,
+        actionFamily: claimActionFamily,
+        source: "native",
+        requestFingerprint: enforcementClaimFingerprint({
+            claimKey,
+            logicalRuleId: rule.ruleId,
+            ruleRevision: rule.revision,
+            actionFamily: claimActionFamily,
+        }),
+        occurredAt: request.occurredAt,
+    });
+    const receipt = await repository.appendReceipt({
+        guildId: context.serverId,
+        eventKey,
+        rule,
+        nativeRuleId: context.ruleId,
+        subjectUserId: context.userId,
+        channelId: context.channelId,
+        messageId: context.messageId,
+        alertSystemMessageId: context.alertSystemMessageId,
+        actionType: context.action.type,
+        claimKey,
+        occurredAt: request.occurredAt,
+    });
+    const resumingReceipt = !receipt.created;
+    if (resumingReceipt) {
+        const existingReceipt = await repository.findReceiptByEventKey({
+            guildId: context.serverId,
+            eventKey,
+        });
+        if (!existingReceipt || existingReceipt.outcome !== "observed")
+            return;
+    }
+    const resumableClaim = resumingReceipt &&
+        !claim.created &&
+        claim.source === "native" &&
+        claim.outcome === "pending";
+    if (claim.conflict || (!claim.created && !resumableClaim)) {
+        await repository.settleReceipt({
+            guildId: context.serverId,
+            eventKey,
+            outcome: claim.conflict || claim.outcome === "pending"
+                ? "review_required"
+                : claim.outcome,
+            ...(claim.moderationCaseId
+                ? { moderationCaseId: claim.moderationCaseId }
+                : {}),
+            safeCode: claim.conflict
+                ? "claim_conflict"
+                : (claim.safeCode ?? "first_source_won"),
+        });
+        return;
+    }
+    await countReceipt(context, rule.ruleId, eventKey);
+    await emitTriggerLog(context, rule.ruleId, eventKey);
+    if (!context.services.has(HELYX_SERVICE_NAMES.moderationActions)) {
+        await settleUnavailable(repository, context.serverId, eventKey, claimKey, context.occurredAt);
+        return;
+    }
+    let result;
+    try {
+        result = await context.services
+            .get(HELYX_SERVICE_NAMES.moderationActions)
+            .execute({
+            providerId: MODERATION_ACTION_PROVIDER_ID,
+            contractVersion: MODERATION_ACTION_CONTRACT_VERSION,
+            callerModuleId: AUTOMOD_MODULE_ID,
+            request,
+        });
+    }
+    catch {
+        await settleDispatchUnconfirmed(repository, context.serverId, eventKey, claimKey, context.occurredAt);
+        await emitEnforcementFailure(context, rule.ruleId, eventKey);
+        return;
+    }
+    const caseId = "caseId" in result ? result.caseId : undefined;
+    const outcome = result.outcome;
+    const safeCode = result.outcome === "rejected"
+        ? result.code
+        : "safeCode" in result
+            ? result.safeCode
+            : undefined;
+    await repository.settleReceipt({
+        guildId: context.serverId,
+        eventKey,
+        outcome,
+        ...(caseId ? { moderationCaseId: caseId } : {}),
+        ...(safeCode ? { safeCode } : {}),
+    });
+    await repository.settleClaim({
+        guildId: context.serverId,
+        claimKey,
+        outcome,
+        ...(caseId ? { moderationCaseId: caseId } : {}),
+        ...(result.outcome === "applied" || result.outcome === "already_applied"
+            ? {
+                repeatOrdinal: result.offenceOrdinal,
+                selectedAction: result.selectedAction.type,
+            }
+            : {}),
+        ...(safeCode ? { safeCode } : {}),
+        occurredAt: new Date(),
+    });
+}
+function nativeRequest(context, rule, claimKey) {
+    const observedDuration = context.action.type === "timeout" ? context.action.durationSeconds : null;
+    const timeoutSeconds = AUTOMOD_TIMEOUT_SECONDS.find((seconds) => seconds === observedDuration);
+    const observedAction = timeoutSeconds !== undefined
+        ? {
+            type: "discord_native_timeout",
+            durationSeconds: timeoutSeconds,
+        }
+        : context.action.type === "block_message"
+            ? { type: "discord_native_block_message" }
+            : null;
+    const base = {
+        operationKey: `automod:${claimKey}`,
+        detectionSource: "native",
+        guildId: context.serverId,
+        subjectUserId: context.userId,
+        sourceMessage: context.channelId
+            ? { channelId: context.channelId, messageId: context.messageId }
+            : null,
+        sourceEventId: context.executionId,
+        occurredAt: observationTime(context),
+        callerModuleId: AUTOMOD_MODULE_ID,
+        ruleId: rule.ruleId,
+        configurationRevision: rule.configurationRevision,
+        reasonCode: "native_rule_triggered",
+        severity: rule.category,
+        confidenceClass: "native_equivalent",
+        ...(context.evidenceReference
+            ? { evidenceReference: context.evidenceReference }
+            : {}),
+    };
+    return observedAction
+        ? { ...base, requestKind: "observation", observedAction }
+        : { ...base, requestKind: "detection" };
+}
+function observationTime(context) {
+    if (context.messageId) {
+        try {
+            const milliseconds = Number(BigInt(context.messageId) >> 22n) + 1_420_070_400_000;
+            if (Number.isSafeInteger(milliseconds))
+                return new Date(milliseconds);
+        }
+        catch {
+            // The platform validates Discord identifiers; fall through defensively.
+        }
+    }
+    return new Date(Math.floor(context.occurredAt.getTime() / 1_000) * 1_000);
+}
+async function settleUnavailable(repository, guildId, eventKey, claimKey, occurredAt) {
+    await repository.settleReceipt({
+        guildId,
+        eventKey,
+        outcome: "native_only",
+        safeCode: "moderation_unavailable",
+    });
+    await repository.settleClaim({
+        guildId,
+        claimKey,
+        outcome: "native_only",
+        safeCode: "moderation_unavailable",
+        occurredAt,
+    });
+}
+async function settleDispatchUnconfirmed(repository, guildId, eventKey, claimKey, occurredAt) {
+    const safeCode = "moderation_dispatch_unconfirmed";
+    await repository.settleReceipt({
+        guildId,
+        eventKey,
+        outcome: "review_required",
+        safeCode,
+    });
+    await repository.settleClaim({
+        guildId,
+        claimKey,
+        outcome: "review_required",
+        safeCode,
+        occurredAt,
+    });
+}
+async function countReceipt(context, ruleId, eventKey) {
+    await countAutoModerationReceipt(context.services, {
+        guildId: context.serverId,
+        ruleId,
+        eventKey,
+        source: "native",
+        actionType: context.action.type,
+        occurredAt: context.occurredAt,
+    }).catch(() => undefined);
+}
+async function emitTriggerLog(context, ruleId, eventKey) {
+    if (!context.services.has(HELYX_SERVICE_NAMES.moduleLogging))
+        return;
+    await context.services
+        .get(HELYX_SERVICE_NAMES.moduleLogging)
+        .emit({
+        guildId: context.serverId,
+        moduleId: AUTOMOD_MODULE_ID,
+        eventId: "automod-rule-triggered",
+        summary: "A Discord Auto Moderation rule triggered.",
+        details: [
+            { label: "Rule", value: ruleId },
+            { label: "Action", value: context.action.type },
+            { label: "Outcome", value: "Observed by Discord" },
+        ],
+        idempotencyKey: eventKey,
+    })
+        .catch(() => undefined);
+}
+async function emitEnforcementFailure(context, ruleId, eventKey) {
+    if (!context.services.has(HELYX_SERVICE_NAMES.moduleLogging))
+        return;
+    await context.services
+        .get(HELYX_SERVICE_NAMES.moduleLogging)
+        .emit({
+        guildId: context.serverId,
+        moduleId: AUTOMOD_MODULE_ID,
+        eventId: "automod-enforcement-failed",
+        summary: "An Auto Moderation follow-up requires review.",
+        details: [
+            { label: "Rule", value: ruleId },
+            { label: "Outcome", value: "Moderation dispatch unconfirmed" },
+        ],
+        idempotencyKey: `${eventKey}:enforcement-failed`,
+    })
+        .catch(() => undefined);
+}
+//# sourceMappingURL=events.js.map

package/dist/health.d.ts

@@ -0,0 +1,9 @@
+import { type HealthResult, type RuntimeContext } from "@helyx/sdk";
+export declare class AutoModerationHealth {
+    #private;
+    start(context: RuntimeContext): void;
+    stop(): void;
+    recordConfigurationReconciliation(succeeded: boolean): void;
+    snapshot(): HealthResult;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/health.js

@@ -0,0 +1,45 @@
+import { HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+const REQUIRED_SERVICES = [
+    HELYX_SERVICE_NAMES.records,
+    HELYX_SERVICE_NAMES.configuration,
+    HELYX_SERVICE_NAMES.installations,
+    HELYX_SERVICE_NAMES.discordAutoModeration,
+    HELYX_SERVICE_NAMES.discordResources,
+    HELYX_SERVICE_NAMES.resourceAuthorization,
+];
+export class AutoModerationHealth {
+    #running = false;
+    #missing = [];
+    #configurationReconciliationFailed = false;
+    start(context) {
+        this.#running = true;
+        this.#missing = REQUIRED_SERVICES.filter((name) => !context.services.has(name));
+    }
+    stop() {
+        this.#running = false;
+        this.#missing = [];
+        this.#configurationReconciliationFailed = false;
+    }
+    recordConfigurationReconciliation(succeeded) {
+        this.#configurationReconciliationFailed = !succeeded;
+    }
+    snapshot() {
+        if (!this.#running)
+            return { status: "unhealthy", message: "Auto Moderation is stopped" };
+        if (this.#missing.length)
+            return {
+                status: "unhealthy",
+                message: "Auto Moderation runtime services are unavailable",
+            };
+        if (this.#configurationReconciliationFailed)
+            return {
+                status: "degraded",
+                message: "Auto Moderation configuration was saved but Discord rule reconciliation needs review",
+            };
+        return {
+            status: "healthy",
+            message: "Discord-native Auto Moderation rules and receipts are active",
+        };
+    }
+}
+//# sourceMappingURL=health.js.map

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export declare const automodModule: import("@helyx/sdk").ModuleDefinition;
+export default automodModule;
+export * from "./configuration.js";
+export * from "./constants.js";
+export * from "./contracts.js";
+export * from "./domain.js";
+export * from "./enhanced-configuration.js";
+export * from "./records.js";
+export * from "./repository.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,141 @@
+import { readFileSync } from "node:fs";
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE, parseModuleManifest, } from "@helyx/module-manifest";
+import { HELYX_SERVICE_NAMES, createPrivacyProvider, defineModule, getModulePrivacyDeclaration, } from "@helyx/sdk";
+import { createAutoModerationActivityResource } from "./activity-resource.js";
+import { createAutoModerationCaseLinkProvider } from "./case-link-provider.js";
+import { parseAutoModerationConfiguration } from "./configuration.js";
+import { AUTOMOD_PERMISSION_IDS } from "./constants.js";
+import { automodDefaultPermissions, automodLogging } from "./contracts.js";
+import { createAutoModerationEvents } from "./events.js";
+import { AutoModerationHealth } from "./health.js";
+import { createAutoModerationPolicyProvider } from "./policy-provider.js";
+import { createAutoModerationScannerProvider } from "./scanner-provider.js";
+import { AutoModerationPublicationService } from "./publication.js";
+import { automodRecords } from "./records.js";
+import { createAutoModerationRulesResource } from "./resources.js";
+import { previewEnhancedSettings } from "./settings-preview.js";
+const manifest = parseModuleManifest(JSON.parse(readFileSync(new URL("../manifest.json", import.meta.url), "utf8")));
+const scannerProvider = createAutoModerationScannerProvider();
+const publication = new AutoModerationPublicationService(async (services) => {
+    scannerProvider.invalidate();
+    try {
+        await synchronizeEmbeddedScanner(services);
+        health.recordConfigurationReconciliation(true);
+    }
+    catch {
+        // The rule and Discord mapping are already committed. A scanner refresh
+        // failure degrades delivery rather than inviting a duplicate Save.
+        health.recordConfigurationReconciliation(false);
+    }
+});
+const health = new AutoModerationHealth();
+export const automodModule = defineModule({
+    manifest,
+    configuration: {
+        schemaVersion: 1,
+        validate: (input) => ({ ...parseAutoModerationConfiguration(input) }),
+        validateUpdate: async ({ guildId, value, services }) => {
+            const configuration = parseAutoModerationConfiguration(value);
+            if (services.has(HELYX_SERVICE_NAMES.configuration)) {
+                const moderation = await services
+                    .get(HELYX_SERVICE_NAMES.configuration)
+                    .get(guildId, "helyx.moderation");
+                const violationAccessRoleId = typeof moderation?.value.violationAccessRoleId === "string"
+                    ? moderation.value.violationAccessRoleId
+                    : null;
+                if (violationAccessRoleId &&
+                    configuration.defaultExemptRoleIds.includes(violationAccessRoleId))
+                    throw new Error("The violation-access role cannot be globally ignored by Auto Moderation.");
+            }
+            if (configuration.configuredMode !== "enhanced")
+                return;
+            const access = await services
+                .get(HELYX_SERVICE_NAMES.featureAccess)
+                .check({
+                guildId,
+                moduleId: manifest.id,
+                featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+            });
+            if (access.decision !== "granted")
+                throw new Error("Enhanced Auto Moderation is unavailable for this server.");
+        },
+        settingsPreview: previewEnhancedSettings,
+    },
+    defaultPermissions: automodDefaultPermissions,
+    permissionOperations: Object.values(AUTOMOD_PERMISSION_IDS).map((id) => ({
+        id,
+        name: id,
+        description: `Authorises ${id}.`,
+    })),
+    records: automodRecords,
+    events: createAutoModerationEvents(publication),
+    logging: automodLogging,
+    privacy: {
+        providerVersion: 1,
+        create: (executor) => createPrivacyProvider({
+            id: manifest.id,
+            declaration: getModulePrivacyDeclaration(manifest),
+            executor,
+        }),
+    },
+    managedResources: [
+        createAutoModerationRulesResource(publication),
+        createAutoModerationActivityResource(),
+    ],
+    autoModerationEnforcementPolicyProvider: createAutoModerationPolicyProvider(),
+    autoModerationScannerProvider: scannerProvider,
+    autoModerationCaseLinkProvider: createAutoModerationCaseLinkProvider(),
+    onConfigurationChanged: async (context) => {
+        scannerProvider.invalidate();
+        try {
+            const enabled = await context.services
+                .get(HELYX_SERVICE_NAMES.installations)
+                .isModuleEnabled(context.guildId, manifest.id);
+            await publication.synchronizeOwnedRules(context.services, context.guildId, enabled);
+            await synchronizeEmbeddedScanner(context.services);
+            health.recordConfigurationReconciliation(true);
+        }
+        catch {
+            // The configuration transaction is already authoritative. Surface a
+            // degraded module instead of returning a false save failure to the
+            // dashboard and inviting a conflicting retry.
+            health.recordConfigurationReconciliation(false);
+        }
+    },
+    onActivated: async (context) => {
+        await publication.synchronizeOwnedRules(context.services, context.guildId, true);
+        await synchronizeEmbeddedScanner(context.services);
+    },
+    onDeactivated: async (context) => {
+        await publication.synchronizeOwnedRules(context.services, context.guildId, false);
+        await synchronizeEmbeddedScanner(context.services);
+    },
+    start(context) {
+        health.start(context);
+        context.logger.info({ event: "automod.started" }, "Auto Moderation module started");
+        return Promise.resolve();
+    },
+    stop(context) {
+        health.stop();
+        context.logger.info({ event: "automod.stopped" }, "Auto Moderation module stopped");
+        return Promise.resolve();
+    },
+    health: () => health.snapshot(),
+});
+async function synchronizeEmbeddedScanner(services) {
+    if (!services.has(HELYX_SERVICE_NAMES.automodScannerObservations))
+        return;
+    await services
+        .get(HELYX_SERVICE_NAMES.automodScannerObservations)
+        .synchronize()
+        .catch(() => undefined);
+}
+export default automodModule;
+export * from "./configuration.js";
+export * from "./constants.js";
+export * from "./contracts.js";
+export * from "./domain.js";
+export * from "./enhanced-configuration.js";
+export * from "./records.js";
+export * from "./repository.js";
+//# sourceMappingURL=index.js.map

package/dist/policy-provider.d.ts

@@ -0,0 +1,3 @@
+import { type AutoModerationEnforcementPolicyProviderContributionV1 } from "@helyx/sdk";
+export declare function createAutoModerationPolicyProvider(): AutoModerationEnforcementPolicyProviderContributionV1;
+//# sourceMappingURL=policy-provider.d.ts.map

package/dist/policy-provider.js

@@ -0,0 +1,66 @@
+import { AUTOMOD_ENFORCEMENT_POLICY_CONTRACT_VERSION, AUTOMOD_ENFORCEMENT_POLICY_PROVIDER_ID, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE } from "@helyx/module-manifest";
+import { AUTOMOD_MODULE_ID } from "./constants.js";
+import { policyFingerprint } from "./domain.js";
+import { currentConfiguration } from "./publication.js";
+import { AutoModerationRepository } from "./repository.js";
+export function createAutoModerationPolicyProvider() {
+    return {
+        providerId: AUTOMOD_ENFORCEMENT_POLICY_PROVIDER_ID,
+        contractVersion: AUTOMOD_ENFORCEMENT_POLICY_CONTRACT_VERSION,
+        async resolve(context, request) {
+            if (request.callerModuleId !== AUTOMOD_MODULE_ID)
+                return { outcome: "rejected", code: "action_not_allowed" };
+            const services = context.services;
+            if (!services.has(HELYX_SERVICE_NAMES.installations) ||
+                !(await services
+                    .get(HELYX_SERVICE_NAMES.installations)
+                    .isModuleEnabled(request.guildId, AUTOMOD_MODULE_ID)))
+                return { outcome: "rejected", code: "module_unavailable" };
+            if (request.detectionSource === "enhanced") {
+                if (!services.has(HELYX_SERVICE_NAMES.featureAccess))
+                    return { outcome: "rejected", code: "feature_unavailable" };
+                const access = await services
+                    .get(HELYX_SERVICE_NAMES.featureAccess)
+                    .check({
+                    guildId: request.guildId,
+                    moduleId: AUTOMOD_MODULE_ID,
+                    featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+                })
+                    .catch(() => ({ decision: "dependency_unhealthy" }));
+                if (access.decision !== "granted")
+                    return { outcome: "rejected", code: "feature_unavailable" };
+            }
+            if (services.has(HELYX_SERVICE_NAMES.moduleAvailability) &&
+                !(await services
+                    .get(HELYX_SERVICE_NAMES.moduleAvailability)
+                    .isAvailable(AUTOMOD_MODULE_ID)))
+                return { outcome: "rejected", code: "module_unavailable" };
+            const rule = await new AutoModerationRepository(services).findRule(request.guildId, request.ruleId);
+            if (!rule || rule.status !== "published")
+                return { outcome: "rejected", code: "stale_operation" };
+            const configuration = await currentConfiguration(services, request.guildId);
+            if (request.configurationRevision !== configuration.revision ||
+                rule.configurationRevision !== configuration.revision)
+                return { outcome: "rejected", code: "stale_revision" };
+            const resolved = {
+                ruleRevision: rule.revision,
+                configurationRevision: configuration.revision,
+                windowStartsAt: new Date(request.occurredAt.getTime() -
+                    configuration.value.repeatOffenderWindowDays * 86_400_000),
+                globalIgnoredRoleIds: configuration.value.defaultExemptRoleIds,
+                ruleIgnoredRoleIds: rule.draft.ignoredRoleIds,
+                actionPolicy: rule.draft.actionPolicy,
+                openViolationThread: rule.draft.openViolationThread,
+                deleteSourceMessage: request.detectionSource === "enhanced" && rule.draft.blockMessage,
+            };
+            return {
+                outcome: "eligible",
+                ruleName: rule.draft.name,
+                ...resolved,
+                policyFingerprint: policyFingerprint(resolved),
+            };
+        },
+    };
+}
+//# sourceMappingURL=policy-provider.js.map

package/dist/publication-support.d.ts

@@ -0,0 +1,14 @@
+import { type DiscordAutoModerationRuleDefinition, type DiscordAutoModerationRuleSnapshot, type ServiceAccess } from "@helyx/sdk";
+import { type AutoModerationConfiguration } from "./configuration.js";
+import { type AutoModerationRuleDraft } from "./domain.js";
+export declare function isKindEnabled(draft: AutoModerationRuleDraft, configuration: AutoModerationConfiguration): boolean;
+export declare function validateKindEnabled(draft: AutoModerationRuleDraft, configuration: AutoModerationConfiguration): void;
+export declare function currentConfiguration(services: ServiceAccess, guildId: string): Promise<{
+    value: AutoModerationConfiguration;
+    revision: string;
+}>;
+export declare function definitionFor(ruleId: string, draft: AutoModerationRuleDraft, configuration: AutoModerationConfiguration, enabled: boolean): DiscordAutoModerationRuleDefinition;
+export declare function snapshotDefinition(snapshot: DiscordAutoModerationRuleSnapshot): DiscordAutoModerationRuleDefinition;
+export declare function publicationError(outcome: string, safeCode?: string): Error;
+export declare function mutationSafeCode(result: object): string | undefined;
+//# sourceMappingURL=publication-support.d.ts.map