@helyx/module-automod 1.0.1

package/dist/engine/configuration-cache.d.ts

@@ -0,0 +1,29 @@
+import type { CompiledEnhancedConfiguration } from "./contracts.js";
+export interface CompiledConfigurationCacheOptions {
+    maximumEntries: number;
+    maximumBytes: number;
+    maximumEntryBytes: number;
+}
+export interface CompiledConfigurationCacheMetrics {
+    entries: number;
+    bytes: number;
+    hits: number;
+    misses: number;
+    evictions: number;
+    rejectedOversize: number;
+}
+export declare class CompiledConfigurationCache {
+    #private;
+    constructor(options?: Partial<CompiledConfigurationCacheOptions>);
+    get(input: {
+        guildId: string;
+        configurationRevision: string;
+        fingerprint: string;
+    }): CompiledEnhancedConfiguration | null;
+    put(value: CompiledEnhancedConfiguration): boolean;
+    invalidateGuild(guildId: string): number;
+    invalidateRevision(guildId: string, configurationRevision: string): number;
+    clear(): void;
+    metrics(): CompiledConfigurationCacheMetrics;
+}
+//# sourceMappingURL=configuration-cache.d.ts.map

package/dist/engine/configuration-cache.js

@@ -0,0 +1,115 @@
+const DEFAULT_OPTIONS = Object.freeze({
+    maximumEntries: 1_000,
+    maximumBytes: 64 * 1_024 * 1_024,
+    maximumEntryBytes: 1_048_576,
+});
+export class CompiledConfigurationCache {
+    #options;
+    #entries = new Map();
+    #sequence = 0;
+    #bytes = 0;
+    #hits = 0;
+    #misses = 0;
+    #evictions = 0;
+    #rejectedOversize = 0;
+    constructor(options = {}) {
+        this.#options = validateOptions({ ...DEFAULT_OPTIONS, ...options });
+    }
+    get(input) {
+        const entry = this.#entries.get(key(input));
+        if (!entry) {
+            this.#misses += 1;
+            return null;
+        }
+        this.#hits += 1;
+        entry.accessed = ++this.#sequence;
+        return entry.value;
+    }
+    put(value) {
+        if (value.estimatedBytes > this.#options.maximumEntryBytes) {
+            this.#rejectedOversize += 1;
+            return false;
+        }
+        const identity = {
+            guildId: value.source.guildId,
+            configurationRevision: value.source.configurationRevision,
+            fingerprint: value.source.fingerprint,
+        };
+        const entryKey = key(identity);
+        const previous = this.#entries.get(entryKey);
+        if (previous)
+            this.#bytes -= previous.bytes;
+        this.#entries.set(entryKey, {
+            key: entryKey,
+            guildId: identity.guildId,
+            configurationRevision: identity.configurationRevision,
+            value,
+            bytes: value.estimatedBytes,
+            accessed: ++this.#sequence,
+        });
+        this.#bytes += value.estimatedBytes;
+        this.#evictToBounds();
+        return this.#entries.has(entryKey);
+    }
+    invalidateGuild(guildId) {
+        return this.#removeWhere((entry) => entry.guildId === guildId);
+    }
+    invalidateRevision(guildId, configurationRevision) {
+        return this.#removeWhere((entry) => entry.guildId === guildId &&
+            entry.configurationRevision === configurationRevision);
+    }
+    clear() {
+        this.#entries.clear();
+        this.#bytes = 0;
+    }
+    metrics() {
+        return {
+            entries: this.#entries.size,
+            bytes: this.#bytes,
+            hits: this.#hits,
+            misses: this.#misses,
+            evictions: this.#evictions,
+            rejectedOversize: this.#rejectedOversize,
+        };
+    }
+    #evictToBounds() {
+        while (this.#entries.size > this.#options.maximumEntries ||
+            this.#bytes > this.#options.maximumBytes) {
+            const oldest = [...this.#entries.values()].sort((left, right) => left.accessed - right.accessed || left.key.localeCompare(right.key))[0];
+            if (!oldest)
+                return;
+            this.#entries.delete(oldest.key);
+            this.#bytes -= oldest.bytes;
+            this.#evictions += 1;
+        }
+    }
+    #removeWhere(predicate) {
+        let removed = 0;
+        for (const [entryKey, entry] of this.#entries)
+            if (predicate(entry)) {
+                this.#entries.delete(entryKey);
+                this.#bytes -= entry.bytes;
+                removed += 1;
+            }
+        return removed;
+    }
+}
+function key(input) {
+    return JSON.stringify([
+        input.guildId,
+        input.configurationRevision,
+        input.fingerprint,
+    ]);
+}
+function validateOptions(options) {
+    if (!Number.isInteger(options.maximumEntries) ||
+        options.maximumEntries < 1 ||
+        !Number.isInteger(options.maximumBytes) ||
+        options.maximumBytes < 1 ||
+        !Number.isInteger(options.maximumEntryBytes) ||
+        options.maximumEntryBytes < 1 ||
+        options.maximumEntryBytes > options.maximumBytes)
+        throw new Error("Compiled configuration cache bounds are invalid.");
+    return Object.freeze(options);
+}
+//# sourceMappingURL=configuration-cache.js.map

package/dist/engine/contracts.d.ts

@@ -0,0 +1,82 @@
+import type { AutoModerationConfidenceClass, AutoModerationDetectionMethod, AutoModerationScannerConfigurationV1, AutoModerationScannerRuleV1, AutoModerationScannerTermKind, AutoModerationSeverity } from "@helyx/sdk";
+export declare const ENHANCED_ENGINE_VERSION = "helyx-automod-engine/1";
+export declare const ENHANCED_SCORING_VERSION = "helyx-automod-score/1";
+export declare const ENHANCED_ENGINE_LIMITS: Readonly<{
+    rules: 100;
+    termsPerRule: 1000;
+    totalTerms: 4000;
+    fuzzyTerms: 250;
+    termCharacters: 60;
+    allowListEntries: 100;
+    messageCharacters: 2000;
+    messageUtf8Bytes: 32768;
+    messageTokens: 512;
+    configurationBytes: 1048576;
+    minimumFuzzyCharacters: 4;
+    maximumFuzzyDistance: 3;
+}>;
+export type EnhancedNativeCoverage = "keyword" | "regex" | "spam" | "none";
+export type EnhancedTransformEvidence = "case_fold" | "unicode_nfkc" | "default_ignorable" | "confusable" | "leetspeak" | "separator" | "repeat_compaction" | "edit_distance";
+export interface CompiledEnhancedTerm {
+    termId: string;
+    kind: AutoModerationScannerTermKind;
+    value: string;
+    foldedTokens: readonly string[];
+    normalisedTokens: readonly string[];
+    allowList: readonly CompiledEnhancedAllowance[];
+    normalisedMatching: boolean;
+    fuzzyMatching: boolean;
+    minimumConfidence: number | null;
+    nativeCoverage: EnhancedNativeCoverage;
+    enhancedAvailable: boolean;
+}
+export interface CompiledEnhancedAllowance {
+    foldedTokens: readonly string[];
+    normalisedTokens: readonly string[];
+}
+export interface CompiledEnhancedRule extends Omit<AutoModerationScannerRuleV1, "terms"> {
+    terms: readonly CompiledEnhancedTerm[];
+}
+export interface CompiledEnhancedConfiguration {
+    source: AutoModerationScannerConfigurationV1;
+    rules: readonly CompiledEnhancedRule[];
+    estimatedBytes: number;
+    fuzzyTermCount: number;
+}
+export type EnhancedConfigurationIssueCode = "configuration_too_large" | "unsupported_engine_version" | "unsupported_scoring_version" | "invalid_threshold" | "invalid_rule" | "invalid_term" | "limit_exceeded" | "canonical_term_conflict" | "enhanced_regex_unavailable";
+export interface EnhancedConfigurationIssue {
+    code: EnhancedConfigurationIssueCode;
+    path: string;
+    message: string;
+}
+export declare class EnhancedConfigurationError extends Error {
+    readonly issues: readonly EnhancedConfigurationIssue[];
+    constructor(issues: readonly EnhancedConfigurationIssue[]);
+}
+export interface EnhancedMessageInput {
+    content: string;
+    channelId: string;
+    parentChannelId: string | null;
+    memberRoleIds: readonly string[];
+    source: "user" | "bot" | "webhook" | "system" | "unknown";
+}
+export interface EnhancedDetection {
+    ruleId: string;
+    categoryId: string;
+    termId: string;
+    severity: AutoModerationSeverity;
+    method: AutoModerationDetectionMethod;
+    confidenceScore: number;
+    confidenceClass: AutoModerationConfidenceClass;
+    effectiveThreshold: number;
+    nativeCoverage: EnhancedNativeCoverage;
+    evidence: readonly EnhancedTransformEvidence[];
+}
+export type EnhancedScanResult = {
+    outcome: "detected";
+    detection: EnhancedDetection;
+} | {
+    outcome: "not_detected" | "not_scannable" | "exempt";
+    reason: string;
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/engine/contracts.js

@@ -0,0 +1,25 @@
+export const ENHANCED_ENGINE_VERSION = "helyx-automod-engine/1";
+export const ENHANCED_SCORING_VERSION = "helyx-automod-score/1";
+export const ENHANCED_ENGINE_LIMITS = Object.freeze({
+    rules: 100,
+    termsPerRule: 1_000,
+    totalTerms: 4_000,
+    fuzzyTerms: 250,
+    termCharacters: 60,
+    allowListEntries: 100,
+    messageCharacters: 2_000,
+    messageUtf8Bytes: 32_768,
+    messageTokens: 512,
+    configurationBytes: 1_048_576,
+    minimumFuzzyCharacters: 4,
+    maximumFuzzyDistance: 3,
+});
+export class EnhancedConfigurationError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues[0]?.message ?? "Enhanced configuration is invalid.");
+        this.name = "EnhancedConfigurationError";
+        this.issues = issues;
+    }
+}
+//# sourceMappingURL=contracts.js.map

package/dist/engine/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./canonicalisation.js";
+export * from "./compile.js";
+export * from "./confidence.js";
+export * from "./configuration-cache.js";
+export * from "./contracts.js";
+export * from "./matcher.js";
+export * from "./observations.js";
+export * from "./operation-id.js";
+export * from "./similar-message-window.js";
+export * from "./term-import.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/index.js

@@ -0,0 +1,11 @@
+export * from "./canonicalisation.js";
+export * from "./compile.js";
+export * from "./confidence.js";
+export * from "./configuration-cache.js";
+export * from "./contracts.js";
+export * from "./matcher.js";
+export * from "./observations.js";
+export * from "./operation-id.js";
+export * from "./similar-message-window.js";
+export * from "./term-import.js";
+//# sourceMappingURL=index.js.map

package/dist/engine/matcher.d.ts

@@ -0,0 +1,3 @@
+import { type CompiledEnhancedConfiguration, type EnhancedMessageInput, type EnhancedScanResult } from "./contracts.js";
+export declare function scanEnhancedMessage(configuration: CompiledEnhancedConfiguration, input: EnhancedMessageInput): EnhancedScanResult;
+//# sourceMappingURL=matcher.d.ts.map

package/dist/engine/matcher.js

@@ -0,0 +1,206 @@
+import { canonicaliseText } from "./canonicalisation.js";
+import { confidenceClass, fuzzyConfidence, transformedConfidence, } from "./confidence.js";
+import { ENHANCED_ENGINE_LIMITS, } from "./contracts.js";
+const SEVERITY_RANK = {
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+};
+const METHOD_RANK = {
+    exact: 7,
+    phrase: 6,
+    wildcard: 5,
+    safe_regex: 4,
+    normalised: 3,
+    fuzzy: 2,
+    similar_message: 1,
+};
+export function scanEnhancedMessage(configuration, input) {
+    if (input.source !== "user")
+        return { outcome: "not_scannable", reason: `source_${input.source}` };
+    if (input.content.length > ENHANCED_ENGINE_LIMITS.messageCharacters ||
+        new TextEncoder().encode(input.content).byteLength >
+            ENHANCED_ENGINE_LIMITS.messageUtf8Bytes)
+        return { outcome: "not_scannable", reason: "message_size_limit" };
+    const message = canonicaliseText(withoutUrls(input.content));
+    if (message.foldedTokens.length > ENHANCED_ENGINE_LIMITS.messageTokens ||
+        message.normalisedTokens.length > ENHANCED_ENGINE_LIMITS.messageTokens)
+        return { outcome: "not_scannable", reason: "message_token_limit" };
+    const candidates = [];
+    let eligibleRules = 0;
+    for (const rule of configuration.rules) {
+        if (isExempt(rule, input))
+            continue;
+        eligibleRules += 1;
+        for (const term of rule.terms) {
+            const candidate = matchTerm(configuration, rule, term, message);
+            if (candidate)
+                candidates.push(candidate);
+        }
+    }
+    if (!eligibleRules)
+        return { outcome: "exempt", reason: "all_rules_exempt" };
+    candidates.sort(compareCandidates);
+    const detection = candidates[0];
+    return detection
+        ? { outcome: "detected", detection }
+        : { outcome: "not_detected", reason: "no_eligible_match" };
+}
+function matchTerm(configuration, rule, term, message) {
+    if (!term.enhancedAvailable || term.kind === "similar_message")
+        return null;
+    if (isAllowed(term, message))
+        return null;
+    const threshold = Math.max(configuration.source.categoryThresholds[rule.severity], term.minimumConfidence ?? 60);
+    const exact = directMatch(term, message.foldedTokens, "foldedTokens");
+    if (exact)
+        return candidate(rule, term, exact, 100, threshold, []);
+    if (term.normalisedMatching) {
+        const normalised = directMatch(term, message.normalisedTokens, "normalisedTokens");
+        if (normalised) {
+            const score = transformedConfidence(message.evidence);
+            if (score >= 90 || score >= threshold)
+                return candidate(rule, term, "normalised", score, threshold, message.evidence);
+        }
+    }
+    if (!term.fuzzyMatching ||
+        term.kind === "wildcard" ||
+        term.kind === "safe_regex")
+        return null;
+    const fuzzy = fuzzyMatch(term, message.normalisedTokens, message.evidence, threshold);
+    return fuzzy
+        ? candidate(rule, term, "fuzzy", fuzzy.score, threshold, [
+            ...message.evidence,
+            "edit_distance",
+        ])
+        : null;
+}
+function directMatch(term, messageTokens, termTokensKey) {
+    const termTokens = term[termTokensKey];
+    if (!termTokens.length)
+        return null;
+    if (term.kind === "wildcard")
+        return wildcardMatch(term.value, termTokens[0], messageTokens)
+            ? "wildcard"
+            : null;
+    if (!containsSequence(messageTokens, termTokens))
+        return null;
+    return term.kind === "phrase" || termTokens.length > 1 ? "phrase" : "exact";
+}
+function fuzzyMatch(term, messageTokens, evidence, threshold) {
+    const expected = term.normalisedTokens;
+    const length = expected.join(" ").length;
+    if (length < ENHANCED_ENGINE_LIMITS.minimumFuzzyCharacters)
+        return null;
+    const maximumDistance = fuzzyDistanceLimit(length);
+    let best = 0;
+    const windowSize = expected.length;
+    for (let index = 0; index + windowSize <= messageTokens.length; index += 1) {
+        const observed = messageTokens.slice(index, index + windowSize).join(" ");
+        if (Math.abs(observed.length - length) > maximumDistance)
+            continue;
+        const distance = boundedLevenshtein(expected.join(" "), observed, maximumDistance);
+        if (distance < 1 || distance > maximumDistance)
+            continue;
+        if (length <= 5 &&
+            !reviewedShortEdit(expected.join(" "), observed, evidence))
+            continue;
+        best = Math.max(best, fuzzyConfidence(length, distance));
+    }
+    return best >= threshold ? { score: best } : null;
+}
+function reviewedShortEdit(expected, observed, evidence) {
+    if (Math.abs(expected.length - observed.length) === 1 &&
+        (evidence.includes("separator") || evidence.includes("repeat_compaction")))
+        return true;
+    if (expected.length !== observed.length)
+        return false;
+    const changes = [...expected].flatMap((character, index) => character === observed[index] ? [] : [`${character}/${observed[index]}`]);
+    return (changes.length === 1 &&
+        ["u/v", "v/u", "i/l", "l/i", "m/n", "n/m"].includes(changes[0]));
+}
+function fuzzyDistanceLimit(length) {
+    if (length < 6)
+        return 1;
+    if (length < 10)
+        return 2;
+    return ENHANCED_ENGINE_LIMITS.maximumFuzzyDistance;
+}
+function boundedLevenshtein(left, right, maximum) {
+    if (Math.abs(left.length - right.length) > maximum)
+        return maximum + 1;
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+        const current = [leftIndex];
+        let rowMinimum = leftIndex;
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+            const cost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+            const value = Math.min(previous[rightIndex] + 1, current[rightIndex - 1] + 1, previous[rightIndex - 1] + cost);
+            current.push(value);
+            rowMinimum = Math.min(rowMinimum, value);
+        }
+        if (rowMinimum > maximum)
+            return maximum + 1;
+        previous = current;
+    }
+    return previous[right.length] ?? maximum + 1;
+}
+function isAllowed(term, message) {
+    return term.allowList.some((allowance) => containsSequence(message.foldedTokens, allowance.foldedTokens) ||
+        (term.normalisedMatching &&
+            containsSequence(message.normalisedTokens, allowance.normalisedTokens)));
+}
+function isExempt(rule, input) {
+    if (rule.exemptChannelIds.includes(input.channelId) ||
+        (input.parentChannelId !== null &&
+            rule.exemptChannelIds.includes(input.parentChannelId)))
+        return true;
+    return input.memberRoleIds.some((roleId) => rule.exemptRoleIds.includes(roleId));
+}
+function containsSequence(source, expected) {
+    if (!expected.length || expected.length > source.length)
+        return false;
+    for (let start = 0; start + expected.length <= source.length; start += 1)
+        if (expected.every((token, offset) => source[start + offset] === token))
+            return true;
+    return false;
+}
+function wildcardMatch(value, expected, tokens) {
+    const prefix = value.endsWith("*");
+    const suffix = value.startsWith("*");
+    return tokens.some((token) => {
+        if (prefix && suffix)
+            return token.includes(expected);
+        if (prefix)
+            return token.startsWith(expected);
+        return token.endsWith(expected);
+    });
+}
+function candidate(rule, term, method, confidenceScore, effectiveThreshold, evidence) {
+    return {
+        ruleId: rule.ruleId,
+        categoryId: rule.categoryId,
+        termId: term.termId,
+        severity: rule.severity,
+        method,
+        confidenceScore,
+        confidenceClass: confidenceClass(confidenceScore),
+        effectiveThreshold,
+        nativeCoverage: term.nativeCoverage,
+        evidence: [...new Set(evidence)].sort(),
+        termLength: term.normalisedTokens.join(" ").length,
+    };
+}
+function compareCandidates(left, right) {
+    return (SEVERITY_RANK[right.severity] - SEVERITY_RANK[left.severity] ||
+        right.confidenceScore - left.confidenceScore ||
+        METHOD_RANK[right.method] - METHOD_RANK[left.method] ||
+        right.termLength - left.termLength ||
+        left.ruleId.localeCompare(right.ruleId) ||
+        left.termId.localeCompare(right.termId));
+}
+function withoutUrls(value) {
+    return value.replace(/\b(?:https?:\/\/|www\.)\S+/giu, " ");
+}
+//# sourceMappingURL=matcher.js.map

package/dist/engine/observations.d.ts

@@ -0,0 +1,45 @@
+export type EnhancedMessageSource = "user" | "bot" | "webhook" | "system" | "unknown";
+export interface EnhancedGatewayMessage {
+    guildId: string;
+    channelId: string;
+    parentChannelId?: string | null;
+    messageId: string;
+    authorUserId?: string;
+    source?: EnhancedMessageSource;
+    content?: unknown;
+    observedAtMs: number;
+}
+export type EnhancedMessageObservation = {
+    outcome: "observed";
+    observation: {
+        type: "create" | "edit";
+        version: string;
+        guildId: string;
+        channelId: string;
+        parentChannelId: string | null;
+        messageId: string;
+        authorUserId: string;
+        source: EnhancedMessageSource;
+        content: string;
+        observedAtMs: number;
+    };
+} | {
+    outcome: "not_observed" | "unscannable_edit";
+    reason: "missing_content" | "source_unresolved" | "source_ineligible";
+};
+export declare class EnhancedMessageObservationCache {
+    #private;
+    constructor(options?: {
+        maximumEntries?: number;
+        ttlMs?: number;
+    });
+    observeCreate(input: EnhancedGatewayMessage): EnhancedMessageObservation;
+    observeEdit(input: EnhancedGatewayMessage): EnhancedMessageObservation;
+    metrics(): {
+        entries: number;
+        evictions: number;
+        unscannableEdits: number;
+    };
+    clear(): void;
+}
+//# sourceMappingURL=observations.d.ts.map

package/dist/engine/observations.js

@@ -0,0 +1,105 @@
+export class EnhancedMessageObservationCache {
+    #entries = new Map();
+    #maximumEntries;
+    #ttlMs;
+    #sequence = 0;
+    #evictions = 0;
+    #unscannableEdits = 0;
+    constructor(options = {}) {
+        this.#maximumEntries = options.maximumEntries ?? 50_000;
+        this.#ttlMs = options.ttlMs ?? 10 * 60_000;
+        if (!Number.isInteger(this.#maximumEntries) ||
+            this.#maximumEntries < 1 ||
+            !Number.isInteger(this.#ttlMs) ||
+            this.#ttlMs < 1 ||
+            this.#ttlMs > 10 * 60_000)
+            throw new Error("Message metadata cache bounds are invalid.");
+    }
+    observeCreate(input) {
+        const resolved = resolveMetadata(input);
+        if (resolved)
+            this.#remember(resolved, input.observedAtMs);
+        return observation("create", input, resolved);
+    }
+    observeEdit(input) {
+        this.#pruneExpired(input.observedAtMs);
+        const supplied = resolveMetadata(input);
+        const cached = this.#entries.get(input.messageId);
+        const resolved = supplied ?? cached ?? null;
+        if (!resolved && typeof input.content === "string") {
+            this.#unscannableEdits += 1;
+            return { outcome: "unscannable_edit", reason: "source_unresolved" };
+        }
+        if (supplied)
+            this.#remember(supplied, input.observedAtMs);
+        else if (cached) {
+            cached.accessed = ++this.#sequence;
+            cached.expiresAtMs = input.observedAtMs + this.#ttlMs;
+        }
+        return observation("edit", input, resolved);
+    }
+    metrics() {
+        return {
+            entries: this.#entries.size,
+            evictions: this.#evictions,
+            unscannableEdits: this.#unscannableEdits,
+        };
+    }
+    clear() {
+        this.#entries.clear();
+    }
+    #remember(input, observedAtMs) {
+        this.#entries.set(input.messageId, {
+            ...input,
+            expiresAtMs: observedAtMs + this.#ttlMs,
+            accessed: ++this.#sequence,
+        });
+        while (this.#entries.size > this.#maximumEntries) {
+            const oldest = [...this.#entries.values()].sort((left, right) => left.accessed - right.accessed ||
+                left.messageId.localeCompare(right.messageId))[0];
+            if (!oldest)
+                return;
+            this.#entries.delete(oldest.messageId);
+            this.#evictions += 1;
+        }
+    }
+    #pruneExpired(observedAtMs) {
+        for (const [messageId, entry] of this.#entries)
+            if (entry.expiresAtMs <= observedAtMs)
+                this.#entries.delete(messageId);
+    }
+}
+function resolveMetadata(input) {
+    if (!input.authorUserId || !input.source)
+        return null;
+    return {
+        guildId: input.guildId,
+        channelId: input.channelId,
+        parentChannelId: input.parentChannelId ?? null,
+        messageId: input.messageId,
+        authorUserId: input.authorUserId,
+        source: input.source,
+    };
+}
+function observation(type, input, metadata) {
+    if (typeof input.content !== "string")
+        return { outcome: "not_observed", reason: "missing_content" };
+    if (!metadata)
+        return {
+            outcome: type === "edit" ? "unscannable_edit" : "not_observed",
+            reason: "source_unresolved",
+        };
+    if (metadata.source !== "user")
+        return { outcome: "not_observed", reason: "source_ineligible" };
+    return {
+        outcome: "observed",
+        observation: {
+            type,
+            version: `${input.messageId}:${input.observedAtMs}`,
+            ...metadata,
+            content: input.content,
+            observedAtMs: input.observedAtMs,
+        },
+    };
+}
+//# sourceMappingURL=observations.js.map

package/dist/engine/operation-id.d.ts

@@ -0,0 +1,18 @@
+export interface EnhancedOperationIdentity {
+    environment: string;
+    observation: {
+        guildId: string;
+        channelId: string;
+        messageId: string;
+        type: "create" | "edit";
+        version: string;
+    };
+    configurationRevision: string;
+    detectorVersion: string;
+    ruleId: string;
+    termId: string;
+    resultClass: string;
+}
+/** Stable across Hosted and embedded observations of the same revision. */
+export declare function enhancedOperationId(input: EnhancedOperationIdentity): string;
+//# sourceMappingURL=operation-id.d.ts.map

package/dist/engine/operation-id.js

@@ -0,0 +1,24 @@
+import { AUTOMOD_ENHANCED_RESULT_PROTOCOL } from "@helyx/sdk";
+import { createHash } from "node:crypto";
+/** Stable across Hosted and embedded observations of the same revision. */
+export function enhancedOperationId(input) {
+    const values = [
+        AUTOMOD_ENHANCED_RESULT_PROTOCOL,
+        input.environment,
+        input.observation.guildId,
+        input.observation.channelId,
+        input.observation.messageId,
+        input.observation.type,
+        input.observation.version,
+        input.configurationRevision,
+        input.detectorVersion,
+        input.ruleId,
+        input.termId,
+        input.resultClass,
+    ];
+    const canonical = values
+        .map((value) => `${Buffer.byteLength(value, "utf8")}:${value}`)
+        .join("");
+    return createHash("sha256").update(canonical).digest("hex");
+}
+//# sourceMappingURL=operation-id.js.map