@helyx/module-automod 1.0.1

package/README.md

@@ -0,0 +1,80 @@
+# @helyx/module-automod
+
+Auto Moderation lets authorised managers publish transparent Discord-native safety rules, review content-free activity receipts, and optionally connect confirmed offences to Moderation cases and repeat-offender actions.
+
+## Availability and deployment
+
+Auto Moderation is a Live module distributed under HSAL-1.0. Standard mode supports Hosted and Self-Hosted Helyx installations, uses no third-party credentials, and does not require the Message Content privileged intent.
+
+Package installation does not enable the module for a server. The deployment-neutral Enhanced matching engine is included through the deliberate `@helyx/module-automod/engine` export. Hosted Helyx connects it through Ecko for eligible Enhanced servers, while Self-Hosted Helyx runs the same scanner contract through the embedded adapter. Standard rules remain effective without either adapter.
+
+## What it does
+
+- Keeps one logical Helyx keyword rule mapped to one Helyx-owned Discord Auto Moderation rule.
+- Supports keyword/phrase/wildcard and Discord regex filters, one Discord preset rule, one generic-spam rule, and one mention-spam rule.
+- Applies global and per-rule role/channel exclusions and detects external Discord edits or deletion as drift or missing state.
+- Records bounded structural action receipts without matched words or message content.
+- Supplies the current rule revision, exclusions, repeat window, and first/second/third action policy to the closed Moderation integration.
+- Uses a durable enforcement claim before requesting an optional Moderation effect so native action events collapse into one offence.
+- Compiles immutable, versioned Enhanced rule snapshots and deterministically evaluates exact, phrase, wildcard, reviewed normalisation and explicitly opted-in bounded fuzzy matching.
+- Keeps custom regex on Discord's native Rust engine until an approved linear-time Node engine is available; it never falls back to JavaScript's backtracking regular-expression engine.
+- Provides bounded process-memory configuration, edit-metadata and keyed similar-message caches that remain correct when restarted empty.
+
+Auto Moderation does not provide staff commands, own moderation case numbers, or perform Discord member punishment directly. The optional Moderation module remains the only provider allowed to create a case and dispatch a Helyx warning, mute, kick, ban, demotion, or violation thread.
+
+## Commands and interactions
+
+Auto Moderation has no slash commands or Discord components. Managers use the dashboard resources. Each operation is separately authorised through `automod.rules.read`, `automod.rules.manage`, `automod.rules.publish`, `automod.rules.reconcile`, `automod.activity.read`, or `automod.settings.manage`; all default to Administrators.
+
+## Dashboard configuration
+
+The **Rules** resource uses the exact responsive columns **Rule name**, **Filter**, **Action**, **Moderation thread**, **Ignored roles**, and **Repeat offender**. One **Save** validates the complete native definition, fixed mute durations, high-impact repeat actions, combined exemptions, Discord capacity, and current publishing permission before creating or updating the active Discord rule. The module must be enabled to apply a rule. A 4,000-byte bounded import reviews comma/newline-separated terms without saving or applying them and without silent truncation.
+
+Published mappings support Disable, Adopt current Discord values, Restore Helyx values, and confirmed cleanup of only the mapped Helyx-owned Discord rule. A missing rule is never recreated automatically. Active rules can be edited and saved directly; mapped filter types cannot be changed because Discord treats them as immutable. Drifted or missing mappings must be reconciled before ordinary Save can apply changes.
+
+Settings contain Standard/Enhanced mode identity, Strict (90), Balanced (80), Sensitive (70) and Custom (60–95) confidence choices, optional per-category overrides, native rule-type configuration switches, a default Discord alert channel, global ignored roles/channels, and a 1–365 day repeat-offender window. These switches permit configuration of preset, generic spam and mention spam rules; they do not create a rule or import existing Discord rules. Unmanaged Discord rules remain untouched and still count towards Discord's capacity. Adopt current Discord values applies only to an existing Helyx-owned mapping. Exact, native-equivalent and reviewed high-confidence normalised matches do not depend on the slider. Fuzzy matching must also be enabled explicitly on the rule's bounded keyword group, and terms under four characters never enter fuzzy comparison.
+
+The settings preview tests unsaved confidence values against fictional content and currently published rules in memory. It reports the selected rule, category, method, deterministic score, effective threshold and native coverage without returning the matched term or storing the fictional content. Rule imports accept CRLF/LF and comma-separated lists, normalise duplicates, and return bounded row-level errors for every rejected item instead of silently truncating input.
+
+The **Activity** resource is read-only and lists bounded structural receipts with their rule/action/outcome and optional Moderation case ID. It never shows a matched term or message body.
+
+## Discord requirements
+
+Helyx needs **Manage Server** to inspect, create, update, disable, or delete its owned Discord Auto Moderation rules. A Discord-native timeout additionally needs **Moderate Members**. Auto Moderation consumes Auto Moderation rule create/update/delete and action-execution Gateway events through the core adapter. Those events use the code-level `AUTO_MODERATION_CONFIGURATION` and `AUTO_MODERATION_EXECUTION` intents and require no separate Developer Portal switch.
+
+A native rule must block a message or send an alert; timeout cannot be its only action. Discord alerts may include triggering content in the selected Discord-owned channel, so publication displays that disclosure. The Helyx adapter removes content and matched fields before module code, persistence, Logging, Audit, metrics, or traces.
+
+**Block message** also removes posted Enhanced matches after detection, independently of the selected offence action. Native blocking happens before posting; Enhanced removal is asynchronous. Unconfirmed removal or thread delivery is surfaced through safe Activity codes while the primary action result remains authoritative.
+
+## Data, privacy and retention
+
+| Record category    | Retained data                                                                                                                                                                  |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Rules              | Logical/server identity, category, canonical rule document, owned Discord mapping/fingerprint, configuration revision, nullable creator/updater IDs, revision, and timestamps. |
+| Action receipts    | Structural rule/action, nullable subject/channel/message/alert IDs, claim/case links, safe outcome, and timestamps.                                                            |
+| Enforcement claims | Stable claim fingerprint, nullable subject/case identity, policy generation, repeat ordinal, selected action, safe outcome, and timestamps.                                    |
+| Daily counts       | Anonymous server/day/source/action counts and last observation time.                                                                                                           |
+
+Matched content, matched keywords, message bodies, attachments, embeds, and transient evidence are never written by this module. Native action receipts expire after 90 days. Settled anonymous claim/count history is bounded to 365 days; unresolved claims linked to an active case follow the case safety lifecycle. The versioned privacy provider covers creator, updater, detected-member, and enforced-member associations even while the module is disabled. Erasure detaches nullable user identities while declared rule bodies and active safety records follow manual review.
+
+## Operations and failure behavior
+
+Saving a rule writes Discord first and attaches the mapping only after success. If persistence fails or the local revision changed, Helyx compensates a new Discord rule by deleting it, or restores the previous owned definition after an update where safe; compensation never overwrites a newer mapping. An unsuccessful creation retains an internal unpublished rule for recovery: open its existing Rules row before retrying Save. Ambiguous Discord results remain reviewable rather than being retried blindly, and a differing unconfirmed Discord rule with the same ownership marker blocks another creation.
+
+Deleting an unmapped unpublished rule also requires successful Discord inspection. A native rule with the same ownership marker blocks record deletion so an unconfirmed creation cannot be orphaned.
+
+External edits mark a rule drifted; external deletion marks it missing. Module disablement disables mapped owned rules without deleting mappings or definitions. Re-enablement revalidates and synchronises only rules whose logical status is Published. Uninstall leaves owned Discord rules disabled unless an authorised manager separately confirms cleanup.
+
+The module is unhealthy while stopped or when required records, configuration, installation, Discord Auto Moderation, or authorization services are unavailable. Moderation and Logging are optional: their absence does not stop native Discord enforcement or structural receipt storage. The pure Enhanced engine performs no Discord, database, network, environment, clock or logging access; adapters supply immutable snapshots, message observations and explicit time values.
+
+Before release, run formatting, lint, type checks, focused tests, module contracts, migration integration, packed lifecycle checks, and the repository release dry run. Live Discord behaviour remains unclaimed until the credentialed smoke matrix passes.
+
+## Documentation and support
+
+- [Auto Moderation overview](https://docs.helyx.gg/modules/auto-moderation/)
+- [Auto Moderation permissions](https://docs.helyx.gg/modules/auto-moderation/permissions/)
+- [Auto Moderation failure recovery](https://docs.helyx.gg/modules/auto-moderation/failure-modes/)
+- [Auto Moderation FAQ](https://docs.helyx.gg/modules/auto-moderation/faq/)
+- [Report an issue](https://github.com/ZyC0R3/Helyx/issues)
+
+Publication, licensing, release-state promotion, push, deployment, and production changes require explicit owner approval.

package/dist/activity-resource.d.ts

@@ -0,0 +1,3 @@
+import { type ModuleManagedResource } from "@helyx/sdk";
+export declare function createAutoModerationActivityResource(): ModuleManagedResource;
+//# sourceMappingURL=activity-resource.d.ts.map

package/dist/activity-resource.js

@@ -0,0 +1,114 @@
+import { DashboardActionValidationError, } from "@helyx/sdk";
+import { AutoModerationRepository, } from "./repository.js";
+export function createAutoModerationActivityResource() {
+    return {
+        id: "automod-activity",
+        async list(context, input) {
+            const binding = JSON.stringify({
+                version: 1,
+                guildId: context.guildId,
+                ruleId: input.filters?.ruleId ?? null,
+                outcome: input.filters?.outcome ?? null,
+            });
+            const cursor = decodeCursor(input.cursor, binding);
+            const page = await new AutoModerationRepository(context.services).listReceipts({
+                guildId: context.guildId,
+                limit: input.limit,
+                ...(cursor ? { cursor } : {}),
+                ...(input.filters?.ruleId ? { ruleId: input.filters.ruleId } : {}),
+                ...(input.filters?.outcome ? { outcome: input.filters.outcome } : {}),
+            });
+            return {
+                items: page.items.map(summary),
+                ...(page.nextCursor
+                    ? { nextCursor: encodeCursor(page.nextCursor, binding) }
+                    : {}),
+            };
+        },
+        async read(context, resourceId) {
+            const receipt = await new AutoModerationRepository(context.services).findReceipt(context.guildId, resourceId);
+            return receipt ? detail(receipt) : null;
+        },
+        preview: unavailable,
+        create: unavailable,
+        update: unavailable,
+        delete: unavailable,
+        executeAction: unavailable,
+    };
+}
+function summary(receipt) {
+    return {
+        id: receipt.receiptId,
+        revision: 1,
+        status: receipt.outcome,
+        title: receipt.source === "enhanced"
+            ? "Enhanced Auto Moderation trigger"
+            : "Native Auto Moderation trigger",
+        description: `${receipt.actionType.replaceAll("_", " ")} · ${receipt.occurredAt.toISOString()}`,
+        attributes: {
+            ruleId: receipt.ruleId,
+            source: receipt.source,
+            action: receipt.actionType,
+            outcome: receipt.outcome,
+            caseId: receipt.moderationCaseId,
+        },
+        updatedAt: receipt.createdAt.toISOString(),
+    };
+}
+function detail(receipt) {
+    return {
+        ...summary(receipt),
+        value: {
+            ruleId: receipt.ruleId,
+            ruleRevision: receipt.ruleRevision,
+            configurationRevision: receipt.configurationRevision,
+            source: receipt.source,
+            detectionMethod: receipt.detectionMethod,
+            confidenceClass: receipt.confidenceClass,
+            confidenceScore: receipt.confidenceScore,
+            effectiveThreshold: receipt.effectiveThreshold,
+            action: receipt.actionType,
+            outcome: receipt.outcome,
+            safeCode: receipt.safeCode,
+            moderationCaseId: receipt.moderationCaseId,
+            occurredAt: receipt.occurredAt.toISOString(),
+        },
+    };
+}
+function unavailable() {
+    return Promise.reject(new DashboardActionValidationError("Auto Moderation activity is read-only."));
+}
+function encodeCursor(values, binding) {
+    return Buffer.from(JSON.stringify({
+        version: 1,
+        binding,
+        values: values.map((value) => value instanceof Date ? { date: value.toISOString() } : value),
+    }), "utf8").toString("base64url");
+}
+function decodeCursor(cursor, binding) {
+    if (!cursor)
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+        if (parsed.version !== 1 ||
+            parsed.binding !== binding ||
+            !Array.isArray(parsed.values))
+            throw new Error();
+        return parsed.values.map((value) => {
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                const candidate = value;
+                if (typeof candidate.date === "string")
+                    return new Date(candidate.date);
+            }
+            if (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean")
+                return value;
+            throw new Error();
+        });
+    }
+    catch {
+        throw new DashboardActionValidationError("The Auto Moderation activity cursor is invalid.");
+    }
+}
+//# sourceMappingURL=activity-resource.js.map

package/dist/case-link-provider.d.ts

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

package/dist/case-link-provider.js

@@ -0,0 +1,13 @@
+import { AUTOMOD_CASE_LINK_CONTRACT_VERSION, AUTOMOD_CASE_LINK_PROVIDER_ID, } from "@helyx/sdk";
+import { AutoModerationRepository } from "./repository.js";
+export function createAutoModerationCaseLinkProvider() {
+    return {
+        providerId: AUTOMOD_CASE_LINK_PROVIDER_ID,
+        contractVersion: AUTOMOD_CASE_LINK_CONTRACT_VERSION,
+        disassociateCase: (context, input) => new AutoModerationRepository(context.services).disassociateCaseLinks({
+            guildId: input.guildId,
+            moderationCaseId: input.moderationCaseId,
+        }),
+    };
+}
+//# sourceMappingURL=case-link-provider.js.map

package/dist/configuration.d.ts

@@ -0,0 +1,22 @@
+export type AutoModerationMode = "standard" | "enhanced";
+export type AutoModerationSensitivity = "strict" | "balanced" | "sensitive" | "custom";
+export interface AutoModerationConfiguration {
+    configuredMode: AutoModerationMode;
+    enhancedSensitivityProfile: AutoModerationSensitivity;
+    enhancedMinimumConfidence: number;
+    enhancedCategoryOverridesEnabled: boolean;
+    enhancedLowMinimumConfidence: number;
+    enhancedMediumMinimumConfidence: number;
+    enhancedHighMinimumConfidence: number;
+    enhancedCriticalMinimumConfidence: number;
+    presetRuleEnabled: boolean;
+    genericSpamRuleEnabled: boolean;
+    mentionSpamRuleEnabled: boolean;
+    defaultNativeAlertChannelId: string | null;
+    defaultExemptRoleIds: readonly string[];
+    defaultExemptChannelIds: readonly string[];
+    repeatOffenderWindowDays: number;
+}
+export declare const DEFAULT_AUTOMOD_CONFIGURATION: AutoModerationConfiguration;
+export declare function parseAutoModerationConfiguration(input: unknown): AutoModerationConfiguration;
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,85 @@
+import { AUTOMOD_LIMITS } from "./constants.js";
+export const DEFAULT_AUTOMOD_CONFIGURATION = Object.freeze({
+    configuredMode: "standard",
+    enhancedSensitivityProfile: "balanced",
+    enhancedMinimumConfidence: 80,
+    enhancedCategoryOverridesEnabled: false,
+    enhancedLowMinimumConfidence: 80,
+    enhancedMediumMinimumConfidence: 80,
+    enhancedHighMinimumConfidence: 80,
+    enhancedCriticalMinimumConfidence: 80,
+    presetRuleEnabled: false,
+    genericSpamRuleEnabled: false,
+    mentionSpamRuleEnabled: false,
+    defaultNativeAlertChannelId: null,
+    defaultExemptRoleIds: [],
+    defaultExemptChannelIds: [],
+    repeatOffenderWindowDays: 30,
+});
+export function parseAutoModerationConfiguration(input) {
+    if (!isObject(input))
+        return { ...DEFAULT_AUTOMOD_CONFIGURATION };
+    return {
+        configuredMode: enumValue(input.configuredMode, ["standard", "enhanced"], "configuredMode", "standard"),
+        enhancedSensitivityProfile: enumValue(input.enhancedSensitivityProfile, ["strict", "balanced", "sensitive", "custom"], "enhancedSensitivityProfile", "balanced"),
+        enhancedMinimumConfidence: confidence(input.enhancedMinimumConfidence, 80),
+        enhancedCategoryOverridesEnabled: booleanValue(input.enhancedCategoryOverridesEnabled, false),
+        enhancedLowMinimumConfidence: confidence(input.enhancedLowMinimumConfidence, 80),
+        enhancedMediumMinimumConfidence: confidence(input.enhancedMediumMinimumConfidence, 80),
+        enhancedHighMinimumConfidence: confidence(input.enhancedHighMinimumConfidence, 80),
+        enhancedCriticalMinimumConfidence: confidence(input.enhancedCriticalMinimumConfidence, 80),
+        presetRuleEnabled: booleanValue(input.presetRuleEnabled, false),
+        genericSpamRuleEnabled: booleanValue(input.genericSpamRuleEnabled, false),
+        mentionSpamRuleEnabled: booleanValue(input.mentionSpamRuleEnabled, false),
+        defaultNativeAlertChannelId: optionalDiscordId(input.defaultNativeAlertChannelId, "defaultNativeAlertChannelId"),
+        defaultExemptRoleIds: discordIds(input.defaultExemptRoleIds, AUTOMOD_LIMITS.ignoredRoles, "defaultExemptRoleIds"),
+        defaultExemptChannelIds: discordIds(input.defaultExemptChannelIds, AUTOMOD_LIMITS.ignoredChannels, "defaultExemptChannelIds"),
+        repeatOffenderWindowDays: integerValue(input.repeatOffenderWindowDays, AUTOMOD_LIMITS.repeatWindowMinimumDays, AUTOMOD_LIMITS.repeatWindowMaximumDays, 30, "repeatOffenderWindowDays"),
+    };
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function enumValue(value, values, name, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "string" || !values.includes(value))
+        throw new Error(`Auto Moderation configuration contains an invalid ${name}.`);
+    return value;
+}
+function booleanValue(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "boolean")
+        throw new Error("Auto Moderation configuration requires boolean values.");
+    return value;
+}
+function confidence(value, fallback) {
+    return integerValue(value, 60, 95, fallback, "confidence threshold");
+}
+function integerValue(value, minimum, maximum, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) ||
+        value < minimum ||
+        value > maximum)
+        throw new Error(`Auto Moderation configuration contains an invalid ${name}.`);
+    return value;
+}
+function optionalDiscordId(value, name) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string" || !/^\d{17,20}$/u.test(value))
+        throw new Error(`Auto Moderation configuration contains an invalid ${name}.`);
+    return value;
+}
+function discordIds(value, maximum, name) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) ||
+        value.length > maximum ||
+        value.some((item) => typeof item !== "string" || !/^\d{17,20}$/u.test(item)))
+        throw new Error(`Auto Moderation configuration contains an invalid ${name}.`);
+    return [...new Set(value)].sort();
+}
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,30 @@
+export declare const AUTOMOD_MODULE_ID = "helyx.automod";
+export declare const AUTOMOD_PERMISSION_IDS: Readonly<{
+    readonly rulesRead: "automod.rules.read";
+    readonly rulesManage: "automod.rules.manage";
+    readonly rulesPublish: "automod.rules.publish";
+    readonly rulesReconcile: "automod.rules.reconcile";
+    readonly activityRead: "automod.activity.read";
+    readonly settingsManage: "automod.settings.manage";
+}>;
+export declare const AUTOMOD_LIMITS: Readonly<{
+    rulePageSize: 50;
+    activityPageSize: 100;
+    rulesPerGuild: 100;
+    ruleNameCharacters: 80;
+    termsPerRule: 1000;
+    termCharacters: 60;
+    regexPerRule: 10;
+    regexCharacters: 260;
+    allowListEntries: 100;
+    ignoredRoles: 20;
+    ignoredChannels: 50;
+    demotionRoles: 10;
+    importBytes: 4000;
+    repeatWindowMinimumDays: 1;
+    repeatWindowMaximumDays: 365;
+    actionReceiptRetentionDays: 90;
+    settledClaimRetentionDays: 365;
+}>;
+export declare const AUTOMOD_RULE_STATUSES: readonly ["draft", "published", "disabled", "drifted", "missing", "review"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,37 @@
+export const AUTOMOD_MODULE_ID = "helyx.automod";
+export const AUTOMOD_PERMISSION_IDS = Object.freeze({
+    rulesRead: "automod.rules.read",
+    rulesManage: "automod.rules.manage",
+    rulesPublish: "automod.rules.publish",
+    rulesReconcile: "automod.rules.reconcile",
+    activityRead: "automod.activity.read",
+    settingsManage: "automod.settings.manage",
+});
+export const AUTOMOD_LIMITS = Object.freeze({
+    rulePageSize: 50,
+    activityPageSize: 100,
+    rulesPerGuild: 100,
+    ruleNameCharacters: 80,
+    termsPerRule: 1_000,
+    termCharacters: 60,
+    regexPerRule: 10,
+    regexCharacters: 260,
+    allowListEntries: 100,
+    ignoredRoles: 20,
+    ignoredChannels: 50,
+    demotionRoles: 10,
+    importBytes: 4_000,
+    repeatWindowMinimumDays: 1,
+    repeatWindowMaximumDays: 365,
+    actionReceiptRetentionDays: 90,
+    settledClaimRetentionDays: 365,
+});
+export const AUTOMOD_RULE_STATUSES = Object.freeze([
+    "draft",
+    "published",
+    "disabled",
+    "drifted",
+    "missing",
+    "review",
+]);
+//# sourceMappingURL=constants.js.map

package/dist/contracts.d.ts

@@ -0,0 +1,30 @@
+export declare const automodDefaultPermissions: {
+    module: {
+        readonly everyone: true;
+        readonly requiredPermissions: readonly [];
+        readonly allowedRoleIds: readonly [];
+        readonly deniedRoleIds: readonly [];
+        readonly allowedUserIds: readonly [];
+        readonly deniedUserIds: readonly [];
+    };
+    commands: {
+        [k: string]: {
+            readonly everyone: false;
+            readonly accessLevel: "administrator";
+            readonly requiredPermissions: readonly [];
+            readonly allowedRoleIds: readonly [];
+            readonly deniedRoleIds: readonly [];
+            readonly allowedUserIds: readonly [];
+            readonly deniedUserIds: readonly [];
+        };
+    };
+};
+export declare const automodLogging: {
+    events: {
+        id: string;
+        name: string;
+        description: string;
+        defaultEnabled: false;
+    }[];
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.js

@@ -0,0 +1,51 @@
+import { AUTOMOD_PERMISSION_IDS } from "./constants.js";
+const administrators = {
+    everyone: false,
+    accessLevel: "administrator",
+    requiredPermissions: [],
+    allowedRoleIds: [],
+    deniedRoleIds: [],
+    allowedUserIds: [],
+    deniedUserIds: [],
+};
+const everyone = {
+    everyone: true,
+    requiredPermissions: [],
+    allowedRoleIds: [],
+    deniedRoleIds: [],
+    allowedUserIds: [],
+    deniedUserIds: [],
+};
+export const automodDefaultPermissions = {
+    module: everyone,
+    commands: Object.fromEntries(Object.values(AUTOMOD_PERMISSION_IDS).map((id) => [id, administrators])),
+};
+export const automodLogging = {
+    events: [
+        {
+            id: "automod-rule-triggered",
+            name: "Auto Moderation rule triggered",
+            description: "Records structural rule, action and outcome identifiers without message content.",
+            defaultEnabled: false,
+        },
+        {
+            id: "automod-rule-drifted",
+            name: "Auto Moderation rule drifted",
+            description: "Records that an owned Discord rule differs from its Helyx definition.",
+            defaultEnabled: false,
+        },
+        {
+            id: "automod-enhanced-detected",
+            name: "Enhanced match detected",
+            description: "Reserved for content-free Enhanced detection receipts.",
+            defaultEnabled: false,
+        },
+        {
+            id: "automod-enforcement-failed",
+            name: "Auto Moderation enforcement failed",
+            description: "Records a safe enforcement failure code without copied content.",
+            defaultEnabled: false,
+        },
+    ],
+};
+//# sourceMappingURL=contracts.js.map

package/dist/domain.d.ts

@@ -0,0 +1,61 @@
+import { AUTOMOD_TIMEOUT_SECONDS, type DiscordAutoModerationRuleDefinition, type ModerationRepeatActionPolicy } from "@helyx/sdk";
+export type AutoModerationCategory = "low" | "medium" | "high" | "critical";
+export type AutoModerationRuleKind = "keyword" | "keyword_preset" | "spam" | "mention_spam";
+export type AutoModerationRuleStatus = "draft" | "published" | "disabled" | "drifted" | "missing" | "review";
+export interface AutoModerationRuleDraft {
+    name: string;
+    category: AutoModerationCategory;
+    kind: AutoModerationRuleKind;
+    keywordFilter: readonly string[];
+    regexPatterns: readonly string[];
+    allowList: readonly string[];
+    enhancedNormalisedMatching: boolean;
+    enhancedFuzzyMatching: boolean;
+    presets: readonly ("profanity" | "sexual_content" | "slurs")[];
+    mentionTotalLimit: number;
+    mentionRaidProtectionEnabled: boolean;
+    blockMessage: boolean;
+    blockExplanation: string | null;
+    alertChannelId: string | null;
+    nativeTimeoutSeconds: (typeof AUTOMOD_TIMEOUT_SECONDS)[number] | null;
+    ignoredRoleIds: readonly string[];
+    ignoredChannelIds: readonly string[];
+    openViolationThread: boolean;
+    actionPolicy: ModerationRepeatActionPolicy;
+}
+export declare function parseRuleDraft(value: Readonly<Record<string, unknown>>): AutoModerationRuleDraft;
+export declare function toNativeDefinition(input: {
+    ruleId: string;
+    draft: AutoModerationRuleDraft;
+    enabled: boolean;
+    globalIgnoredRoleIds: readonly string[];
+    globalIgnoredChannelIds: readonly string[];
+    defaultAlertChannelId: string | null;
+}): DiscordAutoModerationRuleDefinition;
+export declare function canonicalRuleFingerprint(rule: DiscordAutoModerationRuleDefinition): string;
+export declare function enforcementClaimKey(input: {
+    guildId: string;
+    configurationRevision: string;
+    subjectUserId: string;
+    messageId: string | null;
+    channelId: string | null;
+    sourceEventId: string;
+}): string;
+export declare function enforcementClaimFingerprint(input: {
+    claimKey: string;
+    logicalRuleId: string;
+    ruleRevision: number;
+    actionFamily: string;
+}): string;
+export declare function enforcementActionFamily(policy: ModerationRepeatActionPolicy): string;
+export declare function policyFingerprint(input: {
+    ruleRevision: number;
+    configurationRevision: string;
+    actionPolicy: ModerationRepeatActionPolicy;
+    openViolationThread: boolean;
+    deleteSourceMessage?: boolean;
+    globalIgnoredRoleIds: readonly string[];
+    ruleIgnoredRoleIds: readonly string[];
+}): string;
+export declare function nativeRuleOwnershipMarker(ruleId: string): string;
+//# sourceMappingURL=domain.d.ts.map