Enum ChallengeOutcome 

pub enum ChallengeOutcome {
    Pass,
    SoftChallenge,
    HardChallenge,
    Blocked,
    Captcha,
}

Normalised label for the outcome of a single acquisition attempt.

The taxonomy is intentionally small and stable so that policy planning, vendor classification (T89), and change-detection feeds (T88) can all agree on a shared vocabulary. Each variant carries a stable snake_case wire label and a per-outcome risk_delta that the feedback loop adds to the next runtime policy’s risk score (subject to the documented MAX_RISK_DELTA clamp).

Example

use stygian_charon::challenge_feedback::ChallengeOutcome;

let outcome = ChallengeOutcome::HardChallenge;
assert_eq!(outcome.label(), "hard_challenge");
assert!(outcome.risk_delta() > 0.0);

Variants

Pass

The request returned successfully (2xx) with no challenge artefact in the response body or headers.

SoftChallenge

The request returned a soft challenge (e.g. Cloudflare “Just a moment…” interstitial, 403 with a JS challenge script, or a slow-down page) that the runner eventually solved without raising execution mode.

HardChallenge

The request returned a hard challenge (e.g. a cf-chl-bypass token, a DataDome interstitial, an Akamai Bot Manager challenge page) that required a browser-stealth strategy.

Blocked

The request was blocked outright (e.g. 403/429 with no challenge artefact — IP-level or fingerprint-level rejection).

Captcha

The request was served a CAPTCHA (reCAPTCHA, hCaptcha, DataDome captcha-delivery, etc.) that could not be solved automatically.

Implementations

impl ChallengeOutcome

pub const fn label(self) -> &'static str

Stable, human-readable label for telemetry / JSON output.

Example

use stygian_charon::challenge_feedback::ChallengeOutcome;

assert_eq!(ChallengeOutcome::Pass.label(), "pass");
assert_eq!(ChallengeOutcome::SoftChallenge.label(), "soft_challenge");
assert_eq!(ChallengeOutcome::HardChallenge.label(), "hard_challenge");
assert_eq!(ChallengeOutcome::Blocked.label(), "blocked");
assert_eq!(ChallengeOutcome::Captcha.label(), "captcha");

pub const fn risk_delta(self) -> f64

Per-outcome risk-score contribution before clamping.

The values are bounded by MAX_RISK_DELTA so a single entry never overshoots the documented ceiling on its own. Pass carries a small negative contribution to gently de-escalate after clean runs; every other outcome contributes a non-negative amount.

Example

use stygian_charon::challenge_feedback::ChallengeOutcome;

assert!(ChallengeOutcome::Pass.risk_delta() < 0.0);
assert!(ChallengeOutcome::SoftChallenge.risk_delta() > 0.0);
assert!(ChallengeOutcome::HardChallenge.risk_delta() > 0.0);
assert!(ChallengeOutcome::Blocked.risk_delta() > 0.0);
assert!(ChallengeOutcome::Captcha.risk_delta() > 0.0);

pub const fn risk_delta_for(self, target_class: TargetClass) -> f64

Per-(outcome, target_class) risk-score contribution.

Different target classes interpret the same outcome differently: an API hitting a Captcha is anomalous (the runner should back off — sign flips to negative), while the same Captcha on a Content site is a normal anti-bot posture that warrants a higher risk score. The TargetClass::Unknown fallback returns 0.0 because the runner has no signal to act on.

Example

use stygian_charon::challenge_feedback::ChallengeOutcome;
use stygian_charon::types::TargetClass;

// API + Captcha is anomalous — sign flips to negative.
let api_captcha = ChallengeOutcome::Captcha.risk_delta_for(TargetClass::Api);
assert!(api_captcha < 0.0);

// ContentSite + Captcha is a normal anti-bot posture — positive.
let content_captcha = ChallengeOutcome::Captcha.risk_delta_for(TargetClass::ContentSite);
assert!(content_captcha > 0.0);

// Unknown class has no signal.
let unknown = ChallengeOutcome::Captcha.risk_delta_for(TargetClass::Unknown);
assert!(unknown == 0.0);

Trait Implementations

impl Clone for ChallengeOutcome

fn clone(&self) -> ChallengeOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ChallengeOutcome

impl Debug for ChallengeOutcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChallengeOutcome

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ChallengeOutcome

impl Hash for ChallengeOutcome

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ChallengeOutcome

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ChallengeOutcome

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 ChallengeOutcome