Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
Remove renderer backqueries from inspector output routing
ldm05c9ce1adcd9e
diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rsindex bfc44c718..e23f1757a 100644--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs@@ -5339,7 +5339,7 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_paus"method": "Runtime.evaluate","sessionId": session_id,"params": {- "expression": "(function outer(){ function inner(){ debugger; return 40; } return inner() + 2; })()",+ "expression": "(function outer(){ function inner(){ console.log('moli debugger prefix', document.body); debugger; return 40; } return inner() + 2; })()","returnByValue": true}})@@ -5357,6 +5357,24 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_paus!observed.iter().any(|message| message["id"] == json!(5_u64)),"Runtime.evaluate must remain pending while the renderer owner is paused: {observed:#?}");+ let console_position = observed+ .iter()+ .position(|message| {+ message["sessionId"].as_str() == Some(session_id.as_str())+ && message["method"] == json!("Runtime.consoleAPICalled")+ && message["params"]["args"][0]["value"] == json!("moli debugger prefix")+ && message["params"]["args"][1]["objectId"].is_string()+ && message["params"]["args"][1]["subtype"] == json!("node")+ })+ .unwrap_or_else(|| panic!("console prefix must be visible before pause: {observed:#?}"));+ let pause_position = observed+ .iter()+ .position(|message| message["method"] == json!("Debugger.paused"))+ .expect("nested Runtime.evaluate should emit Debugger.paused");+ assert!(+ console_position < pause_position,+ "the suspending prefix must preserve console -> debugger pause order: {observed:#?}"+ );let initial_pause = observed.iter().find(|message| message["method"] == json!("Debugger.paused"))@@ -5936,6 +5954,97 @@ async fn websocket_cdp_handle_javascript_dialog_accept_resumes_confirm_with_true"accepted confirm should return true to page JavaScript: {observed:#?}");+ let receiver = send_cdp_command(+ &mut socket,+ 14,+ "Runtime.evaluate",+ Some(&session_id),+ json!({ "expression": "({})" }),+ )+ .await;+ let receiver_object_id = receiver+ .iter()+ .find(|message| message["id"] == json!(14_u64))+ .and_then(|message| message["result"]["result"]["objectId"].as_str())+ .expect("Runtime.evaluate should return a receiver objectId")+ .to_owned();+ socket+ .send(WsMessage::Text(+ json!({+ "id": 15_u64,+ "method": "Runtime.callFunctionOn",+ "sessionId": session_id,+ "params": {+ "objectId": receiver_object_id,+ "functionDeclaration": "function () { console.log('moli callFunctionOn marker', document.body); return confirm('moli callFunctionOn confirm'); }",+ "awaitPromise": true,+ "returnByValue": true,+ "userGesture": true+ }+ })+ .to_string()+ .into(),+ ))+ .await+ .expect("send Runtime.callFunctionOn that opens confirm");+ let mut called = recv_until_match(&mut socket, |message| {+ message["sessionId"].as_str() == Some(session_id.as_str())+ && message["method"] == json!("Page.javascriptDialogOpening")+ && message["params"]["message"] == json!("moli callFunctionOn confirm")+ })+ .await;+ assert!(+ !called.iter().any(|message| message["id"] == json!(15_u64)),+ "Runtime.callFunctionOn must remain pending while confirm is open: {called:#?}"+ );+ let console_position = called+ .iter()+ .position(|message| {+ message["sessionId"].as_str() == Some(session_id.as_str())+ && message["method"] == json!("Runtime.consoleAPICalled")+ && message["params"]["args"][0]["value"] == json!("moli callFunctionOn marker")+ && message["params"]["args"][1]["objectId"].is_string()+ && message["params"]["args"][1]["subtype"] == json!("node")+ })+ .unwrap_or_else(|| {+ panic!("console output before callFunctionOn confirm must be published: {called:#?}")+ });+ let dialog_position = called+ .iter()+ .position(|message| {+ message["sessionId"].as_str() == Some(session_id.as_str())+ && message["method"] == json!("Page.javascriptDialogOpening")+ && message["params"]["message"] == json!("moli callFunctionOn confirm")+ })+ .expect("callFunctionOn confirm opening event");+ assert!(+ console_position < dialog_position,+ "the suspending prefix must preserve console -> dialog producer order: {called:#?}"+ );+ called.extend(+ send_cdp_command(+ &mut socket,+ 16,+ "Page.handleJavaScriptDialog",+ Some(&session_id),+ json!({ "accept": true }),+ )+ .await,+ );+ if !called.iter().any(|message| message["id"] == json!(15_u64)) {+ called+ .extend(recv_until_match(&mut socket, |message| message["id"] == json!(15_u64)).await);+ }+ let call_function = called+ .iter()+ .find(|message| message["id"] == json!(15_u64))+ .expect("Runtime.callFunctionOn should resolve after confirm is handled");+ assert_eq!(+ call_function["result"]["result"]["value"],+ json!(true),+ "accepted confirm should return true through Runtime.callFunctionOn: {called:#?}"+ );+socket.send(WsMessage::Text(json!({diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rsindex 865166adb..3ed8cbe57 100644--- a/moli-protocol/src/conn/dispatch.rs+++ b/moli-protocol/src/conn/dispatch.rs@@ -215,15 +215,6 @@ impl PendingCdpCommandDispatch {}}- pub fn runtime_deferred_reply_page_owner_access_allowed(&self) -> bool {- match &self.inner {- PendingCdpCommandDispatchKind::Runtime(pending) => {- pending.deferred_reply_page_owner_access_allowed()- }- _ => false,- }- }-pub fn waits_for_scheduler_deferred_inspector_reply(&self) -> bool {match &self.inner {PendingCdpCommandDispatchKind::Runtime(pending) => {@@ -388,15 +379,6 @@ impl CompletedCdpCommandDispatch {pub fn kind_name(&self) -> &'static str {self.inner.name()}-- pub fn runtime_command_page_owner_access_allowed(&self) -> Option<bool> {- match &self.inner {- CompletedCdpCommandDispatchKind::Runtime(completed) => {- Some(completed.page_owner_access_allowed())- }- _ => None,- }- }}fn append_command_output_plan(diff --git a/moli-protocol/src/conn/inspector_route.rs b/moli-protocol/src/conn/inspector_route.rsindex 46305a449..e99953223 100644--- a/moli-protocol/src/conn/inspector_route.rs+++ b/moli-protocol/src/conn/inspector_route.rs@@ -436,14 +436,12 @@ mod tests {);let mut ordered_events = Vec::new();assert!(- !ctx.conn- .route_renderer_runtime_command_output_into(- output,- Some(77),- None,- &mut ordered_events,- )- .await,+ !ctx.conn.route_renderer_runtime_command_output_into(+ output,+ Some(77),+ None,+ &mut ordered_events,+ ),"a validated state-only response must not invent a frontend completion");assert!(ordered_events.is_empty());diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rsindex a426ce055..153c1b3bf 100644--- a/moli-protocol/src/conn/runtime_eval.rs+++ b/moli-protocol/src/conn/runtime_eval.rs@@ -635,19 +635,6 @@ impl PendingServiceWorkerRuntimeProtocolMessageDispatch {}impl CompletedRuntimeProtocolMessageDispatch {- pub(crate) fn page_owner_access_allowed(&self) -> bool {- matches!(- self.completion,- moli_core::page::CompletedRuntimeInspectorCommandDispatch::Owner(_)- | moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {- ..- }- | moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(- _- )- )- }-pub(crate) fn session_response_succeeded(&self) -> Option<bool> {match &self.completion {moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {@@ -2695,30 +2682,12 @@ impl CdpConnection {current_seen}- pub(crate) async fn route_renderer_runtime_command_output_into(+ pub(crate) fn route_renderer_runtime_command_output_into(&mut self,output: RendererRuntimeCommandOutput,current_cmd_id: Option<u64>,current_session_id: Option<&str>,ordered_events: &mut Vec<BackgroundProtocolEvent>,- ) -> bool {- self.route_renderer_runtime_command_output_with_page_owner_access_into(- output,- current_cmd_id,- current_session_id,- true,- ordered_events,- )- .await- }-- pub(crate) async fn route_renderer_runtime_command_output_with_page_owner_access_into(- &mut self,- output: RendererRuntimeCommandOutput,- current_cmd_id: Option<u64>,- current_session_id: Option<&str>,- page_owner_access_allowed: bool,- ordered_events: &mut Vec<BackgroundProtocolEvent>,) -> bool {if let Some(attachment_id) = output.renderer_agent_attachment_id()&& !self.renderer_agent_attachment_is_current_for_session_owner(@@ -2740,25 +2709,7 @@ impl CdpConnection {self.merge_v8_inspector_session_state_for_session_owner(current_session_id, state);}let mut current_seen = false;- for mut message in output.into_messages() {- // Pause-loop responses are already concrete V8 protocol output.- // Context and DOM-node normalization can enqueue Page commands,- // so preserve the raw response until that owner can run again.- if page_owner_access_allowed- && let RendererRuntimeInspectorMessage::Protocol(message) = &mut message- {- let mut message_value = message.value_mut();- self.normalize_runtime_event_context_ids_for_session_owner_async(- current_session_id,- &mut message_value,- )- .await;- self.normalize_node_remote_objects_for_session_owner_async(- current_session_id,- &mut message_value,- )- .await;- }+ for message in output.into_messages() {let mut response_events = Vec::new();let mut background_events = Vec::new();current_seen |= self@@ -2775,7 +2726,7 @@ impl CdpConnection {current_seen}- pub(crate) async fn route_renderer_command_turn_output_into(+ pub(crate) fn route_renderer_command_turn_output_into(&mut self,output: RendererCommandTurnOutput,current_cmd_id: Option<u64>,@@ -2799,8 +2750,7 @@ impl CdpConnection {current_cmd_id,current_session_id,ordered_events,- )- .await,+ ),renderer_output_predecessor,)}@@ -2958,18 +2908,16 @@ impl CdpConnection {response.into_renderer_command_output();let (renderer_agent_attachment_id, v8_state_update, messages) = output.into_parts();let mut ordered_events = Vec::new();- let current_seen = self- .route_renderer_runtime_command_output_into(- RendererRuntimeCommandOutput::from_parts(- renderer_agent_attachment_id,- v8_state_update,- messages,- ),- Some(current_cmd_id),- current_session_id,- &mut ordered_events,- )- .await;+ let current_seen = self.route_renderer_runtime_command_output_into(+ RendererRuntimeCommandOutput::from_parts(+ renderer_agent_attachment_id,+ v8_state_update,+ messages,+ ),+ Some(current_cmd_id),+ current_session_id,+ &mut ordered_events,+ );response_events.extend(ordered_events);let _ = background_events;(current_seen, renderer_output_predecessor)@@ -3405,139 +3353,6 @@ impl CdpConnection {BidiChannelListenerRoute::Event(event)}- pub(crate) async fn normalize_node_remote_objects_for_session_owner_async(- &mut self,- session_id: Option<&str>,- payload: &mut Value,- ) {- let inspector_session_id =- self.target_renderer_runtime_inspector_session_id_for_session(session_id);- let include_whitespace =- crate::domains::dom::dom_agent_includes_whitespace_for_session(self, session_id);- self.normalize_node_remote_objects_by_page_lookup_async(- inspector_session_id.as_deref(),- include_whitespace,- payload,- |connection| connection.runtime_session_owner_page_mut(session_id),- )- .await;- }-- async fn normalize_node_remote_objects_for_runtime_protocol_message_route_async(- &mut self,- session_id: Option<&str>,- route: &RuntimeProtocolMessagePageRoute,- payload: &mut Value,- ) {- let inspector_session_id =- self.target_renderer_runtime_inspector_session_id_for_session(session_id);- let include_whitespace =- crate::domains::dom::dom_agent_includes_whitespace_for_session(self, session_id);- self.normalize_node_remote_objects_by_page_lookup_async(- inspector_session_id.as_deref(),- include_whitespace,- payload,- |connection| connection.runtime_protocol_message_started_page_mut(route),- )- .await;- }-- async fn normalize_node_remote_objects_by_page_lookup_async(- &mut self,- inspector_session_id: Option<&str>,- include_whitespace: bool,- payload: &mut Value,- mut page_lookup: impl for<'a> FnMut(&'a mut Self) -> Result<&'a mut Page, String>,- ) {- let mut paths = Vec::new();- collect_remote_object_paths(payload, "", &mut paths);-- for path in paths {- let Some(remote_object) = payload.pointer(&path) else {- continue;- };- let Some(object_id) = remote_object- .get("objectId")- .and_then(Value::as_str)- .map(str::to_owned)- else {- continue;- };-- let has_subtype = remote_object.get("subtype").is_some();- let is_object_like = remote_object- .get("type")- .and_then(Value::as_str)- .is_some_and(|ty| matches!(ty, "object" | "function"));- if has_subtype || !is_object_like {- continue;- }-- let pending = page_lookup(self).and_then(|page| {- page.start_document_node_snapshot_for_object_id_in_inspector_session(- inspector_session_id.map(str::to_owned),- include_whitespace,- &object_id,- 0,- false,- )- .map_err(|error| error.to_string())- });- let is_node = match pending {- Ok(pending) => match pending.wait().await {- Ok(completion) => page_lookup(self)- .and_then(|page| {- page.finish_document_node_snapshot_for_object_id(completion)- .map_err(|error| error.to_string())- })- .ok()- .flatten()- .is_some(),- Err(_) => false,- },- Err(_) => false,- };- if !is_node {- continue;- }-- if let Some(remote_object) = payload.pointer_mut(&path).and_then(Value::as_object_mut) {- remote_object.insert("subtype".to_owned(), json!("node"));- }- }- }-- pub(crate) async fn normalize_runtime_event_context_ids_for_session_owner_async(- &mut self,- session_id: Option<&str>,- message: &mut Value,- ) {- let Some(method) = message.get("method").and_then(Value::as_str) else {- return;- };- let context_pointer = match method {- "Runtime.consoleAPICalled" => "/params/executionContextId",- "Runtime.exceptionThrown" => "/params/exceptionDetails/executionContextId",- _ => return,- };- let Some(inspector_context_id) = message.pointer(context_pointer).and_then(Value::as_i64)- else {- return;- };- let Ok(Some(compatibility_context_id)) = self- .isolated_execution_context_id_for_inspector_context_for_session_owner_async(- session_id,- inspector_context_id,- )- .await- else {- return;- };- if let Some(context_id) = message.pointer_mut(context_pointer) {- *context_id = json!(compatibility_context_id);- }- }-pub(crate) async fn document_node_snapshot_for_runtime_remote_object_id_async(&mut self,session_id: Option<&str>,@@ -4418,7 +4233,7 @@ impl CdpConnection {let timing_started = moli_trace::cdp_nav_timing_enabled().then(std::time::Instant::now);let inspector_session_id =self.target_renderer_runtime_inspector_session_id_for_session(session_id);- let mut messages = {+ let messages = {let page = self.runtime_session_owner_page_mut(session_id)?;page.dispatch_runtime_protocol_message_for_inspector_session_async(inspector_session_id,@@ -4446,20 +4261,6 @@ impl CdpConnection {elapsed_ms = started.elapsed().as_millis(),);}- for message in &mut messages {- self.normalize_runtime_event_context_ids_for_session_owner_async(session_id, message)- .await;- self.normalize_node_remote_objects_for_session_owner_async(session_id, message)- .await;- }- if let Some(started) = timing_started {- tracing::info!(- target: "moli_cdp_nav_timing",- stage = "runtime_inspector_messages_normalized",- messages = messages.len(),- elapsed_ms = started.elapsed().as_millis(),- );- }Ok(messages)}@@ -4505,24 +4306,10 @@ impl CdpConnection {{response.replace_with_error("Execution context was destroyed by navigation");}- let mut message = response.into_protocol_message_for_typed_runtime_route();- self.normalize_runtime_event_context_ids_for_session_owner_async(session_id, &mut message)- .await;- if !self.runtime_inspector_pause_active_for_session_owner(session_id) {- self.normalize_node_remote_objects_for_session_owner_async(session_id, &mut message)- .await;- }+ let message = response.into_protocol_message_for_typed_runtime_route();Some(RendererRuntimeInspectorMessage::protocol(message))}- pub(crate) fn runtime_inspector_pause_active_for_session_owner(- &mut self,- session_id: Option<&str>,- ) -> bool {- self.runtime_session_owner_page_mut(session_id)- .is_ok_and(|page| page.runtime_inspector_pause_active())- }-pub(crate) fn start_runtime_protocol_message_for_session_owner(&mut self,session_id: Option<&str>,@@ -4796,23 +4583,6 @@ impl CdpConnection {runtime_messages.bind_renderer_agent_attachment(completed.route.renderer_agent_attachment_id);let runtime_messages = runtime_messages.messages_mut();- for runtime_message in runtime_messages.iter_mut() {- let RendererRuntimeInspectorMessage::Protocol(message) = runtime_message else {- continue;- };- let mut message_value = message.value_mut();- self.normalize_runtime_event_context_ids_for_session_owner_async(- completed.session_id.as_deref(),- &mut message_value,- )- .await;- self.normalize_node_remote_objects_for_runtime_protocol_message_route_async(- completed.session_id.as_deref(),- &completed.route,- &mut message_value,- )- .await;- }self.restore_frontend_command_ids_in_runtime_messages(completed.session_id.as_deref(),Some(completed.route.renderer_agent_attachment_id),@@ -5121,14 +4891,12 @@ impl CdpConnection {let _ = response_sender.send_output(output);continue;}- let _ = self- .route_renderer_runtime_command_output_into(- output,- None,- frontend_session_id.as_deref(),- &mut events,- )- .await;+ let _ = self.route_renderer_runtime_command_output_into(+ output,+ None,+ frontend_session_id.as_deref(),+ &mut events,+ );}Ok(events)}@@ -5396,7 +5164,6 @@ impl CdpConnection {&mut release_events,&mut release_post_response_events,)- .await.0} else {false@@ -5426,14 +5193,12 @@ impl CdpConnection {renderer_output_predecessor.is_none(),"internal object-group cleanup cannot discard a concrete output cursor");- let release_response_seen = self- .route_renderer_runtime_command_output_into(- output,- Some(command_id),- session_id,- &mut release_events,- )- .await;+ let release_response_seen = self.route_renderer_runtime_command_output_into(+ output,+ Some(command_id),+ session_id,+ &mut release_events,+ );if !release_response_seen {tracing::debug!(command_id,@@ -5555,7 +5320,6 @@ impl CdpConnection {&mut listener_events,&mut listener_post_response_events,)- .await.0} else {false@@ -6042,38 +5806,6 @@ fn send_renderer_replacement_error(}));}-fn collect_remote_object_paths(value: &Value, path: &str, out: &mut Vec<String>) {- let mut stack = vec![(value, path.to_owned(), MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH)];- while let Some((value, path, remaining_tree_depth)) = stack.pop() {- let Some(next_tree_depth) = remaining_tree_depth.checked_sub(1) else {- continue;- };- match value {- Value::Object(map) => {- if map.get("objectId").and_then(Value::as_str).is_some()- && map.get("type").and_then(Value::as_str).is_some()- {- out.push(path.clone());- }-- let children = map.iter().collect::<Vec<_>>();- for (key, child) in children.into_iter().rev() {- let escaped_key = key.replace('~', "~0").replace('/', "~1");- let child_path = format!("{path}/{escaped_key}");- stack.push((child, child_path, next_tree_depth));- }- }- Value::Array(values) => {- for index in (0..values.len()).rev() {- let child_path = format!("{path}/{index}");- stack.push((&values[index], child_path, next_tree_depth));- }- }- Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => {}- }- }-}-fn runtime_realm_info_to_execution_context_event(realm: RendererRuntimeRealmInfo,owner_frame_id: Option<&str>,@@ -7123,32 +6855,6 @@ mod tests {});}- #[test]- fn remote_object_path_collection_respects_protocol_depth_cap() {- run_deep_protocol_value_test("remote-object-path-depth-cap", || {- let value = json!({- "result": {- "type": "object",- "objectId": "OBJECT-1",- }- });- let mut paths = Vec::new();- collect_remote_object_paths(&value, "", &mut paths);- assert_eq!(paths, vec!["/result".to_owned()]);-- let deep_value = deeply_nested_plain_value(- json!({- "type": "object",- "objectId": "too-deep",- }),- MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH + 8,- );- paths.clear();- collect_remote_object_paths(&deep_value, "", &mut paths);- assert!(paths.is_empty());- });- }-#[test]fn bidi_channel_listener_owner_work_publishes_concrete_scheduler_work() {let mut conn = connection_with_bidi_page_session();diff --git a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rsindex 4445cdc5e..b449d58bd 100644--- a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs+++ b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs@@ -66,7 +66,7 @@ impl PreparedProtocolOutputs {Some(prepared)}- pub(in crate::domains::activity) async fn from_renderer_observation(+ pub(in crate::domains::activity) fn from_renderer_observation(conn: &mut CdpConnection,session_id: Option<&str>,source_renderer_agent: moli_core::page::RendererDevToolsAgentToken,@@ -112,7 +112,7 @@ impl PreparedProtocolOutputs {}RendererProtocolObservation::RuntimeInspector(batch) => {let source_batches = vec![batch.clone()];- let mut batches = conn.route_current_renderer_inspector_output_for_session_owner(+ let batches = conn.route_current_renderer_inspector_output_for_session_owner(session_id,source_batches.clone(),);@@ -126,41 +126,6 @@ impl PreparedProtocolOutputs {.append_to_output_sink(&mut prepared);return prepared;}- for batch in &mut batches {- let Some(attachment) = conn- .target_page_protocol_attachment_identity_for_renderer_inspector_route(- session_id,- batch.session.wire_session_id(),- )- else {- continue;- };- let output_session_id = attachment.session_id().map(str::to_owned);- let normalize_node_objects = !conn- .runtime_inspector_pause_active_for_session_owner(- output_session_id.as_deref(),- );- for message in &mut batch.messages {- let moli_core::page::RendererRuntimeInspectorMessage::Protocol(message) =- message- else {- continue;- };- let mut value = message.value_mut();- conn.normalize_runtime_event_context_ids_for_session_owner_async(- output_session_id.as_deref(),- &mut value,- )- .await;- if normalize_node_objects {- conn.normalize_node_remote_objects_for_session_owner_async(- output_session_id.as_deref(),- &mut value,- )- .await;- }- }- }crate::domains::runtime::RuntimePreparedOutputs::from_renderer_runtime_inspector_message_batches(conn,diff --git a/moli-protocol/src/domains/activity/output_ingress/renderer.rs b/moli-protocol/src/domains/activity/output_ingress/renderer.rsindex 6516fd932..ea9f03b54 100644--- a/moli-protocol/src/domains/activity/output_ingress/renderer.rs+++ b/moli-protocol/src/domains/activity/output_ingress/renderer.rs@@ -226,7 +226,6 @@ async fn project_renderer_output_records_for_route(cursor.stream().renderer_agent(),&observation,)- .await};barriers.route_publication_outputs(diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rsindex b5713e1f0..db2102554 100644--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs@@ -753,8 +753,7 @@ mod tests {Some(SESSION_ID),agent_token,&observation,- )- .await;+ );let mut command_context = CommandDispatchContext::default();barriersdiff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rsindex d398450cd..f9a8b0c8c 100644--- a/moli-protocol/src/domains/runtime/dispatcher.rs+++ b/moli-protocol/src/domains/runtime/dispatcher.rs@@ -265,9 +265,6 @@ enum PendingRuntimeCommandKind {routed_output: RuntimeInspectorRoutedOutput,renderer_response_rx: Option<RuntimeInspectorAsyncCompletionReceiver>,claimed_await: Option<ClaimedPendingInspectorAwait>,- // False when V8's nested pause loop, rather than the Page actor,- // consumed the Inspector command.- page_owner_access_allowed: bool,},SharedWorkerInspector {pending: PendingSharedWorkerRuntimeProtocolMessageDispatch,@@ -298,7 +295,6 @@ enum CompletedRuntimeCommandKind {},InspectorDeferredReplyReady {routed_output: RuntimeInspectorRoutedOutput,- page_owner_access_allowed: bool,},SharedWorkerInspector {completed: Result<CompletedSharedWorkerRuntimeProtocolMessageDispatch, String>,@@ -549,16 +545,6 @@ impl PendingRuntimeCommandDispatch {)}- pub(crate) fn deferred_reply_page_owner_access_allowed(&self) -> bool {- matches!(- self.pending,- PendingRuntimeCommandKind::InspectorDeferredReply {- page_owner_access_allowed: true,- ..- }- )- }-pub(crate) fn append_scheduler_deferred_inspector_reply_output(&mut self,response_events: Vec<BackgroundProtocolEvent>,@@ -568,7 +554,6 @@ impl PendingRuntimeCommandDispatch {routed_output,renderer_response_rx: _,claimed_await: _,- page_owner_access_allowed: _,} = &mut self.pendingelse {return;@@ -585,7 +570,6 @@ impl PendingRuntimeCommandDispatch {routed_output,renderer_response_rx: _,claimed_await: _,- page_owner_access_allowed: _,} = &mut self.pendingelse {return Vec::new();@@ -682,7 +666,6 @@ impl PendingRuntimeCommandDispatch {routed_output,renderer_response_rx: _,claimed_await,- page_owner_access_allowed,} => {let mut route_scope = owner_scope.enter(conn);route_scope@@ -691,10 +674,7 @@ impl PendingRuntimeCommandDispatch {claimed_await,routed_output.events(),);- CompletedRuntimeCommandKind::InspectorDeferredReplyReady {- routed_output,- page_owner_access_allowed,- }+ CompletedRuntimeCommandKind::InspectorDeferredReplyReady { routed_output }}_ => {unreachable!(@@ -758,11 +738,7 @@ impl PendingRuntimeCommandDispatch {routed_output,renderer_response_rx: _,claimed_await: _,- page_owner_access_allowed,- } => CompletedRuntimeCommandKind::InspectorDeferredReplyReady {- routed_output,- page_owner_access_allowed,- },+ } => CompletedRuntimeCommandKind::InspectorDeferredReplyReady { routed_output },PendingRuntimeCommandKind::SharedWorkerInspector {pending,binding_effect,@@ -812,19 +788,6 @@ impl CompletedRuntimeCommandDispatch {pub(crate) fn session_id(&self) -> Option<&str> {self.owner_scope.session_id()}-- pub(crate) fn page_owner_access_allowed(&self) -> bool {- match &self.completed {- CompletedRuntimeCommandKind::Inspector {- completed: Ok(completed),- } => completed.page_owner_access_allowed(),- CompletedRuntimeCommandKind::InspectorDeferredReplyReady {- page_owner_access_allowed,- ..- } => *page_owner_access_allowed,- _ => true,- }- }}fn command_response_succeeded(@@ -8076,7 +8039,6 @@ async fn route_registered_runtime_response_receiver_into(command_id: Option<u64>,session_id: Option<&str>,response_rx: RuntimeInspectorAsyncCompletionReceiver,- page_owner_access_allowed: bool,routed_output: &mut RuntimeInspectorRoutedOutput,) -> bool {let Some(command_id) = command_id else {@@ -8101,7 +8063,6 @@ async fn route_registered_runtime_response_receiver_into(output,Some(command_id),session_id,- page_owner_access_allowed,routed_output,).await@@ -8112,19 +8073,15 @@ async fn route_runtime_command_output_into_routed_output(output: RendererRuntimeCommandOutput,command_id: Option<u64>,session_id: Option<&str>,- page_owner_access_allowed: bool,routed_output: &mut RuntimeInspectorRoutedOutput,) -> bool {let mut ordered_events = Vec::new();- let saw_current_response = conn- .route_renderer_runtime_command_output_with_page_owner_access_into(- output,- command_id,- session_id,- page_owner_access_allowed,- &mut ordered_events,- )- .await;+ let saw_current_response = conn.route_renderer_runtime_command_output_into(+ output,+ command_id,+ session_id,+ &mut ordered_events,+ );routed_output.append_ordered_events(ordered_events);saw_current_response}@@ -8147,8 +8104,7 @@ async fn route_renderer_command_turn_output_into_routed_output(response_flush,&mut ordered_events,&mut post_response_events,- )- .await;+ );if let Some(predecessor) = renderer_output_predecessor {routed_output.set_renderer_output_predecessor(predecessor);}@@ -8192,13 +8148,11 @@ async fn complete_pending_runtime_inspector_command(let (messages,mut renderer_response_rx,- page_owner_access_allowed,response_delivery,session_response_predecessor,session_response_succeeded,) = match completed_inspector {Ok(mut completed_protocol) => {- let page_owner_access_allowed = completed_protocol.page_owner_access_allowed();let session_response_succeeded = completed_protocol.session_response_succeeded();let session_response_predecessor = completed_protocol.session_response_predecessor();let response_delivery = completed_protocol.response_delivery();@@ -8210,7 +8164,6 @@ async fn complete_pending_runtime_inspector_command(Ok(messages) => (messages,renderer_response_rx,- page_owner_access_allowed,response_delivery,session_response_predecessor,session_response_succeeded,@@ -8229,7 +8182,6 @@ async fn complete_pending_runtime_inspector_command((None,renderer_response_rx,- page_owner_access_allowed,response_delivery,session_response_predecessor,session_response_succeeded,@@ -8354,7 +8306,6 @@ async fn complete_pending_runtime_inspector_command(completed.command_id,completed.session_id(),renderer_response_rx,- page_owner_access_allowed,&mut routed_output,).await;@@ -8377,7 +8328,6 @@ async fn complete_pending_runtime_inspector_command(completed,routed_output,renderer_response_rx,- page_owner_access_allowed,);}let succeeded = session_response_succeeded@@ -8489,7 +8439,6 @@ fn pending_runtime_deferred_inspector_reply_command(completed: RuntimeCommandCompletionMeta,routed_output: RuntimeInspectorRoutedOutput,renderer_response_rx: Option<RuntimeInspectorAsyncCompletionReceiver>,- page_owner_access_allowed: bool,) -> RuntimeCommandTaskStep {let claimed_await = completed.command_id.and_then(|command_id| {conn.claim_pending_inspector_await_for_scheduler_deferred_reply(@@ -8510,7 +8459,6 @@ fn pending_runtime_deferred_inspector_reply_command(routed_output,renderer_response_rx,claimed_await,- page_owner_access_allowed,},}))}@@ -8742,7 +8690,6 @@ async fn complete_pending_runtime_binding_inspector_command(completed.command_id,completed.session_id(),renderer_response_rx,- true,&mut routed_output,).await;@@ -9507,7 +9454,6 @@ async fn complete_pending_shared_worker_runtime_inspector_command(completed.command_id,completed.session_id(),renderer_response_rx,- true,&mut routed_output,).await;@@ -9521,7 +9467,6 @@ async fn complete_pending_shared_worker_runtime_inspector_command(completed,routed_output,renderer_response_rx,- true,);}let succeeded = routed_output.command_response_succeeded(completed.command_id);@@ -9646,7 +9591,6 @@ async fn complete_pending_service_worker_runtime_inspector_command(completed.command_id,completed.session_id(),renderer_response_rx,- true,&mut routed_output,).await;@@ -9660,7 +9604,6 @@ async fn complete_pending_service_worker_runtime_inspector_command(completed,routed_output,renderer_response_rx,- true,);}let succeeded = routed_output.command_response_succeeded(completed.command_id);diff --git a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rsindex 0422381ea..14a0136f4 100644--- a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs+++ b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs@@ -365,6 +365,7 @@ impl RendererDevToolsSession {state,);let session = Rc::new(session);+ outbound.bind_inspector_session(&session);let executor_registration = frontend_session_route.map(|(agent_token, session_key)| {backend.register_session_executor_route(context_group_id,diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex 7533e9fb8..31a7bca9e 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -5,6 +5,7 @@ mod context_registry;mod document_backend;mod input_state;mod outbound;+mod remote_objects;mod v8_backend;use self::agent::RendererDevToolsAgent;diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rsindex 696964f86..b216adfa5 100644--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs@@ -1,3 +1,4 @@+use super::remote_objects::InspectorRemoteObjectCompleter;use crate::devtools::pause::{RendererInspectorPauseNotificationRoute, RendererInspectorPausePrefaceGuard,RendererInspectorSessionOutboundRoute,@@ -67,6 +68,7 @@ pub(in crate::script_vm) struct InspectorOutbound {output_journal: Option<RendererTurnOutputJournal>,messages: SharedInspectorOutboundMessageState,response_routing: SharedInspectorResponseRoutingState,+ remote_objects: InspectorRemoteObjectCompleter,session_route: Rc<RefCell<Option<RendererInspectorSessionOutboundRoute>>>,}@@ -84,6 +86,7 @@ impl InspectorOutbound {output_journal: None,messages: Rc::new(RefCell::new(InspectorOutboundMessageState::default())),response_routing: Rc::new(RefCell::new(InspectorResponseRoutingState::default())),+ remote_objects: InspectorRemoteObjectCompleter::default(),session_route: Rc::new(RefCell::new(None)),}}@@ -108,6 +111,10 @@ impl InspectorOutbound {self.output_journal = output_journal;self}++ pub(super) fn bind_inspector_session(&self, session: &Rc<v8::inspector::V8InspectorSession>) {+ self.remote_objects.bind_session(session);+ }}impl InspectorOutbound {@@ -145,6 +152,7 @@ impl InspectorOutbound {}let mut messages = self.messages.borrow_mut();messages.messages.clear();+ self.remote_objects.clear_session();if let Some(route) = self.session_route.borrow_mut().take() {route.detach_session();}@@ -158,7 +166,10 @@ impl InspectorOutbound {let message_units = view.len();let message_width = if view.is_8bit() { 8 } else { 16 };match moli_v8_util::decode_inspector_protocol_message(view) {- Ok(value) => self.push_value(value),+ Ok(mut value) => {+ self.remote_objects.complete_message(&mut value);+ self.push_value(value);+ }Err(error) => {let raw = moli_v8_util::inspector_protocol_message_text(view);tracing::warn!(target: "moli::cdp::inspector",@@ -180,7 +191,10 @@ impl InspectorOutbound {let message_units = view.len();let message_width = if view.is_8bit() { 8 } else { 16 };match moli_v8_util::decode_inspector_protocol_message(view) {- Ok(value) => self.push_response_value(call_id, value),+ Ok(mut value) => {+ self.remote_objects.complete_message(&mut value);+ self.push_response_value(call_id, value);+ }Err(error) => {let raw = moli_v8_util::inspector_protocol_message_text(view);tracing::warn!(target: "moli::cdp::inspector",diff --git a/moli-renderer-v8/src/script_vm/inspector/remote_objects.rs b/moli-renderer-v8/src/script_vm/inspector/remote_objects.rsnew file mode 100644index 000000000..0bef97e29--- /dev/null+++ b/moli-renderer-v8/src/script_vm/inspector/remote_objects.rs@@ -0,0 +1,157 @@+use moli_page_types::MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH;+use serde_json::Value;+use std::{+ cell::RefCell,+ rc::{Rc, Weak},+};++/// Completes embedder-owned `Runtime.RemoteObject` fields at the renderer's+/// native V8 Inspector boundary.+///+/// V8 knows how to classify its built-in objects, but the vendored Inspector+/// client binding does not expose Blink's `valueSubtype()` hook for Moli's DOM+/// wrappers. Resolve those wrappers synchronously while the Channel callback's+/// native handle scope is still alive. Once a message leaves this boundary it+/// is immutable protocol output; downstream routing must never query the Page+/// that produced it.+#[derive(Clone, Default)]+pub(super) struct InspectorRemoteObjectCompleter {+ session: Rc<RefCell<Weak<v8::inspector::V8InspectorSession>>>,+}++impl InspectorRemoteObjectCompleter {+ pub(super) fn bind_session(&self, session: &Rc<v8::inspector::V8InspectorSession>) {+ *self.session.borrow_mut() = Rc::downgrade(session);+ }++ pub(super) fn clear_session(&self) {+ *self.session.borrow_mut() = Weak::new();+ }++ pub(super) fn complete_message(&self, message: &mut Value) {+ let Some(session) = self.session.borrow().upgrade() else {+ return;+ };+ for (path, object_id) in unclassified_remote_objects(message) {+ if !inspector_object_is_node(&session, &object_id) {+ continue;+ }+ if let Some(remote_object) = message.pointer_mut(&path).and_then(Value::as_object_mut) {+ remote_object.insert("subtype".to_owned(), Value::String("node".to_owned()));+ }+ }+ }+}++fn unclassified_remote_objects(message: &Value) -> Vec<(String, String)> {+ let mut objects = Vec::new();+ let mut stack = vec![(message, String::new(), MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH)];+ while let Some((value, path, remaining_depth)) = stack.pop() {+ let Some(next_depth) = remaining_depth.checked_sub(1) else {+ continue;+ };+ match value {+ Value::Object(object) => {+ let is_unclassified_remote_object = object.get("subtype").is_none()+ && object.get("type").and_then(Value::as_str) == Some("object");+ if is_unclassified_remote_object+ && let Some(object_id) = object.get("objectId").and_then(Value::as_str)+ {+ objects.push((path.clone(), object_id.to_owned()));+ }+ for (key, child) in object.iter().rev() {+ let key = key.replace('~', "~0").replace('/', "~1");+ stack.push((child, format!("{path}/{key}"), next_depth));+ }+ }+ Value::Array(values) => {+ for index in (0..values.len()).rev() {+ stack.push((&values[index], format!("{path}/{index}"), next_depth));+ }+ }+ Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => {}+ }+ }+ objects+}++fn inspector_object_is_node(session: &v8::inspector::V8InspectorSession, object_id: &str) -> bool {+ // SAFETY: this helper is called only synchronously from the native Channel+ // callback. The Inspector handle scope that created `object_id` remains+ // active for the complete higher-ranked callback below.+ unsafe {+ session.with_unwrapped_object_in_current_handle_scope(+ v8::inspector::StringView::from(object_id.as_bytes()),+ |unwrapped| {+ let context = unwrapped.context;+ let value = unwrapped.value;+ v8::callback_scope!(unsafe let scope, context);+ let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {+ return false;+ };+ let object = v8::Local::new(scope, object);+ crate::native_bridge::object_is_node_wrapper_or_detached(scope, object)+ },+ )+ }+ .unwrap_or(false)+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn finds_only_unclassified_object_handles() {+ let message = json!({+ "result": {+ "result": {+ "type": "object",+ "objectId": "node-object"+ },+ "properties": [+ {+ "value": {+ "type": "function",+ "objectId": "function-object"+ }+ },+ {+ "value": {+ "type": "object",+ "subtype": "array",+ "objectId": "classified-object"+ }+ },+ {+ "value": {+ "type": "string",+ "objectId": "not-an-object"+ }+ }+ ]+ }+ });++ let mut objects = unclassified_remote_objects(&message);+ objects.sort();+ assert_eq!(+ objects,+ vec![("/result/result".to_owned(), "node-object".to_owned())]+ );+ }++ #[test]+ fn object_scan_respects_protocol_depth_cap() {+ let mut message = json!({+ "type": "object",+ "objectId": "too-deep"+ });+ for _ in 0..=MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH {+ message = json!({ "child": message });+ }++ assert!(unclassified_remote_objects(&message).is_empty());+ }+}diff --git a/vendor/v8-146.9.0/src/inspector.rs b/vendor/v8-146.9.0/src/inspector.rsindex 28c1f55b7..68b9bcac0 100644--- a/vendor/v8-146.9.0/src/inspector.rs+++ b/vendor/v8-146.9.0/src/inspector.rs@@ -697,6 +697,32 @@ impl V8InspectorSession {&self,_scope: &PinScope<'s, '_>,object_id: StringView,+ ) -> Result<UnwrappedObject<'s>, UniquePtr<StringBuffer>> {+ unsafe { self.unwrap_object_unchecked(object_id) }+ }++ /// Resolves an Inspector object while running synchronously inside a V8+ /// embedder callback that already has an active C++ handle scope.+ ///+ /// The higher-ranked callback prevents the returned local handles from+ /// escaping. The caller must still create a Rust `CallbackScope` from the+ /// returned context before inspecting either handle.+ ///+ /// # Safety+ ///+ /// This must only be called synchronously from a V8 embedder callback while+ /// the C++ handle scope that receives the resolved locals remains active.+ pub unsafe fn with_unwrapped_object_in_current_handle_scope<R>(+ &self,+ object_id: StringView,+ op: impl for<'s> FnOnce(UnwrappedObject<'s>) -> R,+ ) -> Result<R, UniquePtr<StringBuffer>> {+ unsafe { self.unwrap_object_unchecked(object_id) }.map(op)+ }++ unsafe fn unwrap_object_unchecked<'s>(+ &self,+ object_id: StringView,) -> Result<UnwrappedObject<'s>, UniquePtr<StringBuffer>> {let mut error = std::ptr::null_mut();let mut value = std::ptr::null();