@helyx/module-automod 1.0.1

package/dist/domain.js

@@ -0,0 +1,274 @@
+import { AUTOMOD_TIMEOUT_SECONDS, } from "@helyx/sdk";
+import { createHash } from "node:crypto";
+import { AUTOMOD_LIMITS } from "./constants.js";
+const RULE_KINDS = [
+    "keyword",
+    "keyword_preset",
+    "spam",
+    "mention_spam",
+];
+const CATEGORIES = ["low", "medium", "high", "critical"];
+export function parseRuleDraft(value) {
+    const kind = oneOf(value.ruleKind, RULE_KINDS, "rule kind", "keyword");
+    const keywordFilter = lines(value.keywordFilter, AUTOMOD_LIMITS.termsPerRule);
+    const regexPatterns = lines(value.regexPatterns, AUTOMOD_LIMITS.regexPerRule);
+    const allowList = lines(value.allowList, AUTOMOD_LIMITS.allowListEntries);
+    const presets = [
+        value.presetProfanity === true ? "profanity" : null,
+        value.presetSexualContent === true ? "sexual_content" : null,
+        value.presetSlurs === true ? "slurs" : null,
+    ].filter((item) => Boolean(item));
+    const draft = {
+        name: boundedString(value.name, 1, AUTOMOD_LIMITS.ruleNameCharacters, "rule name"),
+        category: oneOf(value.category, CATEGORIES, "category", "medium"),
+        kind,
+        keywordFilter,
+        regexPatterns,
+        allowList,
+        enhancedNormalisedMatching: value.enhancedNormalisedMatching !== false,
+        enhancedFuzzyMatching: value.enhancedFuzzyMatching === true,
+        presets,
+        mentionTotalLimit: integer(value.mentionTotalLimit, 1, 50, 5, "mention limit"),
+        mentionRaidProtectionEnabled: value.mentionRaidProtectionEnabled === true,
+        blockMessage: value.blockMessage !== false,
+        blockExplanation: optionalString(value.blockExplanation, 150, "block explanation"),
+        alertChannelId: optionalDiscordId(value.alertChannelId, "alert channel"),
+        nativeTimeoutSeconds: timeout(value.nativeTimeoutSeconds),
+        ignoredRoleIds: discordIds(value.ignoredRoleIds, AUTOMOD_LIMITS.ignoredRoles, "ignored roles"),
+        ignoredChannelIds: discordIds(value.ignoredChannelIds, AUTOMOD_LIMITS.ignoredChannels, "ignored channels"),
+        openViolationThread: value.openViolationThread === true,
+        actionPolicy: {
+            first: action(value, "first"),
+            second: action(value, "second"),
+            thirdAndLater: action(value, "third"),
+        },
+    };
+    validateDraft(draft);
+    return draft;
+}
+export function toNativeDefinition(input) {
+    const trigger = nativeTrigger(input.draft);
+    const actions = [];
+    if (input.draft.blockMessage)
+        actions.push({
+            type: "block_message",
+            ...(input.draft.blockExplanation
+                ? { customMessage: input.draft.blockExplanation }
+                : {}),
+        });
+    const alertChannelId = input.draft.alertChannelId ?? input.defaultAlertChannelId;
+    if (alertChannelId)
+        actions.push({ type: "send_alert_message", channelId: alertChannelId });
+    if (!input.draft.blockMessage && !alertChannelId)
+        throw new Error("A rule must block messages or send a Discord alert.");
+    if (input.draft.nativeTimeoutSeconds)
+        actions.push({
+            type: "timeout",
+            durationSeconds: input.draft.nativeTimeoutSeconds,
+        });
+    return {
+        name: operationMarkedName(input.ruleId, input.draft.name),
+        enabled: input.enabled,
+        eventType: "message_send",
+        trigger,
+        actions,
+        exemptRoleIds: mergedIds(input.globalIgnoredRoleIds, input.draft.ignoredRoleIds, AUTOMOD_LIMITS.ignoredRoles),
+        exemptChannelIds: mergedIds(input.globalIgnoredChannelIds, input.draft.ignoredChannelIds, AUTOMOD_LIMITS.ignoredChannels),
+    };
+}
+export function canonicalRuleFingerprint(rule) {
+    return createHash("sha256").update(JSON.stringify(rule)).digest("hex");
+}
+export function enforcementClaimKey(input) {
+    return createHash("sha256")
+        .update(JSON.stringify([
+        input.guildId,
+        input.configurationRevision,
+        input.subjectUserId,
+        input.messageId,
+        input.channelId,
+        input.messageId === null ? input.sourceEventId : null,
+    ]))
+        .digest("hex");
+}
+export function enforcementClaimFingerprint(input) {
+    return createHash("sha256")
+        .update(JSON.stringify([
+        "helyx.automod-enforcement-claim/v2",
+        input.claimKey,
+        input.logicalRuleId,
+        input.ruleRevision,
+        input.actionFamily,
+    ]))
+        .digest("hex");
+}
+export function enforcementActionFamily(policy) {
+    return [
+        policy.first.type,
+        policy.second.type,
+        policy.thirdAndLater.type,
+    ].join(":");
+}
+export function policyFingerprint(input) {
+    return createHash("sha256").update(JSON.stringify(input)).digest("hex");
+}
+function validateDraft(draft) {
+    if (draft.kind === "keyword" &&
+        draft.keywordFilter.length + draft.regexPatterns.length < 1)
+        throw new Error("A keyword rule requires at least one keyword or safe regex.");
+    if (draft.kind === "keyword_preset" && draft.presets.length < 1)
+        throw new Error("A preset rule requires at least one Discord preset.");
+    if (draft.kind !== "keyword" && draft.regexPatterns.length)
+        throw new Error("Only keyword rules accept regex patterns.");
+    if (draft.nativeTimeoutSeconds &&
+        draft.kind !== "keyword" &&
+        draft.kind !== "mention_spam")
+        throw new Error("Discord timeout is unavailable for this rule type.");
+    for (const pattern of draft.regexPatterns)
+        if (!safeRustPattern(pattern))
+            throw new Error("A regex uses syntax that Discord Auto Moderation does not safely support.");
+}
+function nativeTrigger(draft) {
+    if (draft.kind === "keyword")
+        return {
+            type: "keyword",
+            keywordFilter: draft.keywordFilter,
+            regexPatterns: draft.regexPatterns,
+            allowList: draft.allowList,
+        };
+    if (draft.kind === "keyword_preset")
+        return {
+            type: "keyword_preset",
+            presets: draft.presets,
+            allowList: draft.allowList,
+        };
+    if (draft.kind === "mention_spam")
+        return {
+            type: "mention_spam",
+            mentionTotalLimit: draft.mentionTotalLimit,
+            mentionRaidProtectionEnabled: draft.mentionRaidProtectionEnabled,
+        };
+    return { type: "spam" };
+}
+function action(value, prefix) {
+    const type = oneOf(value[`${prefix}Action`], [
+        "case_only",
+        "delete_message",
+        "warn",
+        "timeout",
+        "kick",
+        "ban",
+        "demote",
+    ], `${prefix} action`, "case_only");
+    if (type === "timeout")
+        return {
+            type,
+            durationSeconds: timeout(value[`${prefix}TimeoutSeconds`]) ?? 300,
+        };
+    if (type === "ban")
+        return {
+            type,
+            deleteMessageSeconds: numericChoice(value[`${prefix}BanDeleteMessageSeconds`], [0, 3_600, 21_600, 86_400, 259_200, 604_800], `${prefix} ban deletion duration`, 0),
+        };
+    if (type === "demote") {
+        const roleIds = discordIds(value[`${prefix}DemoteRoleIds`], AUTOMOD_LIMITS.demotionRoles, `${prefix} demotion roles`);
+        if (!roleIds.length)
+            throw new Error("Demotion requires at least one role.");
+        return { type, roleIds };
+    }
+    return { type };
+}
+function operationMarkedName(ruleId, name) {
+    return `${nativeRuleOwnershipMarker(ruleId)} ${name}`.slice(0, 100);
+}
+export function nativeRuleOwnershipMarker(ruleId) {
+    const marker = createHash("sha256").update(ruleId).digest("hex").slice(0, 10);
+    return `[Helyx:${marker}]`;
+}
+function safeRustPattern(pattern) {
+    return (pattern.length <= AUTOMOD_LIMITS.regexCharacters &&
+        !/\\[1-9]|\(\?[=!<]|\(\?>|\(\?[a-zA-Z-]+\)/u.test(pattern));
+}
+function lines(value, maximum) {
+    if (value === undefined || value === null || value === "")
+        return [];
+    if (typeof value !== "string")
+        throw new Error("Rule lists must be text.");
+    const result = [
+        ...new Set(value
+            .split(/\r?\n|,/u)
+            .map((item) => item.trim())
+            .filter(Boolean)),
+    ];
+    if (result.length > maximum ||
+        result.some((item) => item.length > AUTOMOD_LIMITS.termCharacters))
+        throw new Error("A rule list exceeds its supported size.");
+    return result;
+}
+function boundedString(value, minimum, maximum, name) {
+    if (typeof value !== "string" ||
+        value.trim().length < minimum ||
+        value.length > maximum)
+        throw new Error(`Auto Moderation contains an invalid ${name}.`);
+    return value.trim();
+}
+function optionalString(value, maximum, name) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    return boundedString(value, 1, maximum, name);
+}
+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 contains an invalid ${name}.`);
+    return value;
+}
+function discordIds(value, maximum, name) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value) ||
+        value.length > maximum ||
+        value.some((id) => typeof id !== "string" || !/^\d{17,20}$/u.test(id)))
+        throw new Error(`Auto Moderation contains invalid ${name}.`);
+    return [...new Set(value)].sort();
+}
+function timeout(value) {
+    if (value === undefined || value === null || value === 0 || value === "0")
+        return null;
+    const numeric = typeof value === "string" ? Number(value) : value;
+    if (!AUTOMOD_TIMEOUT_SECONDS.includes(numeric))
+        throw new Error("Auto Moderation contains an invalid mute duration.");
+    return numeric;
+}
+function integer(value, minimum, maximum, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) ||
+        value < minimum ||
+        value > maximum)
+        throw new Error(`Auto Moderation contains an invalid ${name}.`);
+    return value;
+}
+function oneOf(value, values, name, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!values.includes(value))
+        throw new Error(`Auto Moderation contains an invalid ${name}.`);
+    return value;
+}
+function numericChoice(value, values, name, fallback) {
+    if (value === undefined)
+        return fallback;
+    const numeric = typeof value === "string" && /^\d+$/u.test(value) ? Number(value) : value;
+    if (!values.includes(numeric))
+        throw new Error(`Auto Moderation contains an invalid ${name}.`);
+    return numeric;
+}
+function mergedIds(left, right, maximum) {
+    const values = [...new Set([...left, ...right])].sort();
+    if (values.length > maximum)
+        throw new Error("Combined global and rule exemptions exceed Discord's limit.");
+    return values;
+}
+//# sourceMappingURL=domain.js.map

package/dist/engine/canonicalisation.d.ts

@@ -0,0 +1,9 @@
+import type { EnhancedTransformEvidence } from "./contracts.js";
+export interface CanonicalText {
+    foldedTokens: readonly string[];
+    normalisedTokens: readonly string[];
+    evidence: readonly EnhancedTransformEvidence[];
+}
+export declare function canonicaliseText(value: string): CanonicalText;
+export declare function canonicalTermKey(value: string): string;
+//# sourceMappingURL=canonicalisation.d.ts.map

package/dist/engine/canonicalisation.js

@@ -0,0 +1,150 @@
+const TOKEN = /[\p{L}\p{N}]+/gu;
+const ALPHANUMERIC = /[\p{L}\p{N}]/u;
+const FOLDABLE_SEPARATORS = new Set([
+    "<",
+    ">",
+    "{",
+    "}",
+    "[",
+    "]",
+    "(",
+    ")",
+    ".",
+    ",",
+    "_",
+    "|",
+    "/",
+    "\\",
+    "-",
+]);
+const VISUAL_MAP = Object.freeze({
+    а: "a",
+    е: "e",
+    і: "i",
+    ј: "j",
+    о: "o",
+    р: "p",
+    с: "c",
+    х: "x",
+    у: "y",
+    ɑ: "a",
+    ο: "o",
+});
+const LEET_MAP = Object.freeze({
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s",
+});
+export function canonicaliseText(value) {
+    const evidence = new Set();
+    const nfkc = value.normalize("NFKC");
+    if (nfkc !== value)
+        evidence.add("unicode_nfkc");
+    const folded = fullCaseFold(nfkc);
+    if (folded !== nfkc)
+        evidence.add("case_fold");
+    const withoutIgnorables = [...folded]
+        .filter((character) => !isDefaultIgnorable(character.codePointAt(0)))
+        .join("");
+    if (withoutIgnorables !== folded)
+        evidence.add("default_ignorable");
+    const foldedTokens = tokens(folded);
+    const mapped = mapCharacters(withoutIgnorables, evidence);
+    const joined = foldSeparators(mapped.value, evidence);
+    const compacted = compactRepeats(joined, evidence);
+    return {
+        foldedTokens,
+        normalisedTokens: tokens(compacted),
+        evidence: [...evidence].sort(),
+    };
+}
+export function canonicalTermKey(value) {
+    return canonicaliseText(value).normalisedTokens.join(" ");
+}
+function fullCaseFold(value) {
+    return value
+        .toLocaleLowerCase("und")
+        .replaceAll("ß", "ss")
+        .replaceAll("ς", "σ")
+        .replaceAll("i\u0307", "i");
+}
+function tokens(value) {
+    return [...value.matchAll(TOKEN)].map(([token]) => token);
+}
+function mapCharacters(value, evidence) {
+    let result = "";
+    for (const character of value) {
+        const visual = VISUAL_MAP[character];
+        if (visual) {
+            evidence.add("confusable");
+            result += visual;
+            continue;
+        }
+        const leet = LEET_MAP[character];
+        if (leet) {
+            evidence.add("leetspeak");
+            result += leet;
+            continue;
+        }
+        result += character;
+    }
+    return { value: result };
+}
+function foldSeparators(value, evidence) {
+    const characters = [...value];
+    return characters
+        .map((character, index) => {
+        if (!FOLDABLE_SEPARATORS.has(character))
+            return character;
+        const previous = characters[index - 1] ?? "";
+        const next = characters[index + 1] ?? "";
+        if (ALPHANUMERIC.test(previous) && ALPHANUMERIC.test(next)) {
+            evidence.add("separator");
+            return "";
+        }
+        return " ";
+    })
+        .join("");
+}
+function compactRepeats(value, evidence) {
+    let result = "";
+    let previous = "";
+    let count = 0;
+    for (const character of value) {
+        if (character === previous)
+            count += 1;
+        else {
+            previous = character;
+            count = 1;
+        }
+        if (count <= 2)
+            result += character;
+        else
+            evidence.add("repeat_compaction");
+    }
+    return result;
+}
+function isDefaultIgnorable(codePoint) {
+    return (codePoint === 0x00ad ||
+        codePoint === 0x034f ||
+        codePoint === 0x061c ||
+        codePoint === 0x115f ||
+        codePoint === 0x1160 ||
+        codePoint === 0x17b4 ||
+        codePoint === 0x17b5 ||
+        between(codePoint, 0x180b, 0x180f) ||
+        between(codePoint, 0x200b, 0x200f) ||
+        between(codePoint, 0x202a, 0x202e) ||
+        between(codePoint, 0x2060, 0x206f) ||
+        codePoint === 0xfeff ||
+        between(codePoint, 0xfe00, 0xfe0f));
+}
+function between(value, minimum, maximum) {
+    return value >= minimum && value <= maximum;
+}
+//# sourceMappingURL=canonicalisation.js.map

package/dist/engine/compile.d.ts

@@ -0,0 +1,4 @@
+import type { AutoModerationScannerConfigurationV1 } from "@helyx/sdk";
+import { type CompiledEnhancedConfiguration } from "./contracts.js";
+export declare function compileEnhancedConfiguration(source: AutoModerationScannerConfigurationV1): CompiledEnhancedConfiguration;
+//# sourceMappingURL=compile.d.ts.map

package/dist/engine/compile.js

@@ -0,0 +1,169 @@
+import { canonicaliseText, canonicalTermKey } from "./canonicalisation.js";
+import { boundedThreshold } from "./confidence.js";
+import { ENHANCED_ENGINE_LIMITS, ENHANCED_ENGINE_VERSION, ENHANCED_SCORING_VERSION, EnhancedConfigurationError, } from "./contracts.js";
+export function compileEnhancedConfiguration(source) {
+    const issues = [];
+    const serialized = JSON.stringify(source);
+    const bytes = new TextEncoder().encode(serialized).byteLength;
+    const ownedSource = deepFreeze(JSON.parse(serialized));
+    if (bytes > ENHANCED_ENGINE_LIMITS.configurationBytes)
+        issue(issues, "configuration_too_large", "$", "Enhanced configuration exceeds the one MiB compiled-input limit.");
+    if (ownedSource.engineVersion !== ENHANCED_ENGINE_VERSION)
+        issue(issues, "unsupported_engine_version", "engineVersion", `Enhanced engine version ${ownedSource.engineVersion} is unsupported.`);
+    if (ownedSource.scoringVersion !== ENHANCED_SCORING_VERSION)
+        issue(issues, "unsupported_scoring_version", "scoringVersion", `Enhanced scoring version ${ownedSource.scoringVersion} is unsupported.`);
+    validateIdentity(ownedSource, issues);
+    validateThresholds(ownedSource.categoryThresholds, issues);
+    if (ownedSource.rules.length > ENHANCED_ENGINE_LIMITS.rules)
+        issue(issues, "limit_exceeded", "rules", "Enhanced configuration contains too many rules.");
+    let termCount = 0;
+    let fuzzyTermCount = 0;
+    const owners = new Map();
+    const ruleIds = new Set();
+    const rules = ownedSource.rules.map((rule, ruleIndex) => {
+        if (ruleIds.has(rule.ruleId))
+            issue(issues, "invalid_rule", `rules[${ruleIndex}].ruleId`, "Enhanced rule IDs must be unique.");
+        ruleIds.add(rule.ruleId);
+        termCount += rule.terms.length;
+        fuzzyTermCount += rule.terms.filter((term) => term.fuzzyMatching).length;
+        return compileRule(rule, ruleIndex, owners, issues);
+    });
+    if (termCount > ENHANCED_ENGINE_LIMITS.totalTerms)
+        issue(issues, "limit_exceeded", "rules", "Enhanced configuration contains too many terms.");
+    if (fuzzyTermCount > ENHANCED_ENGINE_LIMITS.fuzzyTerms)
+        issue(issues, "limit_exceeded", "rules", `Enhanced fuzzy matching is limited to ${ENHANCED_ENGINE_LIMITS.fuzzyTerms} explicitly opted-in terms.`);
+    if (issues.length)
+        throw new EnhancedConfigurationError(issues);
+    return Object.freeze({
+        source: ownedSource,
+        rules: Object.freeze(rules),
+        estimatedBytes: bytes,
+        fuzzyTermCount,
+    });
+}
+function validateIdentity(source, issues) {
+    for (const [path, value] of [
+        ["guildId", source.guildId],
+        ["configurationRevision", source.configurationRevision],
+        ["fingerprint", source.fingerprint],
+        ["refreshAfter", source.refreshAfter],
+        ["expiresAt", source.expiresAt],
+    ])
+        if (!value)
+            issue(issues, "invalid_rule", path, `Enhanced configuration requires ${path}.`);
+}
+function compileRule(rule, ruleIndex, owners, issues) {
+    const path = `rules[${ruleIndex}]`;
+    if (!rule.ruleId || !rule.name || !rule.categoryId)
+        issue(issues, "invalid_rule", path, "Enhanced rules require stable IDs, names and category IDs.");
+    if (rule.terms.length > ENHANCED_ENGINE_LIMITS.termsPerRule)
+        issue(issues, "limit_exceeded", `${path}.terms`, "Enhanced rule contains too many terms.");
+    const seenIds = new Set();
+    const terms = rule.terms.map((term, termIndex) => {
+        if (seenIds.has(term.termId))
+            issue(issues, "invalid_term", `${path}.terms[${termIndex}].termId`, "Term IDs must be unique inside a rule.");
+        seenIds.add(term.termId);
+        registerOwner(rule, term, owners, issues, `${path}.terms[${termIndex}]`);
+        return compileTerm(term, `${path}.terms[${termIndex}]`, issues);
+    });
+    return Object.freeze({ ...rule, terms: Object.freeze(terms) });
+}
+function compileTerm(term, path, issues) {
+    const canonical = canonicaliseText(term.value);
+    const contextual = term.kind === "similar_message";
+    if (!term.termId ||
+        !term.value.trim() ||
+        (!contextual &&
+            term.kind !== "safe_regex" &&
+            term.value.length > ENHANCED_ENGINE_LIMITS.termCharacters) ||
+        (!contextual &&
+            term.kind !== "safe_regex" &&
+            canonical.normalisedTokens.length === 0))
+        issue(issues, "invalid_term", path, "Enhanced terms require an ID and one to 60 useful characters.");
+    if (term.kind === "word" && canonical.foldedTokens.length !== 1)
+        issue(issues, "invalid_term", path, "Whole-word terms must contain exactly one token.");
+    if (term.kind === "wildcard" && !validWildcard(term.value))
+        issue(issues, "invalid_term", path, "Wildcards must contain one token and use stars only at the edges.");
+    if (contextual &&
+        (term.value !== "cross-channel-similar-message" ||
+            term.normalisedMatching ||
+            term.fuzzyMatching ||
+            term.allowList.length))
+        issue(issues, "invalid_term", path, "Similar-message detectors require the canonical contextual policy.");
+    if (term.allowList.length > ENHANCED_ENGINE_LIMITS.allowListEntries)
+        issue(issues, "limit_exceeded", `${path}.allowList`, "Enhanced term allow list is too large.");
+    let minimumConfidence = null;
+    if (term.minimumConfidence !== undefined)
+        try {
+            minimumConfidence = boundedThreshold(term.minimumConfidence);
+        }
+        catch {
+            issue(issues, "invalid_threshold", `${path}.minimumConfidence`, "Term confidence threshold must be from 60 to 95.");
+        }
+    return Object.freeze({
+        ...term,
+        foldedTokens: Object.freeze(canonical.foldedTokens),
+        normalisedTokens: Object.freeze(canonical.normalisedTokens),
+        allowList: Object.freeze(term.allowList.map(compileAllowance)),
+        minimumConfidence,
+        nativeCoverage: term.kind === "safe_regex"
+            ? "regex"
+            : term.kind === "similar_message"
+                ? "spam"
+                : "keyword",
+        enhancedAvailable: term.kind !== "safe_regex",
+    });
+}
+function compileAllowance(value) {
+    const canonical = canonicaliseText(value);
+    return Object.freeze({
+        foldedTokens: Object.freeze(canonical.foldedTokens),
+        normalisedTokens: Object.freeze(canonical.normalisedTokens),
+    });
+}
+function registerOwner(rule, term, owners, issues, path) {
+    const key = canonicalTermKey(term.value.replaceAll("*", ""));
+    if (term.kind === "safe_regex" || term.kind === "similar_message")
+        return;
+    if (!key)
+        return;
+    const current = owners.get(key);
+    if (current && current.severity !== rule.severity)
+        issue(issues, "canonical_term_conflict", path, `Canonical term conflicts with ${current.ruleId}/${current.termId}; choose one severity owner explicitly.`);
+    else if (!current)
+        owners.set(key, {
+            severity: rule.severity,
+            ruleId: rule.ruleId,
+            termId: term.termId,
+        });
+}
+function validateThresholds(thresholds, issues) {
+    for (const severity of ["low", "medium", "high", "critical"])
+        try {
+            boundedThreshold(thresholds[severity]);
+        }
+        catch {
+            issue(issues, "invalid_threshold", `categoryThresholds.${severity}`, "Category confidence thresholds must be from 60 to 95.");
+        }
+}
+function validWildcard(value) {
+    const stars = [...value].filter((character) => character === "*").length;
+    if (stars < 1 ||
+        stars > 2 ||
+        (!value.startsWith("*") && !value.endsWith("*")))
+        return false;
+    const body = value.replace(/^\*/u, "").replace(/\*$/u, "");
+    return (!body.includes("*") && canonicaliseText(body).normalisedTokens.length === 1);
+}
+function issue(issues, code, path, message) {
+    issues.push({ code, path, message });
+}
+function deepFreeze(value) {
+    if (value && typeof value === "object") {
+        Object.freeze(value);
+        for (const nested of Object.values(value))
+            deepFreeze(nested);
+    }
+    return value;
+}
+//# sourceMappingURL=compile.js.map

package/dist/engine/confidence.d.ts

@@ -0,0 +1,13 @@
+import type { AutoModerationConfidenceClass, AutoModerationSeverity } from "@helyx/sdk";
+import type { EnhancedTransformEvidence } from "./contracts.js";
+export declare function confidenceThresholds(input: {
+    profile: "strict" | "balanced" | "sensitive" | "custom";
+    custom: number;
+    overridesEnabled: boolean;
+    overrides: Readonly<Record<AutoModerationSeverity, number>>;
+}): Readonly<Record<AutoModerationSeverity, number>>;
+export declare function transformedConfidence(evidence: readonly EnhancedTransformEvidence[]): number;
+export declare function fuzzyConfidence(termLength: number, distance: number): number;
+export declare function confidenceClass(score: number): AutoModerationConfidenceClass;
+export declare function boundedThreshold(value: number): number;
+//# sourceMappingURL=confidence.d.ts.map

package/dist/engine/confidence.js

@@ -0,0 +1,57 @@
+const TRANSFORM_SCORES = Object.freeze({
+    case_fold: 100,
+    unicode_nfkc: 98,
+    default_ignorable: 96,
+    confusable: 94,
+    leetspeak: 92,
+    separator: 91,
+    repeat_compaction: 90,
+});
+export function confidenceThresholds(input) {
+    const inherited = input.profile === "strict"
+        ? 90
+        : input.profile === "sensitive"
+            ? 70
+            : input.profile === "custom"
+                ? boundedThreshold(input.custom)
+                : 80;
+    return Object.freeze({
+        low: input.overridesEnabled
+            ? boundedThreshold(input.overrides.low)
+            : inherited,
+        medium: input.overridesEnabled
+            ? boundedThreshold(input.overrides.medium)
+            : inherited,
+        high: input.overridesEnabled
+            ? boundedThreshold(input.overrides.high)
+            : inherited,
+        critical: input.overridesEnabled
+            ? boundedThreshold(input.overrides.critical)
+            : inherited,
+    });
+}
+export function transformedConfidence(evidence) {
+    return evidence.reduce((lowest, item) => Math.min(lowest, TRANSFORM_SCORES[item] ?? 100), 100);
+}
+export function fuzzyConfidence(termLength, distance) {
+    if (distance <= 0)
+        return 100;
+    return Math.max(60, 100 - Math.round((72 * distance) / termLength));
+}
+export function confidenceClass(score) {
+    if (score === 100)
+        return "exact";
+    if (score >= 96)
+        return "native_equivalent";
+    if (score >= 90)
+        return "high";
+    if (score >= 80)
+        return "medium";
+    return "low";
+}
+export function boundedThreshold(value) {
+    if (!Number.isInteger(value) || value < 60 || value > 95)
+        throw new Error("Enhanced confidence thresholds must be from 60 to 95.");
+    return value;
+}
+//# sourceMappingURL=confidence.js.map