Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(cdp): publish CSS and accessibility replies at the renderer
ldm044011a899cef
diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rsindex 0996f34b5..23eaf7b2c 100644--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs@@ -3381,3 +3381,175 @@ async fn websocket_cdp_owner_registry_shutdown_joins_shared_default_page_owner()abort_test_cdp_server(server).await;}++async fn assert_native_isolate_handler_waits_for_resume(method: &str) {+ let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(+ Router::new().route("/page", get(|| async {+ axum::response::Html("<!doctype html><style>input {color: red}</style><form><input id=number autocomplete=cc-number></form>")+ })),+ "native-isolate-entry",+ );+ let (addr, server) = spawn_test_protocol_server().await;+ let (mut browser, _) =+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))+ .await+ .unwrap();+ let context = cdp_create_browser_context(&mut browser, 1).await;+ let target = cdp_create_attached_target(&mut browser, 2, &context).await;+ let session = Some(target.session_id.as_str());+ navigate_fixture_document(+ &mut browser,+ 4,+ &target,+ &format!("http://{fixture_addr}/page"),+ )+ .await;+ let document = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;+ let root = response_by_id(&document, 5)["result"]["root"]["nodeId"]+ .as_u64()+ .unwrap();+ let query = send_cdp_command(+ &mut browser,+ 6,+ "DOM.querySelector",+ session,+ json!({"nodeId": root, "selector": "#number"}),+ )+ .await;+ let node = response_by_id(&query, 6)["result"]["nodeId"]+ .as_u64()+ .unwrap_or_else(|| panic!("fixture query failed after parsing: {query:#?}"));+ let describe = send_cdp_command(+ &mut browser,+ 7,+ "DOM.describeNode",+ session,+ json!({"nodeId": node}),+ )+ .await;+ let backend = response_by_id(&describe, 7)["result"]["node"]["backendNodeId"]+ .as_u64()+ .unwrap();+ let css = send_cdp_command(&mut browser, 8, "CSS.enable", session, json!({})).await;+ let stylesheet = css+ .iter()+ .find(|message| message["method"] == "CSS.styleSheetAdded")+ .expect("fixture inline stylesheet")["params"]["header"]["styleSheetId"]+ .clone();+ let (params, expression, expected) = match method {+ "Page.setDocumentContent" => (+ json!({"frameId": target.target_id, "html": "<!doctype html><body>resumed content</body>"}),+ "document.body.textContent",+ json!("resumed content"),+ ),+ "Page.resetNavigationHistory" => (json!({}), "history.length", json!(1)),+ "Autofill.trigger" => (+ json!({"fieldId": backend, "card": {+ "number": "4444444444444448", "name": "Test Card", "expiryMonth": "12", "expiryYear": "2030", "cvc": "123"+ }}),+ "document.getElementById('number').value",+ json!("4444444444444448"),+ ),+ "CSS.setStyleSheetText" => (+ json!({"styleSheetId": stylesheet, "text": "input {color: blue}"}),+ "document.querySelector('style').textContent",+ json!("input {color: blue}"),+ ),+ "Emulation.setHardwareConcurrencyOverride" => (+ json!({"hardwareConcurrency": 4}),+ "navigator.hardwareConcurrency",+ json!(4),+ ),+ _ => panic!("unsupported isolate-entry fixture: {method}"),+ };+ let enabled = send_cdp_command(&mut browser, 10, "Debugger.enable", session, json!({})).await;+ assert!(response_by_id(&enabled, 10)["error"].is_null());+ send_cdp_command_without_wait(+ &mut browser,+ 12,+ "Runtime.evaluate",+ session,+ json!({+ "expression": "(() => { history.pushState(null, '', '#one'); debugger; return 42; })()",+ "returnByValue": true+ }),+ )+ .await;+ let paused = recv_until_match(&mut browser, |message| {+ message["sessionId"] == target.session_id && message["method"] == "Debugger.paused"+ })+ .await;+ assert!(paused.iter().all(|message| message["id"] != 12));++ // This must be the first Main command after pausing. An earlier owner-only+ // command would hide a missing requirement by blocking the session lane.+ send_cdp_command_without_wait(&mut browser, 13, method, session, params).await;+ let gate = send_cdp_command(+ &mut browser,+ 14,+ "Performance.getMetrics",+ session,+ json!({}),+ )+ .await;+ assert!(response_by_id(&gate, 14)["error"].is_null());+ assert!(+ gate.iter()+ .all(|message| message["id"] != 12 && message["id"] != 13),+ "{method} must wait for its independent V8 entry: {gate:?}"+ );+ send_cdp_command_without_wait(&mut browser, 15, "Debugger.resume", session, json!({})).await;+ let mut completed = std::collections::HashSet::new();+ let resumed = recv_until_match(&mut browser, |message| {+ if message["sessionId"] == target.session_id+ && let Some(id) = message["id"].as_u64()+ {+ assert!(completed.insert(id), "duplicate terminal: {message}");+ }+ [12, 13, 15].iter().all(|id| completed.contains(id))+ })+ .await;+ assert_eq!(+ response_by_id(&resumed, 12)["result"]["result"]["value"],+ 42+ );+ assert!(+ response_by_id(&resumed, 13)["error"].is_null(),+ "{method}: {resumed:?}"+ );+ assert!(response_by_id(&resumed, 15)["error"].is_null());+ let state = send_cdp_command(+ &mut browser,+ 16,+ "Runtime.evaluate",+ session,+ json!({"expression": expression, "returnByValue": true}),+ )+ .await;+ assert_eq!(+ response_by_id(&state, 16)["result"]["result"]["value"],+ expected,+ "{method}: {state:?}"+ );+ assert!(+ state.iter().all(|message| message["id"] != 13),+ "duplicate terminal: {state:?}"+ );+ browser.close(None).await.unwrap();+ abort_test_cdp_server(server).await;+}++#[tokio::test(flavor = "current_thread")]+async fn cdp_ordering_document_content_waits_for_isolate_owner() {+ assert_native_isolate_handler_waits_for_resume("Page.setDocumentContent").await;+}++#[tokio::test(flavor = "current_thread")]+async fn cdp_ordering_history_reset_waits_for_isolate_owner() {+ assert_native_isolate_handler_waits_for_resume("Page.resetNavigationHistory").await;+}++#[tokio::test(flavor = "current_thread")]+async fn cdp_ordering_stylesheet_edit_waits_for_isolate_owner() {+ assert_native_isolate_handler_waits_for_resume("CSS.setStyleSheetText").await;+}diff --git a/moli-protocol/src/domains/accessibility.rs b/moli-protocol/src/domains/accessibility.rsindex 9a1429f25..a3d9680c9 100644--- a/moli-protocol/src/domains/accessibility.rs+++ b/moli-protocol/src/domains/accessibility.rs@@ -1,3 +1,5 @@+pub(crate) mod native;+use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};use crate::domains::actions::AccessibilityAction;use crate::domains::command_output::CommandOutputPlan;diff --git a/moli-protocol/src/domains/accessibility/native.rs b/moli-protocol/src/domains/accessibility/native.rsnew file mode 100644index 000000000..3c83e2e81--- /dev/null+++ b/moli-protocol/src/domains/accessibility/native.rs@@ -0,0 +1,325 @@+use super::*;+use crate::domains::native::{self, NativeCommandStep};+use moli_core::{+ RendererNativeOperation as Operation, RendererNativeOperationStep as Step,+ RendererNativeProtocolResponse as Response, RendererPageCommand as Command,+ RendererPageReply as Reply,+};++pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<NativeCommandStep> {+ let action = cmd.parse_action::<AccessibilityAction>()?;+ if !action.queries_tree() {+ return None;+ }+ let operation = prepare(conn, cmd, action);+ Some(match operation {+ Ok(operation) => native::start_operation(conn, cmd, operation),+ Err(error) => {+ NativeCommandStep::Complete(CommandOutputPlan::error(error.code, error.message))+ }+ })+}++type StartError = PendingAccessibilityCommandStartError;++fn prepare(+ conn: &CdpConnection,+ cmd: &Cmd<'_>,+ action: AccessibilityAction,+) -> Result<Operation, StartError> {+ let top_frame_id = helpers::top_frame_id_for_session(conn, cmd.session_id)+ .ok_or_else(StartError::no_document_loaded)?;+ match action {+ AccessibilityAction::GetFullAxTree => {+ let params = cmd+ .get_params::<helpers::GetFullAxTreeParams>()+ .map_err(|_| StartError::invalid_params())?+ .unwrap_or(helpers::GetFullAxTreeParams {+ depth: None,+ frame_id: None,+ });+ let max_depth = match params.depth {+ Some(depth) => {+ let depth = i32::try_from(depth).map_err(|_| StartError::invalid_params())?;+ (depth >= 0).then_some(depth)+ }+ None => None,+ };+ Ok(frame_operation(+ top_frame_id,+ params.frame_id.map(|id| id.as_ref().to_owned()),+ max_depth,+ false,+ ))+ }+ AccessibilityAction::GetRootAxNode => {+ let params = cmd+ .get_params::<helpers::FrameScopedParams>()+ .map_err(|_| StartError::invalid_params())?+ .unwrap_or(helpers::FrameScopedParams { frame_id: None });+ Ok(frame_operation(top_frame_id, params.frame_id, None, true))+ }+ AccessibilityAction::GetChildAxNodes => {+ let params = cmd+ .get_params::<helpers::ChildAxNodesParams>()+ .ok()+ .flatten()+ .ok_or_else(StartError::invalid_params)?;+ let backend_node_id = helpers::parse_ax_backend_node_id(params.id.as_ref())+ .ok_or_else(StartError::invalid_params)?;+ let frame_id = params+ .frame_id+ .map(|id| id.as_ref().to_owned())+ .unwrap_or_else(|| top_frame_id.clone());+ Ok(backend_operation(+ backend_node_id,+ frame_id,+ top_frame_id,+ AccessibilityNodeOperation::Children,+ ))+ }+ AccessibilityAction::GetAxNodeAndAncestors => {+ let params = cmd+ .get_params::<helpers::AncestorsParams>()+ .ok()+ .flatten()+ .ok_or_else(StartError::invalid_params)?;+ reference_operation(+ conn,+ cmd,+ params.reference,+ params.frame_id,+ top_frame_id,+ AccessibilityNodeOperation::Ancestors,+ )+ }+ AccessibilityAction::QueryAxTree => {+ let params = cmd+ .get_params::<helpers::QueryAxTreeParams>()+ .ok()+ .flatten()+ .ok_or_else(StartError::invalid_params)?;+ reference_operation(+ conn,+ cmd,+ params.reference,+ params.frame_id,+ top_frame_id,+ AccessibilityNodeOperation::Query {+ accessible_name: params.accessible_name,+ role: params.role,+ },+ )+ }+ AccessibilityAction::GetPartialAxTree => {+ let params = cmd+ .get_params::<helpers::PartialAxTreeParams>()+ .ok()+ .flatten()+ .ok_or_else(StartError::invalid_params)?;+ reference_operation(+ conn,+ cmd,+ params.reference,+ params.frame_id,+ top_frame_id,+ AccessibilityNodeOperation::Partial {+ fetch_relatives: params.fetch_relatives.unwrap_or(true),+ },+ )+ }+ AccessibilityAction::Enable | AccessibilityAction::Disable => unreachable!(),+ }+}++fn frame_operation(+ top_frame_id: String,+ frame_id: Option<String>,+ max_depth: Option<i32>,+ root_only: bool,+) -> Operation {+ let frame_id = frame_id.unwrap_or_else(|| top_frame_id.clone());+ let child = frame_id != top_frame_id;+ let command = match (child, root_only) {+ (false, false) => Command::AccessibilityTreePayloadsForDocument { max_depth },+ (false, true) => Command::AccessibilityNodePayloadForDocument,+ (true, false) => Command::AccessibilityTreePayloadsForChildFrame {+ frame_id,+ max_depth,+ },+ (true, true) => Command::AccessibilityNodePayloadForChildFrame { frame_id },+ };+ Operation::new(command, move |reply| match reply {+ Ok(Reply::OptionalAccessibilityPayload(Some(node))) => {+ Response::success(json!({"node": node}))+ }+ Ok(Reply::OptionalAccessibilityPayloads(Some(nodes))) => {+ Response::success(json!({"nodes": nodes}))+ }+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(Some(payload))) => {+ match payload.payloads {+ Some(mut nodes) if root_only => {+ if nodes.is_empty() {+ node_not_found()+ } else {+ Response::success(json!({"node": nodes.remove(0)}))+ }+ }+ Some(nodes) => Response::success(json!({"nodes": nodes})),+ None => node_not_found(),+ }+ }+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(None)) => Response::error(+ -32000,+ "Frame with the given id does not belong to the target.",+ ),+ Ok(+ Reply::OptionalAccessibilityPayload(None) | Reply::OptionalAccessibilityPayloads(None),+ ) => Response::error(-32000, "NoDocumentLoaded"),+ Err(error) => {+ let kind = if root_only {+ "root accessibility node"+ } else {+ "accessibility tree"+ };+ let suffix = if child { " for frame" } else { "" };+ Response::error(-32000, format!("Could not build {kind}{suffix}: {error}"))+ }+ _ => unreachable!("frame accessibility reply"),+ })+}++fn reference_operation(+ conn: &CdpConnection,+ cmd: &Cmd<'_>,+ reference: helpers::NodeReferenceParams,+ frame_id: Option<String>,+ top_frame_id: String,+ operation: AccessibilityNodeOperation,+) -> Result<Operation, StartError> {+ let frame_id = frame_id.unwrap_or_else(|| top_frame_id.clone());+ if let Some(object_id) = reference.object_id {+ let session = cmd.session_id.map(str::to_owned);+ let command = match &operation {+ AccessibilityNodeOperation::Ancestors => {+ Command::accessibility_node_and_ancestor_payloads_for_object_id(session, object_id)+ }+ AccessibilityNodeOperation::Query { .. } => {+ Command::accessibility_tree_payloads_for_object_id(session, object_id)+ }+ AccessibilityNodeOperation::Partial { fetch_relatives } => {+ Command::accessibility_partial_tree_payloads_for_object_id(+ session,+ object_id,+ *fetch_relatives,+ )+ }+ AccessibilityNodeOperation::Children => unreachable!(),+ };+ return Ok(Operation::new(command, move |reply| {+ project_nodes(reply, frame_id, top_frame_id, operation)+ }));+ }+ if let Some(backend_node_id) = renderer_backend_node_id_for_reference(&reference) {+ return Ok(backend_operation(+ backend_node_id,+ frame_id,+ top_frame_id,+ operation,+ ));+ }+ let frontend_node_id = reference.node_id.ok_or_else(StartError::node_not_found)?;+ let inspector_session_id =+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);+ Ok(Operation::then_on_nested_main(+ Command::DocumentFrontendNodeBinding {+ inspector_session_id,+ frontend_node_id,+ },+ move |reply| match reply {+ Ok(Reply::DocumentFrontendNodeBinding(+ RendererDomFrontendNodeBindingResolution::BackendNodeId(id),+ )) => Step::Continue(backend_operation(id, frame_id, top_frame_id, operation)),+ Ok(Reply::DocumentFrontendNodeBinding(+ RendererDomFrontendNodeBindingResolution::NotFound,+ )) => Step::Complete(node_not_found()),+ Err(error) => Step::Complete(Response::error(+ -32000,+ format!("Could not resolve frontend node binding: {error}"),+ )),+ _ => unreachable!("accessibility frontend-node lookup reply"),+ },+ ))+}++fn backend_operation(+ backend_node_id: u32,+ frame_id: String,+ top_frame_id: String,+ operation: AccessibilityNodeOperation,+) -> Operation {+ let command = match &operation {+ AccessibilityNodeOperation::Children => {+ Command::AccessibilityChildNodePayloadsForBackendNodeId { backend_node_id }+ }+ AccessibilityNodeOperation::Ancestors => {+ Command::AccessibilityNodeAndAncestorPayloadsForBackendNodeId { backend_node_id }+ }+ AccessibilityNodeOperation::Query { .. } => {+ Command::AccessibilityTreePayloadsForBackendNodeId {+ backend_node_id,+ max_depth: None,+ }+ }+ AccessibilityNodeOperation::Partial { fetch_relatives } => {+ Command::AccessibilityPartialTreePayloadsForBackendNodeId {+ backend_node_id,+ fetch_relatives: *fetch_relatives,+ }+ }+ };+ Operation::new(command, move |reply| {+ project_nodes(reply, frame_id, top_frame_id, operation)+ })+}++fn project_nodes(+ reply: anyhow::Result<Reply>,+ frame_id: String,+ top_frame_id: String,+ operation: AccessibilityNodeOperation,+) -> Response {+ let payload = match reply {+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(Some(payload))) => payload,+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(None)) => return node_not_found(),+ Err(error) => {+ return Response::error(+ -32000,+ format!("Could not build accessibility payload for node: {error}"),+ );+ }+ _ => unreachable!("accessibility node reply"),+ };+ if payload.frame_id.as_deref().unwrap_or(&top_frame_id) != frame_id {+ return node_not_found();+ }+ let Some(mut nodes) = payload.payloads else {+ return node_not_found();+ };+ if let AccessibilityNodeOperation::Query {+ accessible_name,+ role,+ } = operation+ {+ retain_matching_accessibility_nodes(+ &mut nodes,+ accessible_name.as_deref(),+ role.as_deref(),+ );+ }+ Response::success(json!({"nodes": nodes}))+}++fn node_not_found() -> Response {+ Response::error(-32000, "Could not find node with given id")+}diff --git a/moli-protocol/src/domains/accessibility/tests.rs b/moli-protocol/src/domains/accessibility/tests.rsindex 9a798a17f..077fb5aae 100644--- a/moli-protocol/src/domains/accessibility/tests.rs+++ b/moli-protocol/src/domains/accessibility/tests.rs@@ -13,7 +13,9 @@ async fn complete_pending_command_task_for_test(let completed = pending.wait().await;match ctx.conn.complete_pending_command_dispatch(completed).await {CdpCommandTaskStep::Pending(next) => pending = *next,- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts(),+ CdpCommandTaskStep::Complete(outcome) => {+ return ctx.route_completed_command_outcome_for_test(outcome).await;+ }}}}@@ -23,7 +25,11 @@ async fn complete_command_task_for_test(step: CdpCommandTaskStep,) -> Vec<Value> {match step {- CdpCommandTaskStep::Complete(outcome) => outcome.into_parts().0,+ CdpCommandTaskStep::Complete(outcome) => {+ ctx.route_completed_command_outcome_for_test(outcome)+ .await+ .0+ }CdpCommandTaskStep::Pending(pending) => {complete_pending_command_task_for_test(ctx, *pending).await@@ -435,7 +441,7 @@ async fn accessibility_loaded_page_methods_target_background_owner_without_activ"method": "Accessibility.getFullAXTree"})).await;- let full_tree = ctx.take_one();+ let full_tree = ctx.take_response_by_id(201);assert_eq!(full_tree["sessionId"], "SID-background");let nodes = full_tree["result"]["nodes"].as_array()@@ -554,7 +560,7 @@ async fn accessibility_loaded_page_methods_target_inactive_owner_without_activat"method": "Accessibility.getFullAXTree"})).await;- let full_tree = ctx.take_one();+ let full_tree = ctx.take_response_by_id(211);assert_eq!(full_tree["sessionId"], "SID-inactive");let nodes = full_tree["result"]["nodes"].as_array()@@ -570,7 +576,7 @@ async fn accessibility_loaded_page_methods_target_inactive_owner_without_activat"method": "Accessibility.getRootAXNode"})).await;- let root = ctx.take_one();+ let root = ctx.take_response_by_id(212);assert_eq!(root["sessionId"], "SID-inactive");assert_eq!(root["result"]["node"]["role"]["value"], "RootWebArea");assert_eq!(@@ -1970,7 +1976,7 @@ async fn get_ax_node_and_ancestors_object_id_completes_with_single_renderer_commelse {panic!("top-frame object id AX lookup should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"AX top-frame object lookup should not enqueue scheduler events: {scheduler_events:?}"@@ -2282,7 +2288,7 @@ async fn async_dispatch_get_ax_node_and_ancestors_accepts_child_frame_object_id(else {panic!("child-frame object id AX lookup should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"AX child-frame object lookup should not enqueue scheduler events: {scheduler_events:?}"@@ -2364,7 +2370,8 @@ async fn child_frame_ax_reference_accepts_renderer_backend_node_id_live() {"{method} with child renderer backend id should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) =+ ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"{method} should not enqueue scheduler events: {scheduler_events:?}"@@ -2839,7 +2846,7 @@ async fn async_dispatch_query_ax_tree_accepts_child_frame_object_id() {else {panic!("child-frame object id AX query should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"AX child-frame object query should not enqueue scheduler events: {scheduler_events:?}"@@ -3165,7 +3172,7 @@ async fn async_dispatch_get_partial_ax_tree_accepts_child_frame_object_id() {"child-frame object id partial AX lookup should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"AX child-frame object partial lookup should not enqueue scheduler events: {scheduler_events:?}"diff --git a/moli-protocol/src/domains/css.rs b/moli-protocol/src/domains/css.rsindex b022d2656..1827c3a3b 100644--- a/moli-protocol/src/domains/css.rs+++ b/moli-protocol/src/domains/css.rs@@ -1,3 +1,5 @@+pub(crate) mod native;+use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};use crate::domains::actions::CssAction;use crate::domains::command_output::CommandOutputPlan;@@ -777,7 +779,9 @@ mod tests {let completed = pending.wait().await;match ctx.conn.complete_pending_command_dispatch(completed).await {CdpCommandTaskStep::Pending(next) => pending = *next,- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts(),+ CdpCommandTaskStep::Complete(outcome) => {+ return ctx.route_completed_command_outcome_for_test(outcome).await;+ }}}}@@ -1276,8 +1280,8 @@ mod tests {.position(|message| message["method"] == json!("CSS.styleSheetAdded")).expect("CSS.styleSheetAdded event");assert!(- response_pos < first_event_pos,- "stylesheet event should follow CSS.enable response: {:?}",+ first_event_pos < response_pos,+ "stylesheet event should precede CSS.enable response: {:?}",ctx.sent);@@ -1683,6 +1687,9 @@ mod tests {.await.expect("background page should load");+ let active_renderer = crate::conn::RendererPageResidenceIdentity::from_page(&active_page);+ let background_renderer =+ crate::conn::RendererPageResidenceIdentity::from_page(&background_page);let mut browser_context = BrowserContext::new("BID-css-owner-route".to_owned());browser_context.set_active_target_id("TID-css-active".to_owned());browser_context@@ -1702,6 +1709,26 @@ mod tests {.replace_loaded_page(Some(background_page));ctx.conn.install_browser_context_fixture_for_test(browser_context);+ // These fixture Pages bypass production attachment. Preserve their+ // exact stream owners before any command publishes a native response.+ for (target, renderer) in [+ ("TID-css-active", active_renderer),+ ("TID-css-background", background_renderer),+ ] {+ let owner = crate::conn::CommandOwnerScope::for_route(+ crate::conn::CdpSessionRoute::PageTarget {+ browser_context_id: "BID-css-owner-route".to_owned(),+ target_id: target.to_owned(),+ session_key: moli_page_types::DevToolsSessionKey::Primary,+ },+ );+ let residence = ctx+ .conn+ .target_page_residence_identity_for_owner(&owner)+ .unwrap();+ ctx.conn+ .bind_renderer_page_output_owner(renderer, residence);+ }let background_session = attach_page_session_async(&mut ctx, "TID-css-background").await;let active_style_sheet_id = inline_style_sheet_id_for_session_async(&mut ctx, None).await;@@ -2370,7 +2397,8 @@ mod tests {let CdpCommandTaskStep::Complete(outcome) = step else {panic!("CSS objectId computed style should complete after one renderer command");};- let (messages, scheduler_events) = outcome.into_parts();+ let (messages, scheduler_events) =+ ctx.route_completed_command_outcome_for_test(outcome).await;assert!(scheduler_events.is_empty(),"computed style objectId lookup should not enqueue scheduler events: {scheduler_events:?}"diff --git a/moli-protocol/src/domains/css/native.rs b/moli-protocol/src/domains/css/native.rsnew file mode 100644index 000000000..571ea267f--- /dev/null+++ b/moli-protocol/src/domains/css/native.rs@@ -0,0 +1,212 @@+use super::*;+use crate::domains::native::{self, NativeCommandStep};+use moli_core::{+ RendererNativeOperation as Operation, RendererNativeOperationStep as Step,+ RendererNativeProtocolResponse as Response, RendererPageCommand as Command,+ RendererPageReply as Reply,+};++pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<NativeCommandStep> {+ let action = cmd.parse_action::<CssAction>()?;+ let inspector_session_id =+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);+ let frame_id = top_frame_id_for_session(conn, cmd.session_id).unwrap_or_default();+ let invalid_params =+ || NativeCommandStep::Complete(CommandOutputPlan::error(-32602, "InvalidParams"));+ let operation = match action {+ CssAction::Enable => {+ conn.mutate_target_page_state_for_session(cmd.session_id, |state| {+ state.css_enabled = true+ });+ Operation::new(+ Command::StyleSheetInventoryForDocument {+ inspector_session_id,+ },+ move |reply| match reply {+ Ok(Reply::StyleSheetInventory(update)) => {+ let mut response = Response::success(json!({}));+ for id in update.removed {+ response.notifications.push(json!({"method": "CSS.styleSheetRemoved", "params": {"styleSheetId": id}}).into());+ }+ for header in update.added {+ response.notifications.push(json!({"method": "CSS.styleSheetAdded", "params": {+ "header": style_sheets::style_sheet_header_value(&frame_id, &header),+ }}).into());+ }+ response+ }+ Err(error) => Response::error(-32000, error.to_string()),+ _ => unreachable!("CSS inventory reply"),+ },+ )+ }+ CssAction::Disable => {+ conn.mutate_target_page_state_for_session(cmd.session_id, |state| {+ state.css_enabled = false+ });+ Operation::new(+ Command::ResetCssAgentSession {+ inspector_session_id,+ },+ |reply| match reply {+ Ok(Reply::Unit) => Response::success(json!({})),+ Err(error) => Response::error(-32000, error.to_string()),+ _ => unreachable!("CSS reset reply"),+ },+ )+ }+ CssAction::GetStyleSheet => {+ let params = match cmd.get_params::<StyleSheetIdParams>() {+ Ok(Some(params)) => params,+ _ => return Some(invalid_params()),+ };+ let id = params.style_sheet_id.as_ref().to_owned();+ Operation::new(+ Command::StyleSheetPayloadForStyleSheetId {+ inspector_session_id,+ style_sheet_id: id.clone(),+ },+ move |reply| match reply {+ Ok(Reply::OptionalStyleSheetPayload(Some(payload))) => {+ style_sheets::get_style_sheet_command_output_plan(&id, &frame_id, payload)+ .into_native_response()+ }+ Ok(Reply::OptionalStyleSheetPayload(None)) => {+ Response::error(-32000, "Could not find stylesheet with given id")+ }+ Err(error) => Response::error(-32000, error.to_string()),+ _ => unreachable!("CSS stylesheet reply"),+ },+ )+ }+ CssAction::SetStyleSheetText => {+ let params = match cmd.get_params::<SetStyleSheetTextParams>() {+ Ok(Some(params)) => params,+ _ => return Some(invalid_params()),+ };+ let id = params.style_sheet_id.as_ref().to_owned();+ Operation::new(+ Command::SetInlineStyleSheetTextForStyleSheetId {+ inspector_session_id,+ style_sheet_id: id.clone(),+ text: params.text,+ },+ move |reply| match reply {+ Ok(Reply::Bool(true)) => {+ Response::success(json!({"styleSheetId": id, "sourceMapURL": ""}))+ }+ Ok(Reply::Bool(false)) => {+ Response::error(-32000, "Could not find stylesheet with given id")+ }+ Err(error) => Response::error(-32000, error.to_string()),+ _ => unreachable!("CSS text mutation reply"),+ },+ )+ }+ CssAction::GetComputedStyleForNode+ | CssAction::GetInlineStylesForNode+ | CssAction::GetMatchedStylesForNode => {+ let params = match cmd.get_params::<NodeReferenceParams>() {+ Ok(Some(params)) => params,+ _ => return Some(invalid_params()),+ };+ let query = match action {+ CssAction::GetComputedStyleForNode => StyleQuery::Computed,+ CssAction::GetInlineStylesForNode => {+ StyleQuery::Inline(InlineStyleQueryKind::InlineStyles)+ }+ CssAction::GetMatchedStylesForNode => {+ StyleQuery::Inline(InlineStyleQueryKind::MatchedStyles)+ }+ _ => unreachable!(),+ };+ if let Some(object_id) = params.object_id {+ if matches!(query, StyleQuery::Inline(_)) {+ // The existing native API has no inline-style object-id+ // lookup. Preserve its explicit unsupported-method result.+ return None;+ }+ Operation::new(+ Command::computed_style_properties_for_object_id(+ cmd.session_id.map(str::to_owned),+ object_id,+ ),+ move |reply| project_style(reply, query),+ )+ } else if let Some(frontend_node_id) = params.node_id {+ Operation::then_on_nested_main(+ Command::DocumentFrontendNodeBinding {+ inspector_session_id,+ frontend_node_id,+ },+ move |reply| match reply {+ Ok(Reply::DocumentFrontendNodeBinding(resolution)) => {+ match node_references::backend_node_id_from_frontend_resolution(+ resolution,+ ) {+ Some(id) => Step::Continue(backend_style_operation(id, query)),+ None => Step::Complete(Response::error(+ -32000,+ "Could not find node with given id",+ )),+ }+ }+ Err(error) => Step::Complete(Response::error(+ -32000,+ format!("Could not resolve frontend node binding: {error}"),+ )),+ _ => unreachable!("CSS frontend-node lookup reply"),+ },+ )+ } else if let Some(backend_node_id) = params.backend_node_id {+ backend_style_operation(backend_node_id, query)+ } else {+ return Some(NativeCommandStep::Complete(CommandOutputPlan::error(+ -32000,+ "Could not find node with given id",+ )));+ }+ }+ };+ Some(native::start_operation(conn, cmd, operation))+}++#[derive(Clone, Copy)]+enum StyleQuery {+ Computed,+ Inline(InlineStyleQueryKind),+}++fn backend_style_operation(backend_node_id: u32, query: StyleQuery) -> Operation {+ let command = match query {+ StyleQuery::Computed => {+ Command::ComputedStylePropertiesForBackendNodeId { backend_node_id }+ }+ StyleQuery::Inline(_) => {+ Command::DocumentNodeAttributesForBackendNodeId { backend_node_id }+ }+ };+ Operation::new(command, move |reply| project_style(reply, query))+}++fn project_style(reply: anyhow::Result<Reply>, query: StyleQuery) -> Response {+ match (query, reply) {+ (StyleQuery::Computed, Ok(Reply::ComputedStyleProperties(Some(properties)))) => {+ computed_style_command_output_plan(properties).into_native_response()+ }+ (StyleQuery::Computed, Ok(Reply::ComputedStyleProperties(None))) => {+ Response::error(-32000, "Could not find node with given id")+ }+ (StyleQuery::Inline(kind), Ok(Reply::DocumentNodeAttributesResolution(attributes))) => {+ match inline_style_result_from_attributes_resolution(attributes, kind) {+ Ok(result) => Response::success(result),+ Err(error) => Response::error(error.code, error.message),+ }+ }+ (StyleQuery::Computed, Err(error)) => {+ Response::error(-32000, format!("failed to compute style: {error}"))+ }+ (_, Err(error)) => Response::error(-32000, error.to_string()),+ _ => unreachable!("CSS native style reply"),+ }+}diff --git a/moli-protocol/src/domains/css/style_sheets.rs b/moli-protocol/src/domains/css/style_sheets.rsindex 19bf31693..bb945e96f 100644--- a/moli-protocol/src/domains/css/style_sheets.rs+++ b/moli-protocol/src/domains/css/style_sheets.rs@@ -127,7 +127,7 @@ fn set_css_enabled(conn: &mut CdpConnection, cmd: &Cmd<'_>, enabled: bool) {});}-fn style_sheet_header_value(frame_id: &str, header: &RendererStyleSheetHeader) -> Value {+pub(super) fn style_sheet_header_value(frame_id: &str, header: &RendererStyleSheetHeader) -> Value {json!({"styleSheetId": header.style_sheet_id,"frameId": frame_id,diff --git a/moli-protocol/src/domains/native.rs b/moli-protocol/src/domains/native.rsindex d9335ffa8..667d2dc25 100644--- a/moli-protocol/src/domains/native.rs+++ b/moli-protocol/src/domains/native.rs@@ -155,6 +155,8 @@ pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<Nativmatch cmd.method.split_once('.')?.0 {"Page" => super::page::native::try_start,"DOMSnapshot" => super::dom_snapshot::try_start_native_command,+ "CSS" => super::css::native::try_start,+ "Accessibility" => super::accessibility::native::try_start,_ => return None,};frontend_attachment(conn, cmd)?;