codec::emulation

seleniumbase_rs_codec::emulation holds every wire value the stealth layer imitates. Each one was measured from a real browser by a capture tool (capture_tls, capture_hints, capture_h2) and stored as JSON under crates/codec/src/measured. The files are embedded with include_str!, parsed once, and looked up by BrowserKind and OsType. Only what was measured exists: an unmeasured pair is an error, never a nearby guess. Today the table holds chrome-155-macos.json. How the files are made and refreshed is in Wire formats.

Emulation#

#[derive(Debug, Clone, PartialEq, Eq)]pub struct Emulation {    pub kind: BrowserKind,    pub major: u32,    pub full_version: String,    pub os: OsType,    pub user_agent: String,    pub tls: TlsSpec,    pub tls_websocket: Option<TlsSpec>,    pub http2: Option<Http2Spec>,    pub headers: HeaderSpec,    pub client_hints: Option<ClientHints>,    pub provenance: Provenance,}

One measured browser on one operating system: everything a client must send to look like it. OsType and ClientHints are the core’s (seleniumbase_rs::stealth::fingerprint).

Emulation::from_json#

pub fn from_json(name: &str, json: &str) -> Result<Self, EmulationError>

Reads one measured file, for a browser the crate does not ship as well as for the embedded ones. name only labels errors. The raw evidence under the capture key is skipped; any other unknown key is an error. The entry is checked to agree with itself: the full version starts with the major version, the user agent names the browser at that major version (Chrome/155), and the header spec is valid.

Emulation::to_json#

pub fn to_json(&self) -> Result<String, EmulationError>

The entry as pretty-printed JSON, without the raw evidence. Returns EmulationError::Parse when serialization fails, which a valid entry never does.

Emulation::file_stem#

pub fn file_stem(&self) -> String

The stem the capture tools give this entry’s files, such as chrome-155-macos. An operating system without measured files is spelled other.

Provenance#

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]pub struct Provenance {    pub captured_on: String,    pub tool: String,    pub browser: String,    #[serde(default)]    pub known_gaps: Vec<KnownGap>,}

Where and how a measured entry was captured.

EmulationError#

#[derive(Debug, Clone, PartialEq, Eq, Error)]#[non_exhaustive]pub enum EmulationError {    NotMeasured { kind: BrowserKind, os: OsType },    VersionNotMeasured { kind: BrowserKind, major: u32, os: OsType },    Parse { name: String, reason: String },    TooLarge { name: String },    Inconsistent { name: String, reason: &'static str },    Headers { name: String, source: HeaderSpecError },    Duplicate { first: String, second: String },}pub type SpecError = EmulationError;

Why a measured table could not be read or looked up. SpecError is the design plan’s name for it: its NotMeasured variant is the plan’s SpecError::NotMeasured.

get#

pub fn get(kind: BrowserKind, os: OsType) -> Result<&'static Emulation, EmulationError>

The newest measured entry of a browser on an operating system. Re-exported at the crate root as get_emulation.

get_version#

pub fn get_version(    kind: BrowserKind,    os: OsType,    major: u32,) -> Result<&'static Emulation, EmulationError>

The measured entry of a browser at one major version on an operating system. NotMeasured when the pair has no capture at all, VersionNotMeasured when it has captures but not at major.

for_kind#

pub fn for_kind(kind: BrowserKind) -> &'static Emulation

The newest measured entry of a browser, whatever the system. Re-exported as emulation_for_kind. It panics if kind has no entry; the unit test every_browser_kind_has_an_entry rules that out.

measured#

pub fn measured() -> &'static [Emulation]

Every measured entry, parsed once from the embedded JSON. Re-exported as measured_emulations. It panics if an embedded file is broken; the unit tests parse every file, so a broken file cannot reach a release. Use try_measured to see the error instead.

try_measured#

pub fn try_measured() -> Result<&'static [Emulation], &'static EmulationError>

Every measured entry, or the first error met while parsing the embedded files.

newest, newest_on#

pub fn newest(entries: &[Emulation], kind: BrowserKind) -> Option<&Emulation>pub fn newest_on(entries: &[Emulation], kind: BrowserKind, os: OsType) -> Option<&Emulation>

The entry with the highest major version of kind (on os) among entries; the first of equals wins. They work on any slice, such as a table of your own read with Emulation::from_json.

measured_systems#

pub fn measured_systems(kind: BrowserKind) -> Vec<OsType>

The operating systems with a measured entry for kind, without repeats.

source_names#

pub fn source_names() -> Vec<&'static str>

The names of the embedded measured files: today ["chrome-155-macos.json"]. A file added to src/measured must be added to the crate’s list of sources too; the test tests/wire_emulation.rs fails when one is missing.

Constants#

pub const MAX_MEASURED_JSON_BYTES: usize = 16 * 1024 * 1024;

The largest measured file Emulation::from_json reads, in bytes.

Related#