Struct VendorResolver 

pub struct VendorResolver { /* private fields */ }

Vendor-to-playbook resolver.

Construct with VendorResolver::with_builtin_defaults to load the four baseline rules shipped in crates/stygian-charon/data/vendor_playbook_rules/, or VendorResolver::from_rules for an empty / custom bundle.

The resolver is stateless and Send + Sync so it can be shared across threads and requests without locking.

Example

use stygian_charon::vendor_classifier::VendorClassifier;
use stygian_charon::vendor_resolver::{StrategyMarker, VendorResolver};

let resolver = VendorResolver::with_builtin_defaults();
let classifier = VendorClassifier::with_builtin_defaults();
let c = classifier.classify(
    &[],
    &std::collections::BTreeMap::new(),
    Some("harmless html"),
    "https://example.com/",
);
let r = resolver.resolve(&c);
// A clean HAR reports Unknown with confidence 0.0; the resolver
// routes that through the tier1-static rule (Unknown vendor).
assert!(r.is_resolved() || r.is_manual());

Implementations

impl VendorResolver

pub fn from_rules<I>(rules: I) -> Result<Self, VendorResolverError>

where I: IntoIterator<Item = ResolutionRule>,

Build a resolver from a pre-loaded list of ResolutionRule entries.

The rules are validated, deduplicated by id, and sorted by (priority ASC, id ASC) so the resolver’s deterministic iteration order is independent of the caller’s input order.

Errors

Returns VendorResolverError on the first invalid rule or on duplicate ids.

pub fn with_builtin_defaults() -> Self

Build a resolver seeded with the four baseline rules embedded at compile time from crates/stygian-charon/data/vendor_playbook_rules/.

The compile-time check compile_check_builtin_resolution_rules guarantees that every embedded TOML is valid; if it regresses, the build will fail.

Panics

Panics if any embedded baseline TOML fails to parse or validate. This is a compile-time failure guarded by the compile_check_builtin_resolution_rules test; the panic in production surfaces a regression in the embedded data as a hard startup error.

Example

use stygian_charon::vendor_resolver::VendorResolver;

let resolver = VendorResolver::with_builtin_defaults();
assert!(resolver.contains("tier2-hostile"));
assert!(resolver.contains("tier1-js-cloudflare"));
assert!(resolver.contains("tier1-static"));
assert!(resolver.contains("default-manual"));

pub fn contains(&self, id: &str) -> bool

true when the resolver has a rule with the given id.

pub const fn len(&self) -> usize

Number of rules currently registered.

pub const fn is_empty(&self) -> bool

true when no rules are registered.

pub fn rule_ids(&self) -> Vec<String>

Ids of all registered rules, in priority order.

pub fn resolve(&self, classification: &VendorClassification) -> VendorResolution

Resolve a VendorClassification into a VendorResolution.

The resolver iterates the rules in priority order (lowest priority number first) and fires the first rule whose confidence and score gates pass. See the module-level docs for the full resolution flow.

Example

use stygian_charon::vendor_classifier::VendorClassifier;
use stygian_charon::vendor_resolver::VendorResolver;

let resolver = VendorResolver::with_builtin_defaults();
let classifier = VendorClassifier::with_builtin_defaults();
let cookies = vec!["datadome=abc; Path=/".to_string()];
let mut headers = std::collections::BTreeMap::new();
headers.insert("x-datadome".to_string(), "protected".to_string());
let c = classifier.classify(&cookies, &headers, None, "https://example.com/");
let r = resolver.resolve(&c);
assert!(r.is_resolved());

pub fn resolve_with_playbooks( &self, classification: &VendorClassification, playbook_resolver: &PlaybookResolver, overrides: &PlaybookOverrides, ) -> Result<Option<ResolvedPlaybook>, ValidationError>

Convenience helper that resolves a classification and then resolves the matched playbook through a PlaybookResolver.

Returns None when the resolver returned the Manual strategy marker, mirroring the “non-breaking integration with existing manual mode selection” guarantee — the caller keeps its manual mode selection rather than receiving a ResolvedPlaybook.

Errors

Returns crate::playbooks::ValidationError when the resolver picked a playbook id the PlaybookResolver does not have registered.

Trait Implementations

impl Clone for VendorResolver

fn clone(&self) -> VendorResolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VendorResolver

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

Formats the value using the given formatter.