Enum Match 

pub enum Match {
    Keyword {
        patterns: Vec<String>,
        normalize: Normalize,
    },
    Regex {
        patterns: Vec<String>,
        normalize: Normalize,
        boundary_word: bool,
    },
    Link {
        patterns: Vec<String>,
    },
    Repeat {
        normalize: Normalize,
        within_secs: Option<u64>,
    },
    Rate {
        per_secs: u64,
    },
    Mentions {},
    Cohort {
        min: u32,
        quiet_max: u32,
        short_factor: u32,
        thin_ratio: Option<Ratio>,
    },
    JoinBurst {
        gap_secs: u64,
        min: u32,
    },
    TenureLt {
        secs: u64,
    },
    MessagesLte {
        n: u32,
    },
}

Phase-1 rule types. Each entry states its admissible scopes and basis; the validator rejects anything the spec does not define, so an undefined rule type can never evaluate as a silent no-op.

Variants

Keyword

Bare pattern = token-anchored (the Scunthorpe guard); *word, word*, *word* relax an edge; \* is a literal asterisk. No boundary field: the grammar makes it redundant.

Fields

patterns: Vec<String>

normalize: Normalize

Regex

Fields

patterns: Vec<String>

normalize: Normalize

boundary_word: bool

Link

Hits = distinct non-exempt registrable domains per message. Carries no span (its hit is a domain, not a text range).

Fields

patterns: Vec<String>

Repeat

Window-only. Hits = occurrences of the most-repeated normalized text by that author; ties by the normalized key ascending.

within_secs bounds the count to the densest run inside that span, so the rule measures a burst rather than a habit. Without it a daily “gm” over a seven-day window counts as seven repeats, which is a regular, not a spammer. A policy that sets it MUST declare requires: ["repeat_within"] or an older engine ignores the field and convicts where a newer one would not — the same policy_hash, two different verdicts.

Fields

normalize: Normalize

within_secs: Option<u64>

Rate

Window-only. Half-open sliding window; candidate starts are the author’s own message timestamps.

Fields

per_secs: u64

Mentions

Hits = p-tags on the message. Inline @name is NOT a mention.

Cohort

Cross-account same-skeleton clustering. Whole-only, Heuristic.

Fields

min: u32

quiet_max: u32

short_factor: u32

thin_ratio: Option<Ratio>

JoinBurst

Densest run of joins within gap_secs; earliest wins on ties.

Fields

gap_secs: u64

min: u32

TenureLt

Member-plane aggravators: citation-less, immutably family-tagged.

Fields

secs: u64

MessagesLte

Fields

n: u32

Implementations

impl Match

pub fn type_name(&self) -> &'static str

pub fn basis(&self) -> Basis

Deterministic = byte-provable and replayable by anyone. Only these feed proven, and only these may refuse.

pub fn admits(&self, scope: Scope) -> bool

Admissible scopes. A window-level quantity must not also declare per_message tiers, or both convictions enter the combinator and double-count one fact.

pub fn is_stateless(&self) -> bool

Can this rule judge ONE message on its own, with no history and no view of anyone else? Word filters and link blocks can; anything that counts across a window, or compares members to each other, cannot.

The split is what lets an ordinary member run moderation at all: their client checks its own drafts and the messages in front of it, while everything requiring historical state — repetition, rates, cohorts, tenure — belongs to an admin or a moderation bot, which has both the authority to act on it and the data to compute it honestly.

pub fn builtin_family(&self) -> Option<&'static str>

Built-in immutable family tag — the fresh-account proxies fold together so correlated signals never OR into an inflated score.

pub fn is_content_derived(&self) -> bool

Cites content (so a conviction needs at least one citable citation), or is member-state (citation-less by nature).

Trait Implementations

impl Clone for Match

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Match

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Match

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Match

impl PartialEq for Match

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Match

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Match