first commit

IMPLEMENTACAO_NAVEGADOR_REALISTA.md

@@ -0,0 +1,331 @@
+# Plano de Implementação: Navegador Realista em Rust (chromiumoxide)
+
+## Contexto do projeto
+
+O `backend/src` (Rust + Actix) já possui:
+
+- `browser.rs` (≈585 linhas): launcher `chromiumoxide` descartável. Cada chamada cria um novo `Browser::launch` com `tempdir` próprio, viewport aleatório (4 tamanhos), `--lang=pt-BR`, `--proxy-server=` + CDP `page.authenticate(...)` quando proxy habilitado, bloqueio de recursos pesados, scroll-until-stable via `window.scrollTo`, warmup antes do alvo e pacing aleatório entre sessões.
+- `proxy.rs` (≈275 linhas): `ProxyConfig` residencial (DataImpulse por padrão), rotação delegada ao gateway (`__cr.{country}`, sem `sessid.`).
+- `http_client.rs` (≈533 linhas): sessão `reqwest` descartável com UA Chrome aleatório (v131–137), `Accept-Language` pt-BR, `sec-ch-ua`, sec-fetch-* headers, cookie jar por sessão, sem reuso de pool.
+- `crawler.rs`, `youtube.rs`, `search.rs`: todos consumem `BrowserModule` (o HTML do Google/YouTube vem pelo Chromium, nunca pelo reqwest). Detecção de desafio é apenas informativa (retorna `AppError::External`).
+- `media.rs`: downloads binários (thumbnails / og:image) via reqwest+proxy — único ponto onde o reqwest pode tocar hospedagens do Google como `i.ytimg.com`.
+
+**Estado atual vs. objetivo:** ainda não há injeção de JS via `Page.addScriptToEvaluateOnNewDocument`, nem override de UA/plataforma via CDP, nem simulação de mouse/teclado, nem coerência entre a persona do `BrowserModule` (que usa o UA nativo do Chromium) e a persona do `http_client.rs` (que inventa Chrome 131–137). O plano abaixo fecha essas lacunas, mantendo o código idiomático ao que já existe.
+
+## Objetivo
+
+Apresentar ao site alvo um navegador cuja identidade (UA, plataforma, hardware, canvas, WebGL, áudio, fuso, idioma) seja **interna e coerente** durante toda a sessão, e cuja interação (movimento, clique, digitação, scroll) seja **orgânica**. Não se trata de burlar nada: trata-se de o cliente automatizado operar como um navegador comum operaria, com a mesma consistência que um usuário real mantém de uma aba para outra.
+
+## Princípios
+
+1. **Consistência dentro da sessão.** Tudo deriva de uma única `Persona` sorteada no início: UA, plataforma, resolução, idioma, vendor WebGL, vendor de áudio. Nada contradiz nada.
+2. **Ruído com semente fixa por sessão.** Canvas/WebGL/Audio recebem perturbação determinística a partir de um seed sorteado no início; o resultado é estável dentro da sessão e diferente entre sessões, sem parecer "bloqueado".
+3. **Comportamento orgânico, não perfeito.** Curvas de Bézier com micro-tremores, digitação com atraso Gaussiano e taxa small de correção, pausas e scroll irregular.
+4. **Nada de "asas paralelas".** Qualquer requisição a domínios do Google/YouTube passa pela aba do Chromium; o reqwest continua reservado aos downloads binários de mídia.
+5. **Isolamento por persona.** Uma persona = um processo Chromium = um `--user-data-dir` temporário = um IP de proxy. IP só muda entre personas.
+6. **Sem mudar contratos públicos existentes.** Onde houver alteração de assinatura, manter a anterior como wrapper que chama a nova.
+
+---
+
+## Fase 1 — Sistema de Persona (`persona.rs`, novo)
+
+Criar `src/persona.rs` declarado em `lib.rs`. Função pública `generate(request_id, proxy_country) -> Persona` que sorteia e devolve uma `Persona` imutável usada por toda a sessão.
+
+```rust
+pub struct Persona {
+    pub user_agent: String,
+    pub platform: &'static str,      // "Win32" | "MacIntel" | "Linux x86_64"
+    pub sec_ch_ua_platform: &'static str, // "Windows" | "macOS" | "Linux"
+    pub chrome_major: u32,
+    pub accept_language: String,      // derivado do país do proxy
+    pub locale: String,               // "pt-BR" | "en-US" | ...
+    pub timezone: String,             // "America/Sao_Paulo" | "Europe/Lisbon" | ...
+    pub hardware_concurrency: u8,     // 4 | 8 | 12 | 16
+    pub device_memory: u8,            // 4 | 8 | 16
+    pub screen: (u32, u32),           // 1920x1080 | 1366x768 | 1440x900 | 1536x864 | 1600x900
+    pub device_scale_factor: f64,     // 1.0 | 1.25 | 2.0 coerente com a screen
+    pub webgl_vendor: &'static str,   // "Google Inc. (Intel)" | "Google Inc. (Apple)" | ...
+    pub webgl_renderer: &'static str,// "ANGLE (Intel, Intel(R) Iris ...)" | "Apple M1" | ...
+    pub audio_sample_rate: u32,       // 44100 | 48000
+    pub canvas_seed: u64,             // semente do ruído de canvas
+    pub audio_seed: u64,              // semente do ruído de áudio
+    pub plugins: Vec<&'static str>,   // ["PDF Viewer","Chrome PDF Viewer",...]
+}
+
+pub fn generate(request_id: &str, proxy_country: Option<&str>) -> Persona;
+```
+
+**Regras de coerência (declaradas como invariantes, não comentadas no código):**
+
+- Se `platform == "MacIntel"` → `webgl_renderer` contém `Apple M1` ou `Intel Iris`, `sec_ch_ua_platform == "macOS"`, UA contem `Macintosh; Intel Mac OS X`.
+- Se `platform == "Win32"` → UA `Windows NT 10.0; Win64; x64`, `webgl_renderer` refere `ANGLE (Intel/NVIDIA/AMD)`.
+- Se `platform == "Linux x86_64"` → UA `X11; Linux x86_64`, `webgl_vendor = "Google Inc. (Intel)"`.
+- `accept_language` e `timezone` derivam do `proxy_country` quando houver (tabela país → idiomas + IANA tz); fallback `pt-BR` / `America/Sao_Paulo`.
+- `chrome_major` sorteado de um array `MAJOR_VERSIONS` mantido junto do `http_client.rs` (de forma que as duas pilhas usem a mesma lista — ver Fase 6).
+
+**Tarefas:**
+
+- [ ] Criar `src/persona.rs` com a struct `Persona` e a função `generate`.
+- [ ] Tables internas: `WINDOWS_UAS`, `MAC_UAS`, `LINUX_UAS` (apenas Chrome ≥ 120), `COUNTRY_LOCALE` (país → (locale, accept_language, timezone)), `WEBGL_BY_PLATFORM`.
+- [ ] Adicionar `pub mod persona;` em `lib.rs`.
+- [ ] Testes unitários: `persona_is_self_consistent` (assertivas cruzadas OS↔UA↔WebGL↔platform), `repeated_calls_differ` (alta entropia entre chamadas), `country_overrides_locale`.
+
+---
+
+## Fase 2 — Launch do Chromium (`browser.rs`, edit)
+
+Extender `BrowserModule` para carregar a `Persona` na sessão corrente. Como `BrowserModule` é compartilhado (clonado) por `SearchService`, `YoutubeService`, `Crawler`, **a persona é sorteada por fetch** (cada `fetch_html_with_options` pode iniciar uma nova sessão Chromium), não por `BrowserModule`. Cada `Browser::launch` já é descartável; semelha-se a "uma pessoa diferente abrindo o navegador para uma consulta" — adequado para sessões curtas.
+
+### 2.1 Novos argumentos de launch
+
+Adicionar ao `ChromiumConfig::builder()` atual (em `browser.rs` linhas ≈213–241):
+
+- `--disable-blink-features=AutomationControlled` — o Chromium headless novo já omite `navigator.webdriver` em muitos builds, mas o arg garante consistência.
+- `--disable-features=IsolateOrigins,site-per-process` apenas quando o builder já estiver em uso em testes; removê-lo em produção (comentar a razão no Doctest/comentário descritivo, **não** no código neural).
+- `--force-webrtc-ip-handling-policy=disable_non_proxied_udp`
+- `--disable-webrtc-multiple-routes`
+- Manter `--disable-gpu`, `--disable-dev-shm-usage`, `--lang={persona.locale}` (substituir o `--lang=pt-BR` fixo).
+- `--user-data-dir=<tempdir>` — já existe via `tempfile`; manter.
+- `--proxy-server={scheme}://{host}:{port}` — já existe; sem mudança.
+
+**Não usar** `--disable-web-security` em produção. Reservado a flag de teste internamente e desativado por padrão.
+
+### 2.2 Assinaturas
+
+Adicionar versões novas em vez de quebrar as existentes:
+
+```rust
+pub async fn fetch_html_with_persona(
+    &self,
+    request_id: &str,
+    url: &str,
+    persona: &Persona,
+) -> AppResult<BrowserPage>;
+
+pub async fn fetch_html_with_options_and_persona(
+    &self,
+    request_id: &str,
+    url: &str,
+    options: &BrowserFetchOptions,
+    persona: &Persona,
+) -> AppResult<BrowserPage>;
+```
+
+`fetch_html` e `fetch_html_with_options` atuais viram wrappers que chamam `persona::generate(request_id, self.proxy.country.as_deref())` e delegam. **Nenhum call-site existente muda.**
+
+### 2.3 Aplicação da persona via CDP
+
+Antes de `page.goto(target)`, ainda em `about:blank`:
+
+1. `page.execute(SetUserAgentOverride { user_agent, accept_language, platform })` — sobrescreve UA, plataforma e Accept-Language no nível do navegador (equivalente a `Emulation.setUserAgentOverride`). Garantia:UA do Chromium bate com UA do `http_client` apenas quando a `Persona` é a mesma — esta coerência fica garantida pela Fase 6.
+2. `page.execute(SetTimezoneOverride { timezone })` (via `Emulation.setTimezoneOverride`).
+3. `page.execute(SetGeolocationOverride)` opcional, se país do proxy fired.
+4. Confirmar `viewport` (já sorteado hoje) agora derivado de `persona.screen` e `persona.device_scale_factor`.
+
+**Tarefas:**
+
+- [ ] Expandir `BrowserModuleConfig` com `stealth: bool` (default `true`) que liga/desliga as inconveniências para testes.
+- [ ] Substituir `random_viewport()` privada por `persona.viewport()` (método em `persona.rs`).
+- [ ] Aplicar `SetUserAgentOverride` + `Emulation.setTimezoneOverride` após `new_page("about:blank")`.
+- [ ] Testes: capturar o `navigator.userAgent` via `page.evaluate` em página de teste e comparar com `persona.user_agent`.
+
+---
+
+## Fase 3 — Injeção de Script `Page.addScriptToEvaluateOnNewDocument` (`stealth.rs`, novo)
+
+Criar `src/stealth.rs` que produz uma string JavaScript única por persona. `browser.rs` injeta via `chromiumoxide` `execute(AddScriptToEvaluateOnNewDocumentParameters { source }).await` ANTES do `goto`. O script é avaliado antes de qualquer recurso da página.
+
+### 3.1 API pública
+
+```rust
+pub fn build_init_script(persona: &Persona) -> String;
+```
+
+Retorna um template JS com os valores da persona interpolados. Razões do design (não entram no código como comentários neuralmente pedantes): manter tudo em um único `source` para evitar múltiplas round-trips CDP.
+
+### 3.2 O que o script faz (sem comentários no JS além de cabeçalho curto)
+
+1. **`navigator.webdriver`** → `delete` do getter (defensive; raramente presente mas padroniza).
+2. **`navigator.platform`** → define `platform` como `persona.platform`.
+3. **`navigator.languages`** → `[persona.locale, fallback...]`.
+4. **`navigator.hardwareConcurrency`** → define via `Object.defineProperty`.
+5. **`navigator.deviceMemory`** → idem.
+6. **`navigator.plugins`** e `navigator.mimeTypes` → reconstrói com `PDF Viewer`, `Chrome PDF Viewer`, `Chromium PDF Viewer`, `Microsoft Edge PDF Viewer`, `WebKit built-in PDF` (lista compatível com a plataforma).
+7. **`navigator.language`** → `persona.locale`.
+8. **Canvas**: interceptar `HTMLCanvasElement.prototype.toDataURL`, `toBlob`, `CanvasRenderingContext2D.prototype.getImageData`. Para cada pixel retornado, aplicar XOR/add de 1 bit em um canal derivado de `persona.canvas_seed + índice`. Não zerar, não bloquear — apenas perturbar. Hash de canvas estável por sessão, diferente entre sessões.
+9. **WebGL**: interceptar `WebGLRenderingContext.prototype.getParameter` e `WebGL2RenderingContext.prototype.getParameter`. Para `UNMASKED_VENDOR_WEBGL` (37445) retornar `persona.webgl_vendor`; para `UNMASKED_RENDERER_WEBGL` (37446) retornar `persona.webgl_renderer`. Para `VENDOR`/`RENDERER` базы, retornar `WebKit`/`WebKit WebGL`. Para `MAX_TEXTURE_SIZE` manter. Para `getShaderPrecisionFormat` manter nativo.
+10. **AudioContext**: interceptar `AnalyserNode.prototype.getByteFrequencyData`, `AudioBuffer.prototype.getChannelData`, `AudioBuffer.prototype.copyFromChannel`. Adicionar ruído determinístico de amplitude ~1e-7 derivado de `persona.audio_seed` + índice. Não quebrar codecs.
+11. **`screen.width/height/availWidth/availHeight`** → coerente com `persona.screen` e `persona.device_scale_factor`.
+12. **`Notification.permission`** e `navigator.permissions.query` → mantêm nativo (não promover).
+13. **Stack trace**: o script é entregue como string única sem identifiable filename — o Chromium já carrega scripts CDP sem origin; nada a fazer.
+
+### 3.3 Tarefas
+
+- [ ] `src/stealth.rs` com `build_init_script(persona)`.
+- [ ] Em `browser.rs` `fetch_in_browser`, chamar `page.execute(AddScriptToEvaluateOnNewDocument { source: build_init_script(&persona) }).await?` logo após `new_page("about:blank")` e antes do `goto(warmup)`.
+- [ ] Testes: carregar `data:text/html,<canvas id=c></canvas><script>…</script>` em página, ler `toDataURL` duas vezes na mesma página — afirmar igualdade (determinismo intra-sessão) — e comparar hash com outra sessão — afirmar desigualdade (entropia inter-sessão).
+- [ ] Teste: `WebGLRenderingContext.getParameter(37446)` retorna `persona.webgl_renderer`.
+
+---
+
+## Fase 4 — Motor Comportamental (`behavior.rs`, novo)
+
+Criar `src/behavior.rs` com funções `async` que operam sobre `&Page` (do `chromiumoxide`). Tudo assíncrono, tudo usando `page.execute(Input.dispatchMouseButton...)` ou os helpers de `chromiumoxide` (`page.mouse`, `page.keyboard`).
+
+### 4.1 Mouse
+
+- `pub async fn move_along_bezier(page, start: (f64,f64), end: (f64,f64), rng: &mut impl Rng)`:
+  - Curva cúbica de Bézier com dois pontos de controle sorteioprandr a partir do quadrado determinante [start,end] perpendicular (offset aleatório 50–200px).
+  - ~30–60 passos ao longo da curva.
+  - `page.mouse.move(x, y)` por passo.
+  - Pacing por passo: ease-in/ease-out com pequena jitter (5–20ms).
+  - **Micro-tremor:** em ~20% dos passos, offset aleatório 1–2px fora da curva, restaurado no passo seguinte.
+- `pub async fn human_click(page, x, y, rng)`:
+  - `move_along_bezier` até `(x,y)`.
+  - `mouse_down` (press).
+  - `tokio::sleep(Duration::from_millis(50 + rng.gen_range(0..100)))`.
+  - `mouse_up` (release).
+
+### 4.2 Teclado
+
+- `pub async fn human_type(page, text: &str, rng)`:
+  - Para cada caractere:
+    - `tokio::sleep(Duration::from_millis(gaussian(130.0, 55.0, rng).clamp(40, 400)))`.
+    - 5% de chance: digite caractere errado, durma `200ms`, `Backspace`, durma `~80ms`, digite o correto.
+    - `page.keyboard.press_char(c)`.
+  - Distribuição gaussiana via Box-Muller a partir de `rand` (já no `Cargo.toml`).
+
+### 4.3 Scroll orgânico
+
+- `pub async fn organic_scroll(page, rng, rounds)`:
+  - Para cada rodada:
+    - Sorteioprand passo aleatório 200–800px.
+    - `page.evaluate("window.scrollBy(0, {n})")`.
+    - `tokio::sleep(300 + rng.gen_range(0..1500ms))`.
+    - Em ~30% das rodadas, um pequeno `scrollBy` reverso de 50–120px (mão voltou um tiquinho).
+
+### 4.4 Navegação de pesquisa
+
+- `pub async fn perform_search(page, query: &str, rng)`:
+  - `move_along_bezier` from a random corner to the search box (CSS selector especificável via parâmetro).
+  - `human_click` na caixa.
+  - `human_type(page, query, rng)`.
+  - `human_press_enter(page)`.
+
+### 4.5 Integração
+
+Em `search.rs` `fetch_html`, após `page.goto(google_url)` e `wait_after_load`, chamar:
+
+```rust
+behavior::perform_search(&page, query, &mut rng).await?;
+```
+
+Não será necessário para `crawler.rs` (que navega direto em URLs) nem para `youtube.rs` (que lê página de resultados já pronta) — exceto `YoutubeService::discover_podcast_channels`, que faria uma pesquisa real na YouTube search; ajustar APENAS aqui se fizer sentido.
+
+### 4.6 Tarefas
+
+- [ ] `src/behavior.rs` com `move_along_bezier`, `human_click`, `human_type`, `organic_scroll`, `perform_search`.
+- [ ] Função `gaussian(mean, std, rng)`.
+- [ ] Em `search.rs::fetch_html` integrar o motor de comportamento (ativado por flag na `SearchConfig::simulate_interaction: bool`, default `true`).
+- [ ] Testes: rodar `perform_search` contra uma fixture HTML `data:text/html,...` com um `<input>` e ler `input.value` — confirmar texto coerente com typos corrigidos.
+
+---
+
+## Fase 5 — TLS e Rede (verificação, não codificação)
+
+Princípio: **todas as requisições a domínios do Google/YouTube que não sejam downloads de mídia binária devem passar pela aba do Chromium**. Já é o caso (`search.rs`, `youtube.rs`, `crawler.rs` usam `BrowserModule`). Esta fase é de auditoria:
+
+- [ ] Grep em `backend/src` por qualquer `reqwest::get`/`reqwest::Client::get`/`HttpClient::fresh(...).get_*` cuja URL seja `youtube.com`, `google.com`, `youtu.be`, `i.ytimg.com`, `ytimg.googleusercontent.com`. Confirmar que só `media.rs` (via `crawler.rs::download_page_media`) faz isso, e somente para dados binários.
+- [ ] Documentar em `AGENTS.md`: "Reqwest é reservado a binários; HTML de Google/YouTube é sempre pela aba do Chromium". (Não há mudança de código.)
+
+---
+
+## Fase 6 — Unificação das Personas (reqwest e Chromium)
+
+`http_client.rs::BrowserIdentity::random_pt_br()` e `persona.rs::generate()` atualmente sorteiam independentemente. Padronizar:
+
+- [ ] Extrair a lista `MAJOR_VERSIONS = [120, 121, ..., 137]` para um `const` em `persona.rs` (ou módulo compartilhado `chrome_versions`).
+- [ ] `BrowserIdentity::from_persona(persona) -> Self` em `http_client.rs` — constrói o `BrowserIdentity` a partir da persona. `random_pt_br()` mantém como legacy fallback.
+- [ ] `MediaStore::download` e similar **continuam usando Chrome nativo**, mas agora opcionalmente derivam `Persona` identica quando houver interesse em hr-consistência crosspod (método `download_with_persona` opcional).
+- [ ] Teste de coerência: instalando persona com `chrome_major=125`, tanto `http_client` quanto Chromium expõem UA contendo `Chrome/125`.
+
+---
+
+## Fase 7 — Isolamento de Sessão
+
+Já parcialmente atendido (cada `BrowserModule::fetch_*` já faz `Browser::launch` novo via `tempfile`). Garantias adicionais:
+
+- [ ] **Um `--user-data-dir` por launch:** já verdadeiro (`tempdir`). Adicionar uma asserção/panic em modo debug de que dois launches simultâneos nunca compartilham o dir.
+- [ ] **IP-amarrado-à-sessão:** como a rotação é por-requisição no gateway DataImpulse, atualmente cada `BrowserModule::fetch_html` recebe um IP novo — coisa quebra a hipótese "IP constante dentro da persona". Para remediar, adicionar à `ProxyConfig` um mecanismo de **sessão-pública** no gateway:
+  - `ProxyConfig::effective_username_session(session_id: &str)` que acrescenta `__sessid.{session_id}` ao usuário (sintaxe DataImpulse). Documentado em `proxy.rs`.
+  - `Persona::proxy_session_id() -> String` (UUID v4 pertencente à persona) usado por toda a sessão para fixar o IP egressivo.
+  - Em `BrowserModule::fetch_html_with_persona`, fixar `session_id` antes de `Browser::launch`.
+- [ ] Teste: dois fetches com a mesma persona usam o mesmo IP egressivo (verificar via `https://api.ipify.org` em helpers de teste — opcional, quando proxy habilitado).
+
+---
+
+## Fase 8 — Fluxo de execução integrado
+
+Adaptar `search.rs::SearchService::search` para orquestrar a sequência:
+
+```
+1. persona = persona::generate(request_id, proxy.country.as_deref())
+2. page = browser.fetch_html_with_persona(url, &persona)
+   (launch + addScriptToEvaluateOnNewDocument + warmup + goto target)
+3. aguardar DOM pronto
+4. behavior::perform_search(&page, query, &mut rng) (movimento + clique + digitação gaussiana)
+5. pressionar Enter (ou clicar no botão "Pesquisar")
+6. aguardar resultados (wait_after_load_ms + organic_scroll)
+7. parse_google_results(html)
+8. retornar Vec<SearchResult>
+```
+
+Em `youtube.rs::discover_podcast_channels`, adicionar interação de pesquisa análoga quando `config.simulate_interaction` for `true`.
+
+---
+
+## Tarefas por arquivo (resumo dos entregáveis)
+
+| Arquivo | Ação |
+|---|---|
+| `src/persona.rs` | **novo** — struct `Persona`, `generate`, tables. |
+| `src/stealth.rs` | **novo** — `build_init_script(persona)`. |
+| `src/behavior.rs` | **novo** — Bezier mouse, teclado gaussiano, scroll orgânico. |
+| `src/browser.rs` | **editar** — novos args de launch, novos métodos `*_with_persona`, injetar init script, override UA/tz via CDP. |
+| `src/proxy.rs` | **editar** — `effective_username_session(session_id)` para fixar IP por persona. |
+| `src/http_client.rs` | **editar** — `BrowserIdentity::from_persona`; extrair `MAJOR_VERSIONS`. |
+| `src/search.rs` | **editar** — integrar persona + `behavior::perform_search`. |
+| `src/youtube.rs` | **editar** — integrar persona no `fetch_youtube_html`; opcional `perform_search` em `discover_podcast_channels`. |
+| `src/crawler.rs` | **editar** — propagar persona ao `fetch_html_with_options_and_persona`. |
+| `src/state.rs` | **editar** — nenhum em princípio; `BrowserModule::clone` continua válido (persona gerada por fetch). |
+| `src/lib.rs` | **editar** — `pub mod persona; pub mod stealth; pub mod behavior;` |
+| `AGENTS.md` (se houver) | **editar** — nota sobre reqwest reservado a binários; pessoaUma por sessão. |
+| `Cargo.toml` | **verificar** — `rand` (`0.8.5`) já presente; se precisar `rand_distr` para Gaussiana, adicionar `rand_distr = "0.4"` (alternativa: Box-Muller manual). |
+
+## Ordem recomendada de execução
+
+1. **Fase 1** (`persona.rs`) — sem dependências; testável isoladamente.
+2. **Fase 6 parte A** (`http_client.rs` — `from_persona`) — unifica listas de versão.
+3. **Fase 3** (`stealth.rs`) — função pura; testável em fixture local.
+4. **Fase 2** (`browser.rs`) — injetar stealth + override UA/tz.
+5. **Fase 4** (`behavior.rs`) — funções `lib`; testável em `data:text/html`.
+6. **Fase 8** (`search.rs`/`youtube.rs`) — integra comportamento ao fluxo.
+7. **Fase 7** (`proxy.rs`) — fixar IP por persona.
+8. **Fase 5** — auditoria (sem código).
+
+## Verificação
+
+- `cargo fmt --check`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test --workspace` (testes unitários de `persona`, `stealth`, `behavior` com `data:text/html` fixtures)
+- `cargo test -- --ignored` para testes que exigem proxy real habilitado (manual).
+
+## Riscos e mitigações
+
+| Risco | Mitigação |
+|---|---|
+| Script CDP longo com erros sintáticos | Manter como `r###"..."###` raw string; teste carrega em `data:text/html` e executa antes de qualquer assertion. |
+| WebRTC arg ignrado em modo headless novo | Validar via `chrome://webrtc-internals` em build dev; nunca作案. |
+| `SetUserAgentOverride` não cobre Client Hints (`sec-ch-ua` em fetch) | Usar `setUserAgentOverride` com `userAgentMetadata` completo (pera. CDP `Emulation.setUserAgentOverride` suporta `acceptLanguage` + `platform`; `userAgentMetadata` trata Client Hints — implementar). |
+| IP fixo por persona não conflita com rotação per-request atual | Manter `rotation=per_request` como default; introduzir `sessid` apenas quando `persona.proxy_session_id()` for set. |
+| Degradação de throughput (mouse+teclado somam ~3–8 seg por pesquisa) | Flag `config.simulate_interaction: bool` default `true`, downgrade em modo bulk. |