Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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();
barriers
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index 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.pending
else {
return;
@@ -585,7 +570,6 @@ impl PendingRuntimeCommandDispatch {
routed_output,
renderer_response_rx: _,
claimed_await: _,
- page_owner_access_allowed: _,
} = &mut self.pending
else {
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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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();