Struct Page 

pub struct Page { /* private fields */ }

Implementations

impl Page

pub async fn navigate(&self, url: &str) -> Result<()>

Navigate to URL (returns immediately, does not wait for load).

Examples found in repository

examples/game_test.rs (line 84)

async fn main() {
    load_dotenv();
    println!("=== Game Test + WS Detection ===\n");

    // 1. Fetch game URL
    println!("Fetching game URL...");
    let client = reqwest::Client::new();
    let resp = client
        .post(api_url())
        .header("Authorization", format!("Bearer {}", api_token()))
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .body(r#"{"user_id": "beezsbee"}"#)
        .send()
        .await
        .expect("API request failed");

    let body: serde_json::Value = resp.json().await.expect("JSON parse failed");
    let game_url = body["url"].as_str().expect("no 'url' in response");
    println!("Game URL: {game_url}\n");

    // 2. Launch browser
    let browser = Browser::builder()
        .headful()
        .profile(42, 12345)
        .build()
        .await
        .expect("browser launch failed");

    // 3. Open blank page first so we can set up listeners before navigation
    let page = browser.new_page("about:blank").await.expect("page failed");

    // Enable network domain for WS events
    page.cdp().execute(EnableParams::default()).await.expect("network enable failed");

    // Set up WS event listeners
    let mut ws_created = page.cdp().event_listener::<EventWebSocketCreated>().await.expect("listener failed");
    let mut ws_closed = page.cdp().event_listener::<EventWebSocketClosed>().await.expect("listener failed");

    // Spawn listener tasks
    tokio::spawn(async move {
        while let Some(ev) = ws_created.next().await {
            println!("[WS CREATED] request_id={:?} url={}", ev.request_id, ev.url);
        }
    });

    tokio::spawn(async move {
        while let Some(ev) = ws_closed.next().await {
            println!("[WS CLOSED]  request_id={:?}", ev.request_id);
        }
    });

    // 4. Navigate to game (human simulation runs automatically)
    println!("Navigating to game...");
    page.navigate(game_url).await.expect("nav failed");

    // 5. Wait and monitor
    println!("Watching for WebSocket connections...\n");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

pub async fn goto(&self, url: &str) -> Result<()>

Navigate to URL and wait for page load.

Examples found in repository

examples/tls_check.rs (line 36)

async fn main() {
    load_dotenv();
    println!("=== TLS/HTTP2 Fingerprint Check ===\n");

    let browser = Browser::builder()
        .headful()
        .random()
        .build()
        .await
        .expect("browser launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    // 1. Check TLS fingerprint
    println!("--- tls.peet.ws ---");
    page.goto("https://tls.peet.ws/api/all").await.expect("nav failed");
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    let body = page.js("document.body.innerText").await.unwrap_or_default();
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&body) {
        // TLS
        if let Some(tls) = v.get("tls") {
            println!("JA3 hash:    {}", tls.get("ja3_hash").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA3:         {}", tls.get("ja3").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA4:         {}", tls.get("ja4").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("TLS version: {}", tls.get("version").and_then(|v| v.as_str()).unwrap_or("N/A"));
        }

        // HTTP2
        println!();
        if let Some(h2) = v.get("http2") {
            println!("HTTP2 fingerprint:   {}", h2.get("akamai_fingerprint").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("Pseudo-header order: {}", h2.get("sent_pseudo_header_fields_order").unwrap_or(&serde_json::Value::Null));
            if let Some(settings) = h2.get("sent_settings") {
                println!("SETTINGS:            {}", settings);
            }
        }

        // HTTP version used
        println!();
        if let Some(ip) = v.get("ip") {
            println!("Client IP:   {}", ip.as_str().unwrap_or("N/A"));
        }
        if let Some(http_version) = v.get("http_version") {
            println!("HTTP version: {}", http_version.as_str().unwrap_or("N/A"));
        }

        // User-Agent
        println!();
        if let Some(h1) = v.get("http1") {
            if let Some(headers) = h1.get("headers") {
                if let Some(arr) = headers.as_array() {
                    for h in arr {
                        let name = h.get("name").and_then(|n| n.as_str()).unwrap_or("");
                        let val = h.get("value").and_then(|n| n.as_str()).unwrap_or("");
                        if name.to_lowercase() == "user-agent" {
                            println!("User-Agent:  {}", val);
                        }
                    }
                }
            }
        }
    } else {
        println!("Failed to parse response: {}", &body[..body.len().min(500)]);
    }

    // 2. Check known Chrome 134 reference values
    println!("\n--- Expected Chrome 134 stock values ---");
    println!("JA3 hash:    cd49876058a26ccf43e241ccc4e4b5d3  (Chrome 134 Windows)");
    println!("JA4:         t13d1517h2_8daaf6152771_02713d6af8  (Chrome 134 Windows)");
    println!("HTTP2 Akamai: 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p");

    println!("\nBrowser still open. Press Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/batch_test.rs (line 213)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}

pub async fn wait_for_load(&self) -> Result<()>

Wait for next navigation/load event.

pub async fn js(&self, expr: &str) -> Result<String>

Run JS expression in page context, return result as String.

Examples found in repository

examples/youtube_test.rs (line 17)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/smoke_test.rs (line 24)

async fn main() {
    println!("=== Smoke Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    let checks = &[
        ("webdriver", "navigator.webdriver.toString()"),
        ("timezone", "Intl.DateTimeFormat().resolvedOptions().timeZone"),
        ("cores", "navigator.hardwareConcurrency.toString()"),
        ("screen", "screen.width+'x'+screen.height"),
        ("UA", "navigator.userAgent"),
    ];
    for (name, expr) in checks {
        let val = page.js(expr).await.unwrap_or_default();
        println!("{name}: {val}");
    }

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/tls_check.rs (line 39)

async fn main() {
    load_dotenv();
    println!("=== TLS/HTTP2 Fingerprint Check ===\n");

    let browser = Browser::builder()
        .headful()
        .random()
        .build()
        .await
        .expect("browser launch failed");

    let page = browser.new_page("about:blank").await.expect("page failed");

    // 1. Check TLS fingerprint
    println!("--- tls.peet.ws ---");
    page.goto("https://tls.peet.ws/api/all").await.expect("nav failed");
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    let body = page.js("document.body.innerText").await.unwrap_or_default();
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&body) {
        // TLS
        if let Some(tls) = v.get("tls") {
            println!("JA3 hash:    {}", tls.get("ja3_hash").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA3:         {}", tls.get("ja3").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("JA4:         {}", tls.get("ja4").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("TLS version: {}", tls.get("version").and_then(|v| v.as_str()).unwrap_or("N/A"));
        }

        // HTTP2
        println!();
        if let Some(h2) = v.get("http2") {
            println!("HTTP2 fingerprint:   {}", h2.get("akamai_fingerprint").and_then(|v| v.as_str()).unwrap_or("N/A"));
            println!("Pseudo-header order: {}", h2.get("sent_pseudo_header_fields_order").unwrap_or(&serde_json::Value::Null));
            if let Some(settings) = h2.get("sent_settings") {
                println!("SETTINGS:            {}", settings);
            }
        }

        // HTTP version used
        println!();
        if let Some(ip) = v.get("ip") {
            println!("Client IP:   {}", ip.as_str().unwrap_or("N/A"));
        }
        if let Some(http_version) = v.get("http_version") {
            println!("HTTP version: {}", http_version.as_str().unwrap_or("N/A"));
        }

        // User-Agent
        println!();
        if let Some(h1) = v.get("http1") {
            if let Some(headers) = h1.get("headers") {
                if let Some(arr) = headers.as_array() {
                    for h in arr {
                        let name = h.get("name").and_then(|n| n.as_str()).unwrap_or("");
                        let val = h.get("value").and_then(|n| n.as_str()).unwrap_or("");
                        if name.to_lowercase() == "user-agent" {
                            println!("User-Agent:  {}", val);
                        }
                    }
                }
            }
        }
    } else {
        println!("Failed to parse response: {}", &body[..body.len().min(500)]);
    }

    // 2. Check known Chrome 134 reference values
    println!("\n--- Expected Chrome 134 stock values ---");
    println!("JA3 hash:    cd49876058a26ccf43e241ccc4e4b5d3  (Chrome 134 Windows)");
    println!("JA4:         t13d1517h2_8daaf6152771_02713d6af8  (Chrome 134 Windows)");
    println!("HTTP2 Akamai: 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p");

    println!("\nBrowser still open. Press Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

pub async fn js_as<T: DeserializeOwned>(&self, expr: &str) -> Result<T>

Run JS and deserialize result into T.

pub async fn js_on_new_document(&self, script: &str) -> Result<()>

Inject script that runs on every new document before page JS.

pub async fn url(&self) -> Result<String>

Current page URL.

Examples found in repository

examples/youtube_test.rs (line 18)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

pub async fn title(&self) -> Result<String>

Page title.

pub async fn html(&self) -> Result<String>

Full page HTML.

pub async fn screenshot(&self) -> Result<Vec<u8>>

Capture PNG screenshot.

pub async fn click(&self, x: f64, y: f64) -> Result<()>

Click at (x, y) with realistic mouse movement + timing.

pub async fn type_text(&self, text: &str) -> Result<()>

Type text into focused element with realistic keystroke timing.

pub async fn scroll(&self, delta_y: f64) -> Result<()>

Scroll by delta_y pixels (positive = down).

pub async fn wait(&self, ms: u64)

Sleep for ms milliseconds.

Examples found in repository

examples/youtube_test.rs (line 15)

async fn main() {
    println!("=== YouTube Test ===\n");

    let browser = Browser::builder()
        .headful()
        .profile(7, 777)
        .build()
        .await
        .expect("launch failed");

    let page = browser.new_page("https://www.youtube.com").await.expect("nav failed");
    page.wait(3000).await;

    let title = page.js("document.title").await.unwrap_or_default();
    let url = page.url().await.unwrap_or_default();
    println!("Title: {title}");
    println!("URL: {url}");

    println!("\nBrowser open. Ctrl+C to exit.");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

pub async fn close(self) -> Result<()>

Close the page/tab.

pub fn cdp(&self) -> &CdpPage

Access underlying chromiumoxide Page for raw CDP.

Examples found in repository

examples/game_test.rs (line 63)

async fn main() {
    load_dotenv();
    println!("=== Game Test + WS Detection ===\n");

    // 1. Fetch game URL
    println!("Fetching game URL...");
    let client = reqwest::Client::new();
    let resp = client
        .post(api_url())
        .header("Authorization", format!("Bearer {}", api_token()))
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .body(r#"{"user_id": "beezsbee"}"#)
        .send()
        .await
        .expect("API request failed");

    let body: serde_json::Value = resp.json().await.expect("JSON parse failed");
    let game_url = body["url"].as_str().expect("no 'url' in response");
    println!("Game URL: {game_url}\n");

    // 2. Launch browser
    let browser = Browser::builder()
        .headful()
        .profile(42, 12345)
        .build()
        .await
        .expect("browser launch failed");

    // 3. Open blank page first so we can set up listeners before navigation
    let page = browser.new_page("about:blank").await.expect("page failed");

    // Enable network domain for WS events
    page.cdp().execute(EnableParams::default()).await.expect("network enable failed");

    // Set up WS event listeners
    let mut ws_created = page.cdp().event_listener::<EventWebSocketCreated>().await.expect("listener failed");
    let mut ws_closed = page.cdp().event_listener::<EventWebSocketClosed>().await.expect("listener failed");

    // Spawn listener tasks
    tokio::spawn(async move {
        while let Some(ev) = ws_created.next().await {
            println!("[WS CREATED] request_id={:?} url={}", ev.request_id, ev.url);
        }
    });

    tokio::spawn(async move {
        while let Some(ev) = ws_closed.next().await {
            println!("[WS CLOSED]  request_id={:?}", ev.request_id);
        }
    });

    // 4. Navigate to game (human simulation runs automatically)
    println!("Navigating to game...");
    page.navigate(game_url).await.expect("nav failed");

    // 5. Wait and monitor
    println!("Watching for WebSocket connections...\n");
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
    }
}

examples/batch_test.rs (line 193)

async fn main() {
    load_dotenv();
    let total = PER_ROUND * ROUNDS;
    println!("=== Proxy batch: {}×{} = {} | live {}s | rotate {}s cooldown ===\n",
        PER_ROUND, ROUNDS, total, BROWSER_LIVE_SECS, ROTATE_COOLDOWN_SECS);

    let start = Instant::now();
    let mut ok = 0u32;
    let mut fail = 0u32;

    for round in 0..ROUNDS {
        println!("--- Round {}/{} ---", round + 1, ROUNDS);

        // 1. Rotate IP and get proxy
        let proxy = match rotate_and_get_proxy().await {
            Some(p) => p,
            None => {
                println!("  Skip round — no proxy");
                fail += PER_ROUND as u32;
                continue;
            }
        };

        // 2. Verify proxy works
        if !verify_proxy(&proxy).await {
            println!("  Skip round — proxy dead");
            fail += PER_ROUND as u32;
            continue;
        }

        // 3. Launch 3 browsers in parallel
        let offset = round * PER_ROUND;
        let mut handles = Vec::new();

        for i in 0..PER_ROUND {
            let idx = offset + i;
            let user_id = USERS[idx % USERS.len()].to_string();
            let proxy = proxy.clone();
            let api = api_url();
            let token = api_token();

            handles.push(tokio::spawn(async move {
                let label = format!("[{:02}/{}]", idx + 1, total);
                let t = Instant::now();

                // Get game URL (direct, no proxy)
                let game_url = match reqwest::Client::new()
                    .post(&api)
                    .header("Authorization", format!("Bearer {}", token))
                    .header("Content-Type", "application/json")
                    .body(format!(r#"{{"user_id": "{}"}}"#, user_id))
                    .send().await
                {
                    Ok(resp) => {
                        let body: serde_json::Value = resp.json().await.unwrap_or_default();
                        match body["url"].as_str() {
                            Some(u) if !u.is_empty() => u.to_string(),
                            _ => return format!("{label} FAIL api: {body}"),
                        }
                    }
                    Err(e) => return format!("{label} FAIL api: {e}"),
                };
                let api_ms = t.elapsed().as_millis();

                // Launch browser with proxy
                let browser = match Browser::builder()
                    .headful()
                    .random()
                    .proxy(&proxy)
                    .build().await
                {
                    Ok(b) => b,
                    Err(e) => return format!("{label} FAIL launch: {e}"),
                };
                let launch_ms = t.elapsed().as_millis() - api_ms;

                // Navigate (human simulation auto-starts with aggressive scroll)
                let page = match browser.new_page("about:blank").await {
                    Ok(p) => p,
                    Err(e) => return format!("{label} FAIL page: {e}"),
                };

                // Aggressive scrolling in background
                let scroll_page = page.cdp().clone();
                let scroll_handle = tokio::spawn(async move {
                    use chromiumoxide::cdp::browser_protocol::input::{
                        DispatchMouseEventParams, DispatchMouseEventType,
                    };
                    let mut y = 300.0f64;
                    loop {
                        // Scroll down aggressively
                        let mut ev = DispatchMouseEventParams::new(
                            DispatchMouseEventType::MouseWheel, 500.0, y,
                        );
                        ev.delta_x = Some(0.0);
                        ev.delta_y = Some(300.0);
                        let _ = scroll_page.execute(ev).await;
                        y = ((y + 50.0) % 800.0) + 100.0;
                        tokio::time::sleep(std::time::Duration::from_millis(800)).await;
                    }
                });

                let t_nav = Instant::now();
                if let Err(e) = page.goto(&game_url).await {
                    scroll_handle.abort();
                    return format!("{label} FAIL nav: {e}");
                }
                let nav_ms = t_nav.elapsed().as_millis();

                // Wait for cookies
                tokio::time::sleep(std::time::Duration::from_secs(5)).await;

                let cookies = page.cdp().get_cookies().await.unwrap_or_default();
                let has_evo = cookies.iter().any(|c| c.name == "EVOSESSIONID");
                let evo = cookies.iter().find(|c| c.name == "EVOSESSIONID")
                    .map(|c| c.value.clone())
                    .unwrap_or_else(|| "N/A".into());
                let cookie_names: Vec<String> = cookies.iter().map(|c| c.name.clone()).collect();

                // Stay alive for remaining time (human sim + aggressive scroll running)
                let elapsed = t.elapsed().as_secs();
                if elapsed < BROWSER_LIVE_SECS {
                    tokio::time::sleep(std::time::Duration::from_secs(BROWSER_LIVE_SECS - elapsed)).await;
                }

                // Close browser
                scroll_handle.abort();
                let _ = browser.close().await;
                let total_ms = t.elapsed().as_millis();

                let status = if has_evo { "OK" } else { "MISS" };
                format!("{label} {status} | {user_id:<18} | total:{total_ms}ms api:{api_ms}ms launch:{launch_ms}ms nav:{nav_ms}ms | cookies:{} | EVO:{evo}\n       {:?}",
                    cookies.len(), cookie_names)
            }));
        }

        for h in handles {
            match h.await {
                Ok(msg) => {
                    if msg.contains("] OK ") { ok += 1; } else { fail += 1; }
                    println!("{msg}");
                }
                Err(e) => { println!("  task panic: {e}"); fail += 1; }
            }
        }

        println!();
    }

    let elapsed = start.elapsed().as_secs_f64();
    println!("=== OK:{ok} FAIL:{fail} | {elapsed:.0}s total | {:.1}s/profile ===",
        elapsed / total as f64);
}