@helyx/module-automod 1.0.1

package/dist/scanner-configuration.js

@@ -0,0 +1,146 @@
+import { createHash } from "node:crypto";
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE } from "@helyx/module-manifest";
+import { AUTOMOD_ENHANCED_CONFIG_PROTOCOL, AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_SCANNER_LIMITS, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+import { AUTOMOD_MODULE_ID } from "./constants.js";
+import { buildEnhancedScannerConfiguration, } from "./enhanced-configuration.js";
+import { currentConfiguration } from "./publication.js";
+import { AutoModerationRepository, } from "./repository.js";
+const MAXIMUM_SCANNER_GUILDS = 5_000;
+const SNAPSHOT_CACHE_MS = 15_000;
+const CONFIGURATION_REFRESH_MS = 60_000;
+const CONFIGURATION_LIFETIME_MS = 15 * 60_000;
+const SNAPSHOT_READ_CONCURRENCY = 16;
+export function createScannerConfigurationSource() {
+    let cached = null;
+    let loading = null;
+    return {
+        async getPage(services, input) {
+            if (!Number.isInteger(input.limit) ||
+                input.limit < 1 ||
+                input.limit > AUTOMOD_SCANNER_LIMITS.configurationPageServers)
+                throw new Error("Enhanced configuration page size is invalid.");
+            const now = Date.now();
+            if (!cached || now - cached.createdAt >= SNAPSHOT_CACHE_MS) {
+                loading ??= buildSnapshot(services).finally(() => {
+                    loading = null;
+                });
+                cached = await loading;
+            }
+            return configurationPage(cached, input);
+        },
+        invalidate() {
+            cached = null;
+        },
+    };
+}
+async function buildSnapshot(services) {
+    const repository = new AutoModerationRepository(services);
+    const guildIds = await repository.listPublishedGuildIds(MAXIMUM_SCANNER_GUILDS);
+    const items = [];
+    for (let index = 0; index < guildIds.length; index += SNAPSHOT_READ_CONCURRENCY) {
+        const now = Date.now();
+        const configurations = await Promise.all(guildIds
+            .slice(index, index + SNAPSHOT_READ_CONCURRENCY)
+            .map((guildId) => eligibleConfiguration(services, repository, guildId, now).catch(() => null)));
+        for (const configuration of configurations)
+            if (configuration)
+                items.push(configuration);
+    }
+    items.sort((left, right) => left.guildId.localeCompare(right.guildId, "en"));
+    const fingerprint = createHash("sha256")
+        .update(JSON.stringify(items.map((item) => [
+        item.guildId,
+        item.configurationRevision,
+        item.fingerprint,
+    ])))
+        .digest("hex");
+    return {
+        createdAt: Date.now(),
+        fingerprint,
+        items: Object.freeze(items),
+    };
+}
+async function eligibleConfiguration(services, repository, guildId, now) {
+    if (!(await services
+        .get(HELYX_SERVICE_NAMES.installations)
+        .isModuleEnabled(guildId, AUTOMOD_MODULE_ID)))
+        return null;
+    const access = await services
+        .get(HELYX_SERVICE_NAMES.featureAccess)
+        .check({
+        guildId,
+        moduleId: AUTOMOD_MODULE_ID,
+        featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+    });
+    if (access.decision !== "granted")
+        return null;
+    const configuration = await currentConfiguration(services, guildId);
+    if (configuration.value.configuredMode !== "enhanced")
+        return null;
+    const rules = (await repository.listAllPublishedRules(guildId)).filter((rule) => rule.configurationRevision === configuration.revision);
+    if (!rules.length)
+        return null;
+    const item = buildEnhancedScannerConfiguration({
+        guildId,
+        configurationRevision: configuration.revision,
+        configuration: configuration.value,
+        rules: rules.map(ruleSource),
+        refreshAfter: new Date(now + CONFIGURATION_REFRESH_MS).toISOString(),
+        expiresAt: new Date(now + CONFIGURATION_LIFETIME_MS).toISOString(),
+    });
+    return encodedBytes(item) < AUTOMOD_SCANNER_LIMITS.configurationPageBytes
+        ? item
+        : null;
+}
+function configurationPage(snapshot, input) {
+    const index = input.cursor
+        ? decodeCursor(input.cursor, snapshot.fingerprint)
+        : 0;
+    const items = [];
+    for (let next = index; next < snapshot.items.length && items.length < input.limit; next += 1) {
+        const item = snapshot.items[next];
+        if (!item)
+            break;
+        const candidate = [...items, item];
+        const candidateNext = index + candidate.length;
+        const page = pageValue(snapshot, candidate, candidateNext);
+        if (encodedBytes(page) > AUTOMOD_SCANNER_LIMITS.configurationPageBytes) {
+            if (!items.length)
+                throw new Error("Enhanced configuration cannot fit in one page.");
+            break;
+        }
+        items.push(item);
+    }
+    return pageValue(snapshot, items, index + items.length);
+}
+function pageValue(snapshot, items, nextIndex) {
+    return {
+        protocol: AUTOMOD_ENHANCED_CONFIG_PROTOCOL,
+        providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+        contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+        snapshotFingerprint: snapshot.fingerprint,
+        items,
+        ...(nextIndex < snapshot.items.length
+            ? { nextCursor: encodeCursor(snapshot.fingerprint, nextIndex) }
+            : {}),
+    };
+}
+function encodeCursor(fingerprint, index) {
+    return Buffer.from(JSON.stringify({ fingerprint, index }), "utf8").toString("base64url");
+}
+function decodeCursor(cursor, fingerprint) {
+    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (decoded.fingerprint !== fingerprint ||
+        !Number.isSafeInteger(decoded.index) ||
+        decoded.index < 0 ||
+        decoded.index > MAXIMUM_SCANNER_GUILDS)
+        throw new Error("Enhanced configuration cursor is stale or invalid.");
+    return decoded.index;
+}
+function encodedBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function ruleSource(rule) {
+    return { ruleId: rule.ruleId, draft: rule.draft };
+}
+//# sourceMappingURL=scanner-configuration.js.map

package/dist/scanner-provider.d.ts

@@ -0,0 +1,5 @@
+import { type AutoModerationScannerProviderContributionV1 } from "@helyx/sdk";
+export declare function createAutoModerationScannerProvider(): AutoModerationScannerProviderContributionV1 & {
+    invalidate(): void;
+};
+//# sourceMappingURL=scanner-provider.d.ts.map

package/dist/scanner-provider.js

@@ -0,0 +1,310 @@
+import { AUTOMOD_ENHANCED_CONFIG_PROTOCOL, AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_ENHANCED_RESULT_PROTOCOL, AUTOMOD_SCANNER_LIMITS, HELYX_SERVICE_NAMES, MODERATION_ACTION_CONTRACT_VERSION, MODERATION_ACTION_PROVIDER_ID, } from "@helyx/sdk";
+import { AUTOMOD_MODULE_ID } from "./constants.js";
+import { countAutoModerationReceipt } from "./receipt-statistics.js";
+import { enforcementActionFamily, enforcementClaimFingerprint, enforcementClaimKey, } from "./domain.js";
+import { buildEnhancedScannerConfiguration, } from "./enhanced-configuration.js";
+import { ENHANCED_ENGINE_VERSION, ENHANCED_SCORING_VERSION, confidenceClass, enhancedOperationId, } from "./engine/index.js";
+import { currentConfiguration } from "./publication.js";
+import { AutoModerationRepository, } from "./repository.js";
+import { createScannerConfigurationSource } from "./scanner-configuration.js";
+import { validateEnhancedResult } from "./scanner-result-validation.js";
+export function createAutoModerationScannerProvider() {
+    const configurations = createScannerConfigurationSource();
+    return {
+        providerId: AUTOMOD_ENHANCED_PROVIDER_ID,
+        contractVersion: AUTOMOD_ENHANCED_CONTRACT_VERSION,
+        configurationProtocol: AUTOMOD_ENHANCED_CONFIG_PROTOCOL,
+        resultProtocol: AUTOMOD_ENHANCED_RESULT_PROTOCOL,
+        evidenceProtocol: AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL,
+        getConfigurationPage: (context, input) => configurations.getPage(context.services, input),
+        validateResult: validateEnhancedResult,
+        handleResult: (context, result) => handleEnhancedResult(context.services, context.evidenceReference, result),
+        invalidate() {
+            configurations.invalidate();
+        },
+    };
+}
+async function handleEnhancedResult(services, evidenceReference, result) {
+    const now = Date.now();
+    const issuedAt = Date.parse(result.issuedAt);
+    const deadlineAt = Date.parse(result.deadlineAt);
+    const observedAt = Date.parse(result.observation.observedAt);
+    if (!Number.isFinite(issuedAt) ||
+        !Number.isFinite(deadlineAt) ||
+        !Number.isFinite(observedAt) ||
+        issuedAt > now + AUTOMOD_SCANNER_LIMITS.clockSkewSeconds * 1_000 ||
+        deadlineAt <= now ||
+        deadlineAt <= issuedAt ||
+        deadlineAt - issuedAt >
+            AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000 ||
+        observedAt > issuedAt + AUTOMOD_SCANNER_LIMITS.clockSkewSeconds * 1_000 ||
+        issuedAt - observedAt > AUTOMOD_SCANNER_LIMITS.actionDeadlineSeconds * 1_000)
+        return rejected("stale");
+    const repository = new AutoModerationRepository(services);
+    const rule = await repository.findRule(result.guildId, result.ruleId);
+    const configuration = await currentConfiguration(services, result.guildId);
+    if (!rule ||
+        rule.status !== "published" ||
+        configuration.value.configuredMode !== "enhanced" ||
+        result.configurationRevision !== configuration.revision ||
+        rule.configurationRevision !== configuration.revision)
+        return rejected("stale_revision");
+    const scannerConfiguration = buildEnhancedScannerConfiguration({
+        guildId: result.guildId,
+        configurationRevision: configuration.revision,
+        configuration: configuration.value,
+        rules: [ruleSource(rule)],
+        refreshAfter: result.issuedAt,
+        expiresAt: result.deadlineAt,
+    });
+    const scannerRule = scannerConfiguration.rules[0];
+    const term = scannerRule?.terms.find(({ termId }) => termId === result.termId);
+    if (!scannerRule ||
+        !term ||
+        result.detectorVersion !== ENHANCED_ENGINE_VERSION ||
+        result.scoringVersion !== ENHANCED_SCORING_VERSION ||
+        result.categoryId !== scannerRule.categoryId ||
+        result.severity !== scannerRule.severity ||
+        result.effectiveThreshold !==
+            scannerConfiguration.categoryThresholds[result.severity] ||
+        result.confidenceScore < result.effectiveThreshold ||
+        result.confidenceClass !== confidenceClass(result.confidenceScore) ||
+        !methodAllowed(term, result.method) ||
+        scannerRule.exemptChannelIds.includes(result.channelId) ||
+        (result.parentChannelId !== null &&
+            scannerRule.exemptChannelIds.includes(result.parentChannelId)))
+        return rejected("source_unresolved");
+    const expectedOperationId = enhancedOperationId({
+        environment: result.environment,
+        observation: {
+            guildId: result.guildId,
+            channelId: result.channelId,
+            messageId: result.messageId,
+            type: result.observation.type,
+            version: result.observation.version,
+        },
+        configurationRevision: result.configurationRevision,
+        detectorVersion: result.detectorVersion,
+        ruleId: result.ruleId,
+        termId: result.termId,
+        resultClass: result.confidenceClass,
+    });
+    if (expectedOperationId !== result.operationId)
+        return rejected("invalid_envelope");
+    const actionFamily = enforcementActionFamily(rule.draft.actionPolicy);
+    const claimKey = enforcementClaimKey({
+        guildId: result.guildId,
+        configurationRevision: rule.configurationRevision,
+        subjectUserId: result.authorUserId,
+        messageId: result.messageId,
+        channelId: result.channelId,
+        sourceEventId: result.operationId,
+    });
+    const claim = await repository.claimEnforcement({
+        guildId: result.guildId,
+        claimKey,
+        rule,
+        subjectUserId: result.authorUserId,
+        channelId: result.channelId,
+        messageId: result.messageId,
+        actionFamily,
+        source: "enhanced",
+        requestFingerprint: enforcementClaimFingerprint({
+            claimKey,
+            logicalRuleId: rule.ruleId,
+            ruleRevision: rule.revision,
+            actionFamily,
+        }),
+        occurredAt: new Date(observedAt),
+    });
+    if (claim.conflict)
+        return rejected("invalid_envelope");
+    const receipt = await repository.appendEnhancedReceipt({
+        result,
+        rule,
+        claimKey,
+        occurredAt: new Date(observedAt),
+    });
+    const resumingReceipt = !receipt.created;
+    if (resumingReceipt) {
+        const existingReceipt = await repository.findReceiptByEventKey({
+            guildId: result.guildId,
+            eventKey: result.operationId,
+        });
+        if (!existingReceipt || existingReceipt.outcome !== "observed")
+            return { outcome: "duplicate", operationId: result.operationId };
+    }
+    if (!claim.created &&
+        (!resumingReceipt ||
+            claim.source !== "enhanced" ||
+            claim.outcome !== "pending")) {
+        await repository.settleReceipt({
+            guildId: result.guildId,
+            eventKey: result.operationId,
+            outcome: claim.outcome === "pending" ? "review_required" : claim.outcome,
+            ...(claim.moderationCaseId
+                ? { moderationCaseId: claim.moderationCaseId }
+                : {}),
+            safeCode: claim.safeCode ?? "first_source_won",
+        });
+        return { outcome: "duplicate", operationId: result.operationId };
+    }
+    await countEnhancedReceipt(services, result, rule.ruleId);
+    await emitEnhancedTrigger(services, result, rule.ruleId);
+    if (!services.has(HELYX_SERVICE_NAMES.moderationActions)) {
+        await settleUnavailable(repository, result, claimKey);
+        return { outcome: "accepted", operationId: result.operationId };
+    }
+    const request = {
+        operationKey: `automod:${claimKey}`,
+        detectionSource: "enhanced",
+        guildId: result.guildId,
+        subjectUserId: result.authorUserId,
+        sourceMessage: {
+            channelId: result.channelId,
+            messageId: result.messageId,
+        },
+        sourceEventId: result.operationId,
+        occurredAt: new Date(observedAt),
+        callerModuleId: AUTOMOD_MODULE_ID,
+        ruleId: rule.ruleId,
+        configurationRevision: rule.configurationRevision,
+        reasonCode: "enhanced_rule_triggered",
+        severity: rule.category,
+        confidenceClass: result.confidenceClass,
+        confidenceScore: result.confidenceScore,
+        requestKind: "detection",
+        ...(evidenceReference ? { evidenceReference } : {}),
+    };
+    let actionResult;
+    try {
+        actionResult = await 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, result, claimKey);
+        return { outcome: "accepted", operationId: result.operationId };
+    }
+    await settleActionResult(repository, result, claimKey, actionResult);
+    return { outcome: "accepted", operationId: result.operationId };
+}
+async function settleDispatchUnconfirmed(repository, result, claimKey) {
+    const safeCode = "moderation_dispatch_unconfirmed";
+    await repository.settleReceipt({
+        guildId: result.guildId,
+        eventKey: result.operationId,
+        outcome: "review_required",
+        safeCode,
+    });
+    await repository.settleClaim({
+        guildId: result.guildId,
+        claimKey,
+        outcome: "review_required",
+        safeCode,
+        occurredAt: new Date(),
+    });
+}
+function methodAllowed(term, method) {
+    if (method === "normalised")
+        return term.normalisedMatching;
+    if (method === "fuzzy")
+        return (term.fuzzyMatching && (term.kind === "word" || term.kind === "phrase"));
+    if (method === "wildcard")
+        return term.kind === "wildcard";
+    if (method === "safe_regex")
+        return term.kind === "safe_regex";
+    if (method === "similar_message")
+        return term.kind === "similar_message";
+    if (method === "phrase")
+        return term.kind === "phrase";
+    if (method === "exact")
+        return term.kind === "word";
+    return false;
+}
+async function settleActionResult(repository, result, claimKey, actionResult) {
+    const caseId = "caseId" in actionResult ? actionResult.caseId : undefined;
+    const safeCode = actionResult.outcome === "rejected"
+        ? actionResult.code
+        : "safeCode" in actionResult
+            ? actionResult.safeCode
+            : undefined;
+    await repository.settleReceipt({
+        guildId: result.guildId,
+        eventKey: result.operationId,
+        outcome: actionResult.outcome,
+        ...(caseId ? { moderationCaseId: caseId } : {}),
+        ...(safeCode ? { safeCode } : {}),
+    });
+    await repository.settleClaim({
+        guildId: result.guildId,
+        claimKey,
+        outcome: actionResult.outcome,
+        ...(caseId ? { moderationCaseId: caseId } : {}),
+        ...(actionResult.outcome === "applied" ||
+            actionResult.outcome === "already_applied"
+            ? {
+                repeatOrdinal: actionResult.offenceOrdinal,
+                selectedAction: actionResult.selectedAction.type,
+            }
+            : {}),
+        ...(safeCode ? { safeCode } : {}),
+        occurredAt: new Date(),
+    });
+}
+async function settleUnavailable(repository, result, claimKey) {
+    await repository.settleReceipt({
+        guildId: result.guildId,
+        eventKey: result.operationId,
+        outcome: "native_only",
+        safeCode: "moderation_unavailable",
+    });
+    await repository.settleClaim({
+        guildId: result.guildId,
+        claimKey,
+        outcome: "native_only",
+        safeCode: "moderation_unavailable",
+        occurredAt: new Date(),
+    });
+}
+async function countEnhancedReceipt(services, result, ruleId) {
+    await countAutoModerationReceipt(services, {
+        guildId: result.guildId,
+        ruleId,
+        eventKey: result.operationId,
+        source: "enhanced",
+        actionType: "detection",
+        occurredAt: new Date(result.observation.observedAt),
+    }).catch(() => undefined);
+}
+async function emitEnhancedTrigger(services, result, ruleId) {
+    if (!services.has(HELYX_SERVICE_NAMES.moduleLogging))
+        return;
+    await services
+        .get(HELYX_SERVICE_NAMES.moduleLogging)
+        .emit({
+        guildId: result.guildId,
+        moduleId: AUTOMOD_MODULE_ID,
+        eventId: "automod-rule-triggered",
+        summary: "An Enhanced Auto Moderation rule triggered.",
+        details: [
+            { label: "Rule", value: ruleId },
+            { label: "Method", value: result.method },
+            { label: "Outcome", value: "Validated by Helyx" },
+        ],
+        idempotencyKey: result.operationId,
+    })
+        .catch(() => undefined);
+}
+function ruleSource(rule) {
+    return { ruleId: rule.ruleId, draft: rule.draft };
+}
+function rejected(code) {
+    return { outcome: "rejected", code };
+}
+//# sourceMappingURL=scanner-provider.js.map

package/dist/scanner-result-validation.d.ts

@@ -0,0 +1,3 @@
+import { type AutoModerationEnhancedResultV1 } from "@helyx/sdk";
+export declare function validateEnhancedResult(input: unknown): AutoModerationEnhancedResultV1;
+//# sourceMappingURL=scanner-result-validation.d.ts.map

package/dist/scanner-result-validation.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_ENHANCED_RESULT_PROTOCOL, AUTOMOD_SCANNER_LIMITS, } from "@helyx/sdk";
+const snowflake = z.string().regex(/^\d{17,20}$/u);
+const safeIdentifier = z.string().min(1).max(200);
+const resultSchema = z
+    .object({
+    protocol: z.literal(AUTOMOD_ENHANCED_RESULT_PROTOCOL),
+    providerId: z.literal(AUTOMOD_ENHANCED_PROVIDER_ID),
+    contractVersion: z.literal(AUTOMOD_ENHANCED_CONTRACT_VERSION),
+    detectorVersion: safeIdentifier,
+    scoringVersion: safeIdentifier,
+    operationId: z.string().regex(/^[a-f0-9]{64}$/u),
+    nonce: z.string().regex(/^[A-Za-z0-9_-]{16,160}$/u),
+    issuedAt: z.iso.datetime({ offset: true }),
+    deadlineAt: z.iso.datetime({ offset: true }),
+    environment: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u),
+    guildId: snowflake,
+    channelId: snowflake,
+    parentChannelId: snowflake.nullable(),
+    messageId: snowflake,
+    authorUserId: snowflake,
+    observation: z
+        .object({
+        type: z.enum(["create", "edit"]),
+        version: safeIdentifier,
+        observedAt: z.iso.datetime({ offset: true }),
+    })
+        .strict(),
+    ruleId: safeIdentifier,
+    categoryId: safeIdentifier,
+    termId: safeIdentifier,
+    configurationRevision: safeIdentifier,
+    severity: z.enum(["low", "medium", "high", "critical"]),
+    method: z.enum([
+        "exact",
+        "phrase",
+        "wildcard",
+        "safe_regex",
+        "normalised",
+        "fuzzy",
+        "similar_message",
+    ]),
+    confidenceScore: z.number().int().min(0).max(100),
+    confidenceClass: z.enum([
+        "exact",
+        "native_equivalent",
+        "high",
+        "medium",
+        "low",
+    ]),
+    effectiveThreshold: z.number().int().min(60).max(100),
+    correlationId: z.uuid(),
+})
+    .strict();
+export function validateEnhancedResult(input) {
+    if (Buffer.byteLength(JSON.stringify(input), "utf8") >
+        AUTOMOD_SCANNER_LIMITS.resultBytes)
+        throw new Error("Enhanced result exceeds its byte limit.");
+    return resultSchema.parse(input);
+}
+//# sourceMappingURL=scanner-result-validation.js.map

package/dist/settings-preview.d.ts

@@ -0,0 +1,6 @@
+import type { ManagedResourceValue, ModuleSettingsPreviewContext } from "@helyx/sdk";
+export declare function previewEnhancedSettings(context: ModuleSettingsPreviewContext, input: {
+    value: Record<string, unknown>;
+    input: Readonly<Record<string, ManagedResourceValue>>;
+}): Promise<Readonly<Record<string, ManagedResourceValue>>>;
+//# sourceMappingURL=settings-preview.d.ts.map

package/dist/settings-preview.js

@@ -0,0 +1,84 @@
+import { buildEnhancedScannerConfiguration, } from "./enhanced-configuration.js";
+import { EnhancedConfigurationError, compileEnhancedConfiguration, scanEnhancedMessage, } from "./engine/index.js";
+import { parseAutoModerationConfiguration } from "./configuration.js";
+import { AutoModerationRepository } from "./repository.js";
+export async function previewEnhancedSettings(context, input) {
+    const content = input.input.content;
+    if (typeof content !== "string" || !content.trim())
+        throw new Error("Enhanced preview requires fictional message content.");
+    const configuration = parseAutoModerationConfiguration(input.value);
+    const rules = await publishedRules(context);
+    const scannerConfiguration = buildEnhancedScannerConfiguration({
+        guildId: context.guildId,
+        configurationRevision: "preview",
+        configuration,
+        rules,
+        refreshAfter: "1970-01-01T00:00:00.000Z",
+        expiresAt: "9999-12-31T23:59:59.999Z",
+    });
+    let compiled;
+    try {
+        compiled = compileEnhancedConfiguration(scannerConfiguration);
+    }
+    catch (error) {
+        if (!(error instanceof EnhancedConfigurationError))
+            throw error;
+        return {
+            outcome: "configuration_invalid",
+            issues: error.issues.map(({ code, path, message }) => ({
+                code,
+                path,
+                message,
+            })),
+        };
+    }
+    const result = scanEnhancedMessage(compiled, {
+        content,
+        channelId: "preview",
+        parentChannelId: null,
+        memberRoleIds: [],
+        source: "user",
+    });
+    if (result.outcome !== "detected")
+        return {
+            outcome: result.outcome,
+            reason: result.reason,
+            evaluatedRules: rules.length,
+            note: regexNote(compiled.rules),
+        };
+    return {
+        outcome: result.outcome,
+        ruleId: result.detection.ruleId,
+        category: result.detection.severity,
+        method: result.detection.method,
+        confidenceScore: result.detection.confidenceScore,
+        confidenceClass: result.detection.confidenceClass,
+        effectiveThreshold: result.detection.effectiveThreshold,
+        nativeCoverage: result.detection.nativeCoverage,
+        evidence: result.detection.evidence,
+        evaluatedRules: rules.length,
+        note: regexNote(compiled.rules),
+    };
+}
+async function publishedRules(context) {
+    const repository = new AutoModerationRepository(context.services);
+    const result = [];
+    let cursor = null;
+    do {
+        const page = await repository.listRules({
+            guildId: context.guildId,
+            limit: 50,
+            status: "published",
+            ...(cursor ? { cursor } : {}),
+        });
+        result.push(...page.items.map((rule) => ({ ruleId: rule.ruleId, draft: rule.draft })));
+        cursor = page.nextCursor;
+    } while (cursor);
+    return result;
+}
+function regexNote(rules) {
+    return rules.some((rule) => rule.terms.some((term) => !term.enhancedAvailable))
+        ? "Custom regex is covered by Discord native Auto Moderation only."
+        : "All evaluated terms have Enhanced matching support.";
+}
+//# sourceMappingURL=settings-preview.js.map