Adler Core

https://docs.rs/adler-core
Admin
Adler Core is the core engine for the Adler OSINT username-search tool, providing runtime-agnostic...
Tokens:760,830
Snippets:7,502
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Mock Server Setup for Basic Response

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Starts a mock server and defines a basic mock that responds with a 200 OK status and a simple HTML body. This is a foundational setup for testing client interactions.

```rust
        let server = MockServer::start().await;
        Mock::given(any())
            .respond_with(
                ResponseTemplate::new(200)
                    .set_body_string(r###"<html><h1 class="name">Alice Example</h1></html>"###),
            )
            .mount(&server)
            .await;
```

--------------------------------

### Quick Start: Scanning for a Username

Source: https://docs.rs/adler-core/latest/adler_core?search=

This example demonstrates how to load the default embedded registry, filter sites, and scan for a specific username, printing any found matches.

```APIDOC
## Quick start
Scan the embedded 1,900-entry main registry for one username and print the hits:
```rust
use adler_core::{Client, ExecutorOptions, MatchKind, Registry, Username, executor};

let registry = Registry::default_embedded()?;

// filter(include, exclude, tags, exclude_tags, include_nsfw)
// — empty slices = no name/tag filter; `false` keeps the
// default NSFW auto-exclusion (matches Sherlock's `--nsfw`
// opt-in). Pass `true` (or `&["nsfw".into()]` as tags) to
// scan adult-content sites.
let sites = registry.filter(&[], &[], &[], &[], false);

let username = Username::new("torvalds")?;
let client = Client::builder().build()?;

let outcomes =
    executor::run(&client, &sites, &username, ExecutorOptions::default()).await;

for outcome in outcomes.iter().filter(|o| o.kind == MatchKind::Found) {
    println!("{} → {}", outcome.site, outcome.url);
}
```
```

--------------------------------

### Mock Server Setup for Basic Response

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up a mock server to respond with a 200 status code and a simple HTML body. This is a basic setup for testing client interactions.

```Rust
    let server = MockServer::start().await;
    Mock::given(any())
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_string(r###"<html><h1 class="name">Alice Example</h1></html>"###),
        )
        .mount(&server)
        .await;
```

--------------------------------

### Mock Server Setup for Specific Header and Response

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Starts a mock server and configures a mock to respond to any request that includes a specific 'cookie' header. This is used for testing session-based authentication flows.

```rust
        let server = MockServer::start().await;
        Mock::given(any())
            .and(wiremock::matchers::header("cookie", "sessionid=real"))
            .respond_with(
                ResponseTemplate::new(200)
                    .set_body_string(r###"<html><h1 class="name">Alice Example</h1></html>"###),
            )
            .mount(&server)
            .await;
```

--------------------------------

### Fetch Data and Handle Browser Setup Errors

Source: https://docs.rs/adler-core/latest/src/adler_core/browser/flaresolverr.rs.html?search=

Demonstrates fetching data from a URL using the FlareSolverr backend and matching specific browser setup errors.

```rust
let err = backend
    .fetch(
        &Url::parse("https://example.com").unwrap(),
        &BTreeMap::new(),
        Duration::from_secs(10),
    )
    .await
    .unwrap_err();
match err {
    Error::BrowserSetup { message } => {
        assert!(message.contains("non-ok"), "got: {message}");
        assert!(message.contains("Could not solve"), "got: {message}");
    }
    other => panic!("expected Error::BrowserSetup, got {other:?}"),
}
```

--------------------------------

### Example Searches

Source: https://docs.rs/adler-core/latest/src/adler_core/confidence.rs.html?search=

Illustrative examples of search queries that can be performed, covering common Rust patterns and types.

```text
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Example Searches in FlareSolverr

Source: https://docs.rs/adler-core/latest/adler_core/browser/flaresolverr/index.html?search=

These are example search queries that can be used with FlareSolverr. They demonstrate different types of search patterns, including standard library modules, type conversions, and generic type transformations.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Client::builder

Source: https://docs.rs/adler-core/latest/adler_core/struct.Client.html

Starts the configuration process for a new client instance by returning a `ClientBuilder`.

```APIDOC
## Client::builder

### Description
Start configuring a new client.

### Method
`fn builder() -> ClientBuilder`
```

--------------------------------

### Running FlareSolverr with Docker

Source: https://docs.rs/adler-core/latest/src/adler_core/browser/flaresolverr.rs.html?search=

Instructions on how to run the official FlareSolverr Docker image. This is the recommended setup for using the FlareSolverr backend.

```bash
docker run -d -p 8191:8191 
ghcr.io/flaresolverr/flaresolverr:latest
```

--------------------------------

### Setup FlareSolverr Backend

Source: https://docs.rs/adler-core/latest/adler_core/browser/flaresolverr/index.html?search=std%3A%3Avec

Run the official FlareSolverr Docker image and configure Adler to use it by providing the service URL.

```bash
docker run -d -p 8191:8191 ghcr.io/flaresolverr/flaresolverr:latest
```

```bash
adler --flaresolverr http://localhost:8191 alice
```

--------------------------------

### Start client configuration

Source: https://docs.rs/adler-core/latest/adler_core/struct.Client.html

Initiates the configuration process for a new client by returning a `ClientBuilder`. Use this to set up custom client parameters before creation.

```rust
pub fn builder() -> ClientBuilder
```

--------------------------------

### Setting up Mock HTTP Server and Site Configuration

Source: https://docs.rs/adler-core/latest/src/adler_core/doctor.rs.html?search=

Starts a mock HTTP server and defines a Site configuration. The Site includes a URL template that uses the mock server's URI and specifies expected signals and known present/absent patterns.

```rust
let http_server = MockServer::start().await;
let url_template = format!("{}/{{username}}", http_server.uri());
let s = Site {
    name: "MockBP".into(),
    url: UrlTemplate::new(url_template).unwrap(),
    signals: vec![Signal::StatusFound { codes: vec![200] }],
    known_present: Some(KnownPresent::Single("torvalds".into())),
    known_absent: None,
    extract: Vec::new(),
    tags: vec![BOT_PROTECTED_TAG.into()],
    request_headers: std::collections::BTreeMap::new(),
    regex_check: None,
    engine: None,
    strip_bad_char: None,
    request_method: crate::site::HttpMethod::Get,
    request_body: None,
    protection: Vec::new(),
    disabled: false,
    disabled_reason: None,
};
```

--------------------------------

### HTTP Method Example

Source: https://docs.rs/adler-core/latest/adler_core/struct.Site.html?search=

Specifies the HTTP method used for probing the site. Defaults to GET, but some sites may require POST.

```rust
pub request_method: HttpMethod,
// Example: HttpMethod::POST
```

--------------------------------

### Run FlareSolverr Docker Image

Source: https://docs.rs/adler-core/latest/adler_core/browser/flaresolverr/index.html?search=

This command starts the official FlareSolverr Docker image in detached mode and maps port 8191. Ensure Docker is installed and running.

```bash
docker run -d -p 8191:8191 ghcr.io/flaresolverr/flaresolverr:latest
```

--------------------------------

### Initialize Browser Backend and Site Configuration

Source: https://docs.rs/adler-core/latest/src/adler_core/doctor.rs.html

This snippet shows how to connect to a mock CDP server, initialize a `BrowserbaseBackend`, and configure a `Site` struct for testing. The `Site` includes details like name, URL template, expected signals, and tags like `BOT_PROTECTED_TAG`.

```rust
let cdp = CdpClient::connect(&server.ws_url()).await.unwrap();
let backend: std::sync::Arc<dyn BrowserBackend> = 
    std::sync::Arc::new(BrowserbaseBackend::from_parts(cdp, "test-session".into()));

let http_server = MockServer::start().await;
let url_template = format!("{}/{{username}}", http_server.uri());
let s = Site {
    name: "MockBP".into(),
    url: UrlTemplate::new(url_template).unwrap(),
    signals: vec![Signal::StatusFound { codes: vec![200] }],
    known_present: Some(KnownPresent::Single("torvalds".into())),
    known_absent: None,
    extract: Vec::new(),
    tags: vec![BOT_PROTECTED_TAG.into()],
    request_headers: std::collections::BTreeMap::new(),
    regex_check: None,
    engine: None,
    strip_bad_char: None,
    request_method: crate::site::HttpMethod::Get,
    request_body: None,
    protection: Vec::new(),
    disabled: false,
```

--------------------------------

### Mock Server Setup for Basic 200 Response

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Initializes a mock server and sets up a catch-all mock to respond with a 200 OK status. This is a minimal server configuration for testing client requests.

```rust
        let server = MockServer::start().await;
        Mock::given(any())
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
```

--------------------------------

### HttpFetcher::fetch - GET request with body

Source: https://docs.rs/adler-core/latest/src/adler_core/transport.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Handles GET requests when the response body is explicitly needed. The request is sent as a standard GET request.

```rust
HttpMethod::Get if req.want_body => {
                send(
                    &self.inner,
                    reqwest::Method::GET,
                    req.url,
                    req.user_agent,
                    req.headers,
                    None,
                )
                .await
            }
```

--------------------------------

### Client Configuration and Site Checking

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates building a client with specific configurations (like zero min request interval and zero retries) and checking two sites: one disallowed by robots.txt and one allowed. This is useful for testing client behavior under different constraints.

```rust
Mock::given(any())
            .and(path("/yes/alice"))
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
        let client = Client::builder()
            .min_request_interval(Duration::ZERO)
            .max_retries(0)
            .respect_robots(true)
            .build()
            .unwrap();

        let disallowed = Site {
            name: "No".into(),
            url: UrlTemplate::new(format!( "{}/no/{{username}}", server.uri())).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };
        let allowed = Site {
            name: "Yes".into(),
            url: UrlTemplate::new(format!( "{}/yes/{{username}}", server.uri())).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };

        let no = client.check(&disallowed, &user()).await;
        assert_eq!(no.kind, MatchKind::Uncertain);
        assert_eq!(no.reason, Some(UncertainReason::RobotsDisallowed));

        let yes = client.check(&allowed, &user()).await;
        assert_eq!(yes.kind, MatchKind::Found);
```

--------------------------------

### Example Search: std::vec

Source: https://docs.rs/adler-core/latest/adler_core/browser/cdp/struct.CdpEvent.html?search=

Demonstrates searching for the `std::vec` type. This is a common search pattern for standard library collections.

```text
std::vec
```

--------------------------------

### UrlTemplate Search Examples

Source: https://docs.rs/adler-core/latest/adler_core/struct.UrlTemplate.html?search=

Examples of how to perform searches related to UrlTemplate.

```APIDOC
## UrlTemplate Search

### Description
Provides examples of search queries that can be used with UrlTemplate.

### Example Searches

*   `std::vec`
*   `u32 -> bool`
*   `Option<T>, (T -> U) -> Option<U>`
```

--------------------------------

### Client Configuration and Site Checking

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=

Demonstrates building a client with specific settings and checking two sites, one disallowed and one allowed, against user criteria. It asserts the expected outcome for each check.

```rust
Mock::given(any())
            .and(path("/yes/alice"))
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
        let client = Client::builder()
            .min_request_interval(Duration::ZERO)
            .max_retries(0)
            .respect_robots(true)
            .build()
            .unwrap();

        let disallowed = Site {
            name: "No".into(),
            url: UrlTemplate::new(format!(‘{}/no/{{username}}’, server.uri())).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };
        let allowed = Site {
            name: "Yes".into(),
            url: UrlTemplate::new(format!(‘{}/yes/{{username}}’, server.uri())).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };

        let no = client.check(&disallowed, &user()).await;
        assert_eq!(no.kind, MatchKind::Uncertain);
        assert_eq!(no.reason, Some(UncertainReason::RobotsDisallowed));

        let yes = client.check(&allowed, &user()).await;
        assert_eq!(yes.kind, MatchKind::Found);
    }
```

--------------------------------

### Configure and Test Client with Mock Server

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Sets up a mock server to simulate responses for 'yes' and 'no' paths. Demonstrates client configuration with zero retries and respecting robots.txt. Tests client behavior against disallowed and allowed sites, asserting expected match kinds and reasons.

```rust
Mock::given(any())
            .and(path("/yes/alice"))
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
        let client = Client::builder()
            .min_request_interval(Duration::ZERO)
            .max_retries(0)
            .respect_robots(true)
            .build()
            .unwrap();

        let disallowed = Site {
            name: "No".into(),
            url: UrlTemplate::new(format!({"}/no/{{username}}", server.uri()))).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };
        let allowed = Site {
            name: "Yes".into(),
            url: UrlTemplate::new(format!({"}/yes/{{username}}", server.uri()))).unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
            access: crate::AccessPolicy::default(),
        };

        let no = client.check(&disallowed, &user()).await;
        assert_eq!(no.kind, MatchKind::Uncertain);
        assert_eq!(no.reason, Some(UncertainReason::RobotsDisallowed));

        let yes = client.check(&allowed, &user()).await;
        assert_eq!(yes.kind, MatchKind::Found);
    }
```

--------------------------------

### Registry Search Examples

Source: https://docs.rs/adler-core/latest/adler_core/struct.Registry.html?search=

Examples of how to perform searches within the registry.

```APIDOC
## Search Operations

This section details how to search and filter registries.

### Example Searches

*   `std::vec`
*   `u32 -> bool`
*   `Option<T>, (T -> U) -> Option<U>`
```

--------------------------------

### Initialize ClientBuilder

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Use `Client::builder()` to start configuring a new HTTP client. This is the entry point for setting up custom client configurations.

```rust
pub fn builder() -> ClientBuilder {
        ClientBuilder::default()
    }
```

--------------------------------

### EgressSpec Search Examples

Source: https://docs.rs/adler-core/latest/adler_core/struct.EgressSpec.html?search=

Demonstrates example searches for EgressSpec, illustrating common patterns and type conversions.

```APIDOC
## Example Searches

### Basic Search

```
std::vec
```

### Type Conversion Search

```
u32 -> bool
```

### Generic Type Conversion Search

```
Option<T>, (T -> U) -> Option<U>
```
```

--------------------------------

### build

Source: https://docs.rs/adler-core/latest/src/adler_core/client/builder.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Builds and returns a configured `Client` instance.

```APIDOC
## build

### Description
Builds and returns a configured `Client` instance.

### Method
`build(self) -> Result<Client>`

### Returns
* `Result<Client>` - A `Result` containing the `Client` on success, or an error if building fails.
```

--------------------------------

### HttpFetcher::fetch - GET request without body (HEAD)

Source: https://docs.rs/adler-core/latest/src/adler_core/transport.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Handles GET requests when the response body is not needed. It attempts to use a HEAD request first. If the server rejects HEAD (e.g., with a 405 status), it retries with a GET request.

```rust
HttpMethod::Get => {
                match send(
                    &self.inner,
                    reqwest::Method::HEAD,

```

--------------------------------

### Create a sample Site for testing

Source: https://docs.rs/adler-core/latest/src/adler_core/cache.rs.html?search=std%3A%3Avec

A helper function to create a `Site` struct with predefined values, useful for unit tests.

```rust
fn site(name: &str) -> Site {
        Site {
            name: name.into(),
            url: UrlTemplate::new("https://example.com/{username}").unwrap(),
            signals: vec![Signal::StatusFound { codes: vec![200] }],
            known_present: None,
            known_absent: None,
            extract: Vec::new(),
            tags: Vec::new(),
            request_headers: std::collections::BTreeMap::new(),
            regex_check: None,
            engine: None,
            strip_bad_char: None,
            request_method: crate::site::HttpMethod::Get,
            request_body: None,
            protection: Vec::new(),
            disabled: false,
            disabled_reason: None,
            source: None,
            popularity: None,
        }
    }
```

--------------------------------

### Get Egress Pool Summary

Source: https://docs.rs/adler-core/latest/src/adler_core/access.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a read-only summary of the `EgressPool`, returning a vector of `EgressSummary` structs. This is used by the `GET /api/access` endpoint.

```rust
pub(crate) fn summary(&self) -> Vec<EgressSummary> {
        self.entries
            .iter()
            .map(|e| EgressSummary {
                name: e.name.clone(),
                country: e.country.clone(),
                kind: e.kind,
            })
            .collect()
    }

```

--------------------------------

### Test Client Setup

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Helper function to build a test client using default configurations. This is typically used in unit tests to create a client instance for testing purposes.

```rust
fn build_client() -> Client {
        test_client()
    }
```

--------------------------------

### ProfileEvidence::from_avatar_hash example

Source: https://docs.rs/adler-core/latest/src/adler_core/check.rs.html?search=u32+-%3E+bool

Demonstrates the creation of `ProfileEvidence` using the `from_avatar_hash` associated function. This specific example uses a mock avatar hash and score.

```Rust
let mut outcome = CheckOutcome {
    site: "Example".to_owned(),
    url: "https://example.com/alice".to_owned(),
    kind: MatchKind::Found,
    reason: None,
    elapsed_ms: 10,
    enrichment: std::collections::BTreeMap::new(),
    evidence: vec!["HTTP 200 (status_found)".to_owned()],
    profile_evidence: vec![ProfileEvidence::from_avatar_hash(
        "Example",
        "https://example.com/alice",
        "dhash64_v1:0123456789abcdef",
        Some(100),
    )],
    confidence: ConfidenceScore::default(),
    transport: None,
    escalations: 0,
};
```

--------------------------------

### Client Configuration and Successful Check

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Demonstrates building a client with specific configurations (timeout, retries, backoff delays) and performing a successful check against a site, expecting a 'Found' match.

```Rust
Mock::given(any())
            .and(path("/alice"))
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
        let site = site_with(&server, vec![Signal::StatusFound { codes: vec![200] }]);
        let client = Client::builder()
            .timeout(Duration::from_secs(2))
            .min_request_interval(Duration::ZERO)
            .max_retries(2)
            .base_backoff_delay(Duration::from_millis(20))
            .max_backoff_delay(Duration::from_millis(100))
            .build()
            .unwrap();
        let outcome = client.check(&site, &user()).await;
        assert_eq!(outcome.kind, MatchKind::Found);
        assert!(outcome.reason.is_none());
```

--------------------------------

### Fetch Request Dispatch Logic

Source: https://docs.rs/adler-core/latest/src/adler_core/transport.rs.html?search=std%3A%3Avec

Handles different HTTP methods for fetch requests. GET requests are initially sent as HEAD to check for 405 errors, retrying as GET if necessary. POST requests are sent directly. This logic aims to optimize resource usage by avoiding unnecessary GET requests when only headers are needed.

```rust
let sent = match req.method {
                HttpMethod::Post => {
                    send(
                        &self.inner,
                        wreq::Method::POST,
                        req.url,
                        req.user_agent,
                        req.headers,
                        req.body,
                    )
                    .await
                }
                HttpMethod::Get if req.want_body => {
                    send(
                        &self.inner,
                        wreq::Method::GET,
                        req.url,
                        req.user_agent,
                        req.headers,
                        None,
                    )
                    .await
                }
                HttpMethod::Get => {
                    match send(
                        &self.inner,
                        wreq::Method::HEAD,
                        req.url,
                        req.user_agent,
                        req.headers,
                        None,
                    )
                    .await
                    {
                        Ok(r) if r.status().as_u16() == 405 => {
                            send(
                                &self.inner,
                                wreq::Method::GET,
                                req.url,
                                req.user_agent,
                                req.headers,
                                None,
                            )
                            .await
                        }
                        other => other,
                    }
                }
            };
```

--------------------------------

### LocalBackend::launch

Source: https://docs.rs/adler-core/latest/adler_core/browser/local/struct.LocalBackend.html?search=

Launches a fresh headless Chrome process with the given configuration. This is the primary method for starting a new browser instance.

```APIDOC
## LocalBackend::launch

### Description
Launch a fresh headless Chrome process.

### Method
`async fn launch(cfg: LocalConfig) -> Result<Self>`

### Parameters
* `cfg` (LocalConfig) - The configuration for the local browser instance.

### Errors
* `Error::BrowserSetup` - If Chrome cannot be located or the process fails to start.
```

--------------------------------

### ScanSchedule: Immediate Due Time Without Start or Previous Run

Source: https://docs.rs/adler-core/latest/src/adler_core/watchlist.rs.html?search=std%3A%3Avec

Tests the `ScanSchedule` behavior when no start time or previous run is provided, indicating it should be due immediately.

```rust
let schedule = ScanSchedule {
    every_secs: 60,
    start_at_ms: None,
};

assert_eq!(schedule.next_due_ms(None), 0);
assert!(schedule.is_due(None, 1));
```

--------------------------------

### Build Client with Custom Settings

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Demonstrates building a client with custom timeout and minimum request interval settings. Ensures subsequent requests adhere to these intervals.

```rust
let client = Client::builder()
    .timeout(Duration::from_secs(2))
    .min_request_interval(Duration::from_millis(300))
    .build()
    .unwrap();

client.check(&site, &user()).await;
let started = Instant::now();
client.check(&site, &user()).await;
let elapsed = started.elapsed();
assert!(
    elapsed >= Duration::from_millis(200),
    "second probe to the same host should wait ≥200 ms, got {elapsed:?}",
);
```

--------------------------------

### Calculate Next Due Time

Source: https://docs.rs/adler-core/latest/src/adler_core/watchlist.rs.html?search=u32+-%3E+bool

Calculates the millisecond timestamp for the next scheduled scan, considering the last scan start time and the schedule's start time.

```APIDOC
## next_due_ms

### Description
Calculates the millisecond timestamp for the next scheduled scan, considering the last scan start time and the schedule's start time.

### Method
`next_due_ms(&self, last_started_at_ms: Option<u64>) -> u64`

### Parameters
- `last_started_at_ms` (Option<u64>): The timestamp of the previous scan start for this schedule. `None` if the first scan has not run yet.

### Returns
- `u64`: The millisecond timestamp when the next scan is due.
```

--------------------------------

### Calculate Next Watchlist Scan Time

Source: https://docs.rs/adler-core/latest/src/adler_core/watchlist.rs.html?search=

Calculates the millisecond timestamp for the next scheduled scan, considering the last scan start time and the schedule's defined start time.

```rust
pub fn next_due_ms(&self, last_started_at_ms: Option<u64>) -> u64 {
        let interval_ms = self.every_secs.saturating_mul(1_000);
        let due_after_last = last_started_at_ms.map(|last| last.saturating_add(interval_ms));
        match (due_after_last, self.start_at_ms) {
            (Some(due), Some(start_at)) => due.max(start_at),
            (Some(due), None) => due,
            (None, Some(start_at)) => start_at,
            (None, None) => 0,
        }
    }
```

--------------------------------

### Initializing BrowserbaseBackend with Mock CDP

Source: https://docs.rs/adler-core/latest/src/adler_core/doctor.rs.html?search=

Connects to the mock CDP server and initializes a BrowserbaseBackend, which is then used as a browser backend for other operations.

```rust
let cdp = CdpClient::connect(&server.ws_url()).await.unwrap();
let backend: std::sync::Arc<dyn BrowserBackend> =
    std::sync::Arc::new(BrowserbaseBackend::from_parts(cdp, "test-session".into()));
```

--------------------------------

### Configure Client with Retries and Timeouts

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Demonstrates building a client with specific timeout, retry, and backoff delay configurations for handling site checks.

```rust
let client = Client::builder()
    .timeout(Duration::from_secs(2))
    .min_request_interval(Duration::ZERO)
    .max_retries(2)
    .base_backoff_delay(Duration::from_millis(20))
    .max_backoff_delay(Duration::from_millis(100))
    .build()
    .unwrap();
```

--------------------------------

### Test ScanSchedule With Start and Last Run

Source: https://docs.rs/adler-core/latest/src/adler_core/watchlist.rs.html?search=

Tests ScanSchedule's next_due_ms and is_due methods when a start time and previous run time are provided. It verifies calculations based on the 'every_secs' interval.

```rust
#[test]
fn schedule_uses_start_and_last_run_for_next_due() {
    let schedule = ScanSchedule {
        every_secs: 60,
        start_at_ms: Some(10_000),
    };

    assert_eq!(schedule.next_due_ms(None), 10_000);
    assert_eq!(schedule.next_due_ms(Some(12_000)), 72_000);
    assert!(!schedule.is_due(Some(12_000), 71_999));
    assert!(schedule.is_due(Some(12_000), 72_000));
}
```

--------------------------------

### Create and Filter Registry Sites

Source: https://docs.rs/adler-core/latest/src/adler_core/registry.rs.html

Demonstrates creating a `Registry` from a JSON string and filtering sites. The `sites()` method returns all entries, while `filter()` excludes disabled ones.

```rust
let json = r#"{ 
            "sites": [ 
                { "name": "Alive", "url": "https://alive.example/{username}", 
                  "signals": [{ "kind": "status_found", "codes": [200] }] }, 
                { "name": "Disabled Example", "url": "https://disabled.example/{username}", 
                  "signals": [{ "kind": "status_found", "codes": [200] }], 
                  "disabled": true } 
            ] 
        }"#;
        let registry = Registry::from_json_str(json).unwrap();
        // sites() returns everything including disabled — it's the
        // serialisation view. filter() is the scan view and drops
        // disabled entries.
        assert_eq!(registry.sites().len(), 2);
        let scanned = registry.filter(&[], &[], &[], &[], false);
        let names: Vec<&str> = scanned.iter().map(|s| s.name.as_str()).collect();
        assert_eq!(names, vec!["Alive"]);
```

--------------------------------

### Any::type_id

Source: https://docs.rs/adler-core/latest/adler_core/struct.ClientBuilder.html?search=u32+-%3E+bool

Gets the TypeId of the ClientBuilder.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source
```

--------------------------------

### Client Initialization with Egress and Features

Source: https://docs.rs/adler-core/latest/src/adler_core/client/builder.rs.html?search=u32+-%3E+bool

Initializes the main `Client` struct, setting up HTTP fetchers, egress pools, and conditional features like impersonation.

```rust
let mut egress_entries = Vec::with_capacity(self.egress.len());
for spec in &self.egress {
    let client = build_reqwest(
        &self.user_agent,
        self.timeout,
        self.connect_timeout,
        self.follow_redirects,
        self.redirect_limit,
        Some(&spec.url),
    )?;
    egress_entries.push((
        spec.name.clone(),
        spec.country.clone(),
        spec.kind,
        Arc::new(HttpFetcher::new(client)),
    ));
}

let global_throttle = self.max_rps.map(|rps| {
    // Min spacing between any two requests = 1s / rps.
    let interval = Duration::from_secs(1) / rps.get();
    HostThrottle::new(interval)
});
let robots = self
    .respect_robots
    .then(|| RobotsCache::new(inner.clone(), "adler"));
// Build the impersonate fetcher up front when the feature is on;
// surface a wreq init failure as `HttpSetup` so the caller sees
// it the same way they'd see a bad `--proxy` URL.
#[cfg(feature = "impersonate")]
let impersonate = Some(Arc::new(ImpersonateFetcher::new()?));
Ok(Client {
    http: Arc::new(HttpFetcher::new(inner)),
    egress: Arc::new(EgressPool::new(egress_entries)),
    sessions: Arc::new(self.sessions),
    throttle: HostThrottle::new(self.min_request_interval),
    global_throttle,
    retry: self.retry,
    user_agents: Arc::from(self.user_agents),
    enrich: self.enrich,
    robots,
    browser: self.browser,
    browser_budget: Arc::new(BrowserBudget::new(self.browser_budget)),
    escalation_budget: Arc::new(crate::escalation::EscalationBudget::new(
        self.escalation_budget,
    )),
    escalation_enabled: self.escalation_enabled,
    #[cfg(feature = "impersonate")]
    impersonate,
})
```

--------------------------------

### type_id

Source: https://docs.rs/adler-core/latest/adler_core/struct.CheckOutcome.html

Gets the `TypeId` of `self`.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Signature
`fn type_id(&self) -> TypeId`
```

--------------------------------

### LocalBackend::launch

Source: https://docs.rs/adler-core/latest/adler_core/browser/local/struct.LocalBackend.html

Launches a new headless Chrome process with the specified configuration. This method is used to initialize a LocalBackend instance.

```APIDOC
## LocalBackend::launch

### Description
Launches a fresh headless Chrome process.

### Method
`pub async fn launch(cfg: LocalConfig) -> Result<Self>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "cfg": "LocalConfig"
}
```

### Response
#### Success Response (Result<Self>)
- `Self`: The newly launched LocalBackend instance.

#### Errors
- `Error::BrowserSetup`: If Chrome cannot be located or the process fails to start.

### Response Example
```json
{
  "Ok": "LocalBackend"
}
```
```

--------------------------------

### HEAD 405 Fallback to GET

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Illustrates how the Adler client automatically retries a request with GET if an initial HEAD request is rejected with a 405 Method Not Allowed status. This ensures accuracy by not failing on unsupported HEAD methods.

```rust
let server = MockServer::start().await;
MOCK::given(method("HEAD"))
    .and(path("/alice"))
    .respond_with(ResponseTemplate::new(405))
    .mount(&server)
    .await;
MOCK::given(any())
    .and(path("/alice"))
    .respond_with(ResponseTemplate::new(200))
    .mount(&server)
    .await;
let site = site_with(&server, vec![Signal::StatusFound { codes: vec![200] }]);
let outcome = build_client().check(&site, &user()).await;
assert_eq!(outcome.kind, MatchKind::Found);
let recvd = server.received_requests().await.unwrap_or_default();
assert_eq!(recvd.len(), 2);
assert_eq!(recvd[0].method.as_str(), "HEAD");
assert_eq!(recvd[1].method.as_str(), "GET");
```

--------------------------------

### Site with Body Signal Uses GET Request

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

If a site includes a body-marker signal (e.g., expecting specific text in the body), the client must use a GET request. This ensures the response body is downloaded for content matching.

```rust
#[tokio::test]
    async fn body_signal_site_uses_get_request() {
        // Same baseline plus a body-marker signal — must still GET so
        // the body actually arrives for matching.
        let server = MockServer::start().await;
        Mock::given(any())
            .and(path("/alice"))
            .respond_with(ResponseTemplate::new(200).set_body_string("hello alice"))
            .mount(&server)
            .await;
        let site = site_with(
            &server,
            vec![Signal::BodyPresent {
                text: "hello".into(),
            }],
        );
        let outcome = build_client().check(&site, &user()).await;
        assert_eq!(outcome.kind, MatchKind::Found);
        let recvd = server.received_requests().await.unwrap_or_default();
        assert_eq!(recvd[0].method.as_str(), "GET");
    }
```

--------------------------------

### Handle 405 Method Not Allowed in Direct Fetch

Source: https://docs.rs/adler-core/latest/src/adler_core/transport.rs.html?search=u32+-%3E+bool

When a direct HTTP request receives a 405 status code, this snippet shows how to retry the request using the GET method. This is useful for endpoints that might initially reject other methods but support GET.

```rust
Ok(r) if r.status().as_u16() == 405 => {
    send(
        &self.inner,
        reqwest::Method::GET,
        req.url,
        req.user_agent,
        req.headers,
        None,
    )
    .await
}
```

--------------------------------

### HEAD Method Fallback to GET on 405 Error

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates how the client automatically retries a request with the GET method if the initial HEAD request results in a 405 Method Not Allowed error. This ensures accuracy by not failing on servers that don't support HEAD.

```rust
    #[tokio::test]
    async fn head_405_falls_back_to_get() {
        // A server that rejects HEAD with 405 — Adler should silently
        // retry with GET so the optimisation can never cost accuracy.
        let server = MockServer::start().await;
        Mock::given(method("HEAD"))
            .and(path("/alice"))
            .respond_with(ResponseTemplate::new(405))
            .mount(&server)
            .await;
        Mock::given(any())
            .and(path("/alice"))
            .respond_with(ResponseTemplate::new(200))
            .mount(&server)
            .await;
        let site = site_with(&server, vec![Signal::StatusFound { codes: vec![200] }]);
        let outcome = build_client().check(&site, &user()).await;
        assert_eq!(outcome.kind, MatchKind::Found);
        let recvd = server.received_requests().await.unwrap_or_default();
        assert_eq!(recvd.len(), 2);
        assert_eq!(recvd[0].method.as_str(), "HEAD");
        assert_eq!(recvd[1].method.as_str(), "GET");
    }
```

--------------------------------

### Initialize Client with Egress and Throttling

Source: https://docs.rs/adler-core/latest/src/adler_core/client/builder.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the main `Client` struct, setting up HTTP fetchers, egress pools, session management, and various throttling and budget configurations.

```rust
let mut egress_entries = Vec::with_capacity(self.egress.len());
        for spec in &self.egress {
            let client = build_reqwest(
                &self.user_agent,
                self.timeout,
                self.connect_timeout,
                self.follow_redirects,
                self.redirect_limit,
                Some(&spec.url),
            )?;
            egress_entries.push(( 
                spec.name.clone(),
                spec.country.clone(),
                spec.kind,
                Arc::new(HttpFetcher::new(client)),
            ));
        }

        let global_throttle = self.max_rps.map(|rps| {
            // Min spacing between any two requests = 1s / rps.
            let interval = Duration::from_secs(1) / rps.get();
            HostThrottle::new(interval)
        });
        let robots = self
            .respect_robots
            .then(|| RobotsCache::new(inner.clone(), "adler"));
        // Build the impersonate fetcher up front when the feature is on;
        // surface a wreq init failure as `HttpSetup` so the caller sees
        // it the same way they'd see a bad `--proxy` URL.
        #[cfg(feature = "impersonate")]
        let impersonate = Some(Arc::new(ImpersonateFetcher::new()?));
        Ok(Client {
            http: Arc::new(HttpFetcher::new(inner)),
            egress: Arc::new(EgressPool::new(egress_entries)),
            sessions: Arc::new(self.sessions),
            throttle: HostThrottle::new(self.min_request_interval),
            global_throttle,
            retry: self.retry,
            user_agents: Arc::from(self.user_agents),
            enrich: self.enrich,
            robots,
            browser: self.browser,
            browser_budget: Arc::new(BrowserBudget::new(self.browser_budget)),
            escalation_budget: Arc::new(crate::escalation::EscalationBudget::new(
                self.escalation_budget,
            )),
            escalation_enabled: self.escalation_enabled,
            #[cfg(feature = "impersonate")]
            impersonate,
        })
```

--------------------------------

### Implement `Any` for `T`

Source: https://docs.rs/adler-core/latest/adler_core/enum.ProtectionKind.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the `type_id` method to get the `TypeId` of a type.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
```

--------------------------------

### ClientBuilder::build

Source: https://docs.rs/adler-core/latest/adler_core/struct.ClientBuilder.html?search=std%3A%3Avec

Builds and returns a configured Client instance.

```APIDOC
## ClientBuilder::build

### Description
Build a `Client`.

### Method
`build(self) -> Result<Client>`

### Returns
* **Result<Client>** - A `Result` containing the `Client` on success, or an error if building fails.
```

--------------------------------

### Example Search: Option<T>, (T -> U) -> Option<U>

Source: https://docs.rs/adler-core/latest/adler_core/browser/cdp/struct.CdpEvent.html?search=

Shows a search pattern for a function that takes an `Option<T>` and a function `T -> U`, returning an `Option<U>`. This is typical for mapping operations on optional values.

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/adler-core/latest/adler_core/enum.ConfidenceLabel.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the `type_id` method to get the `TypeId` of a type.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`
```

--------------------------------

### type_id

Source: https://docs.rs/adler-core/latest/adler_core/struct.Engine.html

Gets the `TypeId` of `self`. This is useful for runtime type identification.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Parameters
- `&self` (Self) - The instance of the struct.

### Returns
- `TypeId` - The unique identifier for the type of `self`.
```

--------------------------------

### Client with Session Store and Site Access Configuration

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Initializes a client with a session store and configures a site with a specific session identifier. This tests the client's ability to associate requests with pre-defined sessions.

```rust
    let mut headers = std::collections::BTreeMap::new();
    headers.insert("Cookie".to_string(), "sessionid=real".to_string());
    let mut store = SessionStore::new();
    store.insert("acct", crate::access::Session::from_headers(headers));
    let client = Client::builder()
        .timeout(Duration::from_secs(2))
        .min_request_interval(Duration::ZERO)
        .max_retries(0)
        .sessions(store)
        .build()
        .expect("client builds");
    let mut site = site_with(&server, vec![Signal::StatusFound { codes: vec![200] }]);
    site.access.session = Some("acct".to_string());
```

--------------------------------

### Build Client with Custom User Agent

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=u32+-%3E+bool

Shows how to configure the client with a custom User-Agent header. This is useful for identifying your client to the server.

```rust
let client = Client::builder()
            .user_agent("adler-test/1.0")
            .build()
            .unwrap();
```

--------------------------------

### type_id

Source: https://docs.rs/adler-core/latest/adler_core/enum.KnownPresent.html

Gets the `TypeId` of `self`. This method is part of the `Any` trait implementation.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
- `self`: A reference to the object.

### Returns
- `TypeId`: The unique type identifier of the object.
```

--------------------------------

### Build Adler Client with Custom Settings

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html?search=std%3A%3Avec

Demonstrates building a client with specific configurations like zero minimum request interval and no retries. Ensures robots.txt is respected.

```rust
let client = Client::builder()
    .min_request_interval(Duration::ZERO)
    .max_retries(0)
    .respect_robots(true)
    .build()
    .unwrap();
```

--------------------------------

### Get budget capacity

Source: https://docs.rs/adler-core/latest/src/adler_core/browser/budget.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the maximum number of budget units allowed.

```rust
/// Maximum the budget allows.
#[must_use]
pub const fn cap(&self) -> usize {
    self.cap
}

```

--------------------------------

### Get budget capacity

Source: https://docs.rs/adler-core/latest/src/adler_core/browser/budget.rs.html?search=

Returns the maximum number of units the budget allows.

```rust
pub const fn cap(&self) -> usize {
    self.cap
}
```

--------------------------------

### LocalBackend::launch

Source: https://docs.rs/adler-core/latest/adler_core/browser/local/struct.LocalBackend.html?search=u32+-%3E+bool

Launches a new headless Chrome process. This method is used to initialize a LocalBackend instance.

```APIDOC
## pub async fn launch(cfg: LocalConfig) -> Result<Self>

### Description
Launch a fresh headless Chrome process.

### Parameters
#### Path Parameters
- **cfg** (LocalConfig) - Description of the configuration for launching the browser.

### Errors
- `Error::BrowserSetup`: If Chrome cannot be located or the process fails to start.
```

--------------------------------

### Any Trait Implementation

Source: https://docs.rs/adler-core/latest/adler_core/struct.Engine.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the `type_id` method to get the unique identifier of a type.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **Output**: TypeId - The unique identifier of the type.
```

--------------------------------

### Load Site Registry from Path

Source: https://docs.rs/adler-core/latest/src/adler_core/registry.rs.html?search=std%3A%3Avec

Demonstrates how to load a site registry from a specified file path at runtime, overriding the default embedded registry.

```Rust
use adler_core::registry::Registry;
use std::path::Path;

// Assuming 'path' is a std::path::Path object pointing to your registry file
let registry = Registry::load_from_path(Path::new("path/to/your/sites.json"))?;

```

--------------------------------

### Get Budget Cap

Source: https://docs.rs/adler-core/latest/adler_core/struct.EscalationBudget.html

Returns the maximum number of escalations allowed by the budget.

```rust
pub const fn cap(&self) -> usize>
```

--------------------------------

### build

Source: https://docs.rs/adler-core/latest/src/adler_core/client/builder.rs.html?search=u32+-%3E+bool

Builds and returns a configured `Client` instance. This is the final step in the builder pattern.

```APIDOC
## build

### Description
Build a [`Client`].

### Method
`build(self) -> Result<Client>`
```

--------------------------------

### Get the current consumed count

Source: https://docs.rs/adler-core/latest/adler_core/browser/budget/struct.BrowserBudget.html?search=

Returns the number of units that have been consumed from the budget.

```rust
pub fn used(&self) -> usize
```

--------------------------------

### IntoIterator example (Err)

Source: https://docs.rs/adler-core/latest/adler_core/type.Result.html?search=

Consuming an Err Result into an iterator yields no values.

```rust
let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

--------------------------------

### Configure Adler Core Client

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Demonstrates how to build and configure the Adler Core client with specific settings like minimum request interval, maximum retries, browser backend, and escalation budget.

```rust
let client = Client::builder()
            .min_request_interval(Duration::ZERO)
            .max_retries(0)
            .browser(Arc::clone(&backend) as Arc<dyn BrowserBackend>)
            .escalation_budget(1)
            .build()
            .unwrap();
```

--------------------------------

### Get Used Budget Count

Source: https://docs.rs/adler-core/latest/adler_core/struct.EscalationBudget.html

Returns the number of escalations that have been consumed by the scan so far.

```rust
pub fn used(&self) -> usize>
```

--------------------------------

### Initialize ClientBuilder

Source: https://docs.rs/adler-core/latest/src/adler_core/client/mod.rs.html

Starts the configuration process for a new Adler Core HTTP client. Use this to set various options before building the client instance.

```rust
pub fn builder() -> ClientBuilder {
    ClientBuilder::default()
}
```

--------------------------------

### Get Cache Size

Source: https://docs.rs/adler-core/latest/adler_core/struct.Cache.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the number of live entries currently stored in the cache.

```rust
pub fn len(&self) -> usize
```
Tokens:
Raw