Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(devtools): unify synchronous Page IO responses
ldm0a74431d2262c
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py b/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.pyindex 8795d6209..68a26966e 100644--- a/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py@@ -57,6 +57,12 @@ async def run_inspector_routing_group(client, page, fixture, results),),+ (+ "raw_cdp_mixed_io_agent_response_order",+ lambda client, page: _mixed_io_agent_response_order(+ client, page, results+ ),+ ),("raw_cdp_performance_io_during_active_javascript",lambda client, page: _performance_io_during_active_javascript(@@ -1480,6 +1486,133 @@ async def _performance_io_during_active_javascript()+async def _mixed_io_agent_response_order(+ client: RawCdpClient,+ page: InspectorRoutingPage,+ results: list[dict[str, Any]],+) -> None:+ source = "globalThis.__mixedIoAgentResponseOrder = 42;"+ compile_id = await client.send(+ "Runtime.compileScript",+ {+ "expression": source,+ "sourceURL": "inspector-routing-mixed-io.js",+ "persistScript": True,+ },+ session_id=page.auxiliary_session_id,+ )+ compile_response, _ = await client.recv_until_id(compile_id, timeout=5)+ script_id = compile_response.get("result", {}).get("scriptId")+ if not isinstance(script_id, str) or not script_id:+ raise SmokeError(+ f"Runtime.compileScript returned no mixed-IO scriptId: {compile_response}"+ )++ performance_enable_id = await client.send(+ "Performance.enable",+ session_id=page.auxiliary_session_id,+ )+ await client.recv_until_id(performance_enable_id, timeout=5)++ commands: list[tuple[int, str]] = []+ for _ in range(64):+ commands.append(+ (+ await client.send(+ "Performance.getMetrics",+ session_id=page.auxiliary_session_id,+ ),+ "Performance.getMetrics",+ )+ )+ commands.append(+ (+ await client.send(+ "Debugger.getScriptSource",+ {"scriptId": script_id},+ session_id=page.auxiliary_session_id,+ ),+ "Debugger.getScriptSource",+ )+ )+ commands.append(+ (+ await client.send(+ "Emulation.setScriptExecutionDisabled",+ {"value": False},+ session_id=page.auxiliary_session_id,+ ),+ "Emulation.setScriptExecutionDisabled",+ )+ )+ commands.append(+ (+ await client.send(+ "Debugger.getScriptSource",+ {"scriptId": script_id},+ session_id=page.auxiliary_session_id,+ ),+ "Debugger.getScriptSource",+ )+ )++ expected_order = [message_id for message_id, _method in commands]+ responses, seen = await _recv_responses(client, set(expected_order), timeout=10)+ response_order = [+ message["id"] for message in seen if message.get("id") in responses+ ]+ assert_equal(+ response_order,+ expected_order,+ "same-session synchronous mixed Page IO agent response order",+ )+ for message_id, method in commands:+ response = responses[message_id]+ if "error" in response:+ raise SmokeError(f"{method} failed in mixed Page IO burst: {response}")+ if method == "Debugger.getScriptSource":+ assert_equal(+ response.get("result", {}).get("scriptSource"),+ source,+ f"mixed Page IO script source for id {message_id}",+ )+ elif method == "Performance.getMetrics":+ metrics = response.get("result", {}).get("metrics")+ if not isinstance(metrics, list) or not metrics:+ raise SmokeError(+ f"Performance.getMetrics returned no metrics in mixed burst: {response}"+ )+ else:+ assert_equal(+ response.get("result"),+ {},+ f"mixed Page IO Emulation result for id {message_id}",+ )++ performance_disable_id = await client.send(+ "Performance.disable",+ session_id=page.auxiliary_session_id,+ )+ await client.recv_until_id(performance_disable_id, timeout=5)+ record_contract(+ results,+ "raw_cdp_mixed_io_agent_response_order",+ contract=(+ "Synchronous V8 Debugger and non-V8 Performance/Emulation commands share one "+ "Page IO ingress and one session output path, so their responses remain in "+ "producer order without serializing genuinely asynchronous Inspector replies."+ ),+ source="Chromium DevToolsSession mixed V8/non-V8 IO executable probe",+ commands=[+ "Performance.getMetrics",+ "Debugger.getScriptSource",+ "Emulation.setScriptExecutionDisabled",+ "Debugger.getScriptSource",+ ],+ observed={"iterations": 64, "responseCount": len(response_order)},+ )++async def _script_execution_disabled_io_during_active_javascript(client: RawCdpClient,page: InspectorRoutingPage,diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex 23639b962..584b2f351 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -856,6 +856,28 @@ impl Page {)}+ /// Publishes the terminal `Performance.getMetrics` response through the+ /// concrete renderer DevTools session that owns this Page attachment.+ pub fn start_performance_get_metrics_from_io_with_response(+ &self,+ inspector_session_id: Option<String>,+ result: Value,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<PendingDevToolsIoCommandDispatch> {+ let attachment = self+ .renderer_agent_attachment_id+ .ok_or_else(|| anyhow!("Performance IO response requires a renderer attachment"))?;+ let route = self+ .handle+ .enqueue_performance_get_metrics_io_command_with_response(+ attachment,+ inspector_session_id,+ result,+ response,+ );+ Ok(Self::pending_devtools_io_command_dispatch(route))+ }+pub fn cached_performance_metric_snapshot(&self) -> RendererPerformanceMetricSnapshot {self.page_state.performance_metric_snapshot().clone()}diff --git a/moli-core/src/page/settings_support.rs b/moli-core/src/page/settings_support.rsindex 4ef54e4e8..55df1010f 100644--- a/moli-core/src/page/settings_support.rs+++ b/moli-core/src/page/settings_support.rs@@ -10,6 +10,7 @@ use super::protocol_support::{use super::{CompletedPageCommand, Page, PendingDevToolsIoCommandDispatch, PendingPageCommand};use crate::renderer::{RendererPageCommand, RendererPageCookieFacadeSnapshotReply, RendererPageReply,+ RendererRuntimeInspectorResponseSender,};use moli_renderer_v8::network::BrowserResourceRuntime;@@ -251,6 +252,28 @@ impl Page {Self::pending_devtools_io_command_dispatch(route)}+ /// Publishes the terminal Emulation response through the concrete+ /// renderer DevTools session that owns this Page attachment.+ pub fn start_set_script_execution_disabled_from_io_with_response(+ &self,+ inspector_session_id: Option<String>,+ disabled: bool,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Result<PendingDevToolsIoCommandDispatch> {+ let attachment = self.renderer_agent_attachment_id.ok_or_else(|| {+ anyhow::anyhow!("Emulation IO response requires a renderer attachment")+ })?;+ let route = self+ .handle+ .enqueue_set_script_execution_disabled_io_command_with_response(+ attachment,+ inspector_session_id,+ disabled,+ response,+ );+ Ok(Self::pending_devtools_io_command_dispatch(route))+ }+pub async fn set_bypass_content_security_policy_async(&mut self, bypass: bool) -> Result<()> {self.dispatch_unit_page_command_async(RendererPageCommand::SetBypassContentSecurityPolicy(bypass),diff --git a/moli-protocol-cdp/src/wire.rs b/moli-protocol-cdp/src/wire.rsindex 75155a422..e22e23e06 100644--- a/moli-protocol-cdp/src/wire.rs+++ b/moli-protocol-cdp/src/wire.rs@@ -1,4 +1,3 @@-use moli_page_types::RendererInspectorResponseDelivery;use serde::{Deserialize, Serialize};use serde_json::{Map, Value};use std::{error::Error, fmt};@@ -232,7 +231,6 @@ pub struct CdpRendererCommandPolicy {inspector_task_mode: CdpInspectorTaskMode,renderer_replacement: CdpRendererCommandReplacement,renderer_replay_dispatch: CdpRendererCommandReplayDispatch,- response_delivery: RendererInspectorResponseDelivery,executes_page_javascript: bool,}@@ -253,10 +251,6 @@ impl CdpRendererCommandPolicy {self.renderer_replay_dispatch}- pub const fn response_delivery(self) -> RendererInspectorResponseDelivery {- self.response_delivery- }-pub const fn executes_page_javascript(self) -> bool {self.executes_page_javascript}@@ -578,7 +572,6 @@ impl CdpRendererCommandPolicy {inspector_task_mode: CdpInspectorTaskMode::for_method(method),renderer_replacement: CdpRendererCommandReplacement::Replay,renderer_replay_dispatch: CdpRendererCommandReplayDispatch::Direct,- response_delivery: RendererInspectorResponseDelivery::CommandReply,executes_page_javascript: false,};};@@ -654,21 +647,6 @@ impl CdpRendererCommandPolicy {} else {CdpRendererCommandReplayDispatch::Direct},- response_delivery: if domain == CdpMethodDomain::Debugger- && matches!(- action,- "getPossibleBreakpoints"- | "getScriptSource"- | "getStackTrace"- | "removeBreakpoint"- | "setBreakpoint"- | "setBreakpointByUrl"- | "setBreakpointsActive"- ) {- RendererInspectorResponseDelivery::DevToolsSession- } else {- RendererInspectorResponseDelivery::CommandReply- },executes_page_javascript: runtime_action.is_some_and(RuntimeWireAction::executes_page_javascript)|| debugger_action.is_some_and(DebuggerWireAction::executes_page_javascript),@@ -828,41 +806,6 @@ mod tests {);}- #[test]- fn synchronous_interruptible_frontend_v8_responses_use_session_output_as_one_family() {- for method in [- "Debugger.getPossibleBreakpoints",- "Debugger.getScriptSource",- "Debugger.getStackTrace",- "Debugger.removeBreakpoint",- "Debugger.setBreakpoint",- "Debugger.setBreakpointByUrl",- "Debugger.setBreakpointsActive",- ] {- assert_eq!(- parse(format!(r#"{{"id":18,"method":"{method}"}}"#))- .renderer_policy()- .response_delivery(),- RendererInspectorResponseDelivery::DevToolsSession,- "{method} must share the same session output path as adjacent synchronous V8 IO commands"- );- }- for method in [- "Debugger.enable",- "Debugger.pause",- "Debugger.resume",- "Runtime.getIsolateId",- ] {- assert_eq!(- parse(format!(r#"{{"id":19,"method":"{method}"}}"#))- .renderer_policy()- .response_delivery(),- RendererInspectorResponseDelivery::CommandReply,- "{method} still requires the command-reply completion path"- );- }- }-#[test]fn renderer_replacement_traits_are_computed_at_the_wire_boundary() {for method in [diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 06a928d04..deb2113bc 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -537,7 +537,7 @@ pub(crate) use state::{ParkedTargetOwnerState, PendingBidiChannelListener, PendingInspectorAwait,PendingRendererCommandKey, PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction,ProfilerInspectorCommand, RendererCommandCorrelation, RendererCommandDescriptor,- RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,+ RendererCommandReplay, RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,RendererMainDocumentCommitSeed, RendererPageResidenceIdentity,ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rsindex d03a90e49..faed0bfc2 100644--- a/moli-protocol/src/conn/runtime_eval.rs+++ b/moli-protocol/src/conn/runtime_eval.rs@@ -911,6 +911,19 @@ impl CdpConnection {.flatten()}+ pub(crate) fn take_renderer_call_if_correlation_matches_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ correlation: RendererCommandCorrelation,+ ) -> bool {+ self.take_renderer_call_for_frontend_if_matches_for_session_owner(+ session_id,+ correlation.frontend_command_id().get(),+ correlation.renderer_call_id(),+ correlation.dispatched_attachment_id(),+ ) == Some(correlation)+ }+fn take_frontend_command_for_renderer_if_attachment_matches_for_session_owner(&mut self,session_id: Option<&str>,@@ -4619,17 +4632,12 @@ impl CdpConnection {let frontend_session_id = replay.frontend_session_id().map(str::to_owned);let renderer_inspector_session_id =replay.renderer_inspector_session_id().map(str::to_owned);- let (correlation, dispatch, response_delivery, frontend_payload, response_sender) =+ let (correlation, replay, response_delivery, frontend_payload, response_sender) =replay.into_replay().into_parts();- let raw_json = match self.rewrite_runtime_inspector_command_for_session_owner(+ let route = match self.runtime_protocol_message_page_route_for_session_owner(frontend_session_id.as_deref(),- &frontend_payload,- Some((- correlation.frontend_command_id(),- correlation.renderer_call_id(),- )),) {- Ok(raw_json) => raw_json,+ Ok(route) => route,Err(error) => {self.settle_renderer_replay_error(&mut events,@@ -4642,10 +4650,122 @@ impl CdpConnection {continue;}};- let route = match self.runtime_protocol_message_page_route_for_session_owner(+ if route.renderer_agent_attachment_id != new_attachment_id {+ self.settle_renderer_replay_error(+ &mut events,+ frontend_session_id.as_deref(),+ response_delivery,+ &response_sender,+ correlation,+ "renderer replay attachment is no longer current",+ );+ continue;+ }+ let dispatch = match replay {+ RendererCommandReplay::Inspector(dispatch) => dispatch,+ RendererCommandReplay::PerformanceGetMetrics => {+ debug_assert_eq!(+ response_delivery,+ RendererInspectorResponseDelivery::DevToolsSession+ );+ let pending = self+ .runtime_session_owner_page_mut(frontend_session_id.as_deref())+ .map_err(|error| error.to_string())+ .and_then(|page| {+ let result = crate::domains::performance::performance_metrics_result(+ &page.cached_performance_metric_snapshot(),+ );+ page.start_performance_get_metrics_from_io_with_response(+ renderer_inspector_session_id.clone(),+ result,+ response_sender.clone(),+ )+ .map_err(|error| error.to_string())+ });+ let completion = match pending {+ Ok(pending) => pending.wait().await.map_err(|error| error.to_string()),+ Err(error) => Err(error),+ };+ match completion {+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Canceled) => {+ self.settle_renderer_replay_error(+ &mut events,+ frontend_session_id.as_deref(),+ response_delivery,+ &response_sender,+ correlation,+ "Inspected target navigated or closed",+ );+ }+ Err(error) => {+ self.settle_renderer_replay_error(+ &mut events,+ frontend_session_id.as_deref(),+ response_delivery,+ &response_sender,+ correlation,+ &format!("Performance replay dispatch failed: {error}"),+ );+ }+ }+ continue;+ }+ RendererCommandReplay::SetScriptExecutionDisabled { disabled } => {+ debug_assert_eq!(+ response_delivery,+ RendererInspectorResponseDelivery::DevToolsSession+ );+ let pending = self+ .runtime_session_owner_page_mut(frontend_session_id.as_deref())+ .map_err(|error| error.to_string())+ .and_then(|page| {+ page.start_set_script_execution_disabled_from_io_with_response(+ renderer_inspector_session_id.clone(),+ disabled,+ response_sender.clone(),+ )+ .map_err(|error| error.to_string())+ });+ let completion = match pending {+ Ok(pending) => pending.wait().await.map_err(|error| error.to_string()),+ Err(error) => Err(error),+ };+ match completion {+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Canceled) => {+ self.settle_renderer_replay_error(+ &mut events,+ frontend_session_id.as_deref(),+ response_delivery,+ &response_sender,+ correlation,+ "Inspected target navigated or closed",+ );+ }+ Err(error) => {+ self.settle_renderer_replay_error(+ &mut events,+ frontend_session_id.as_deref(),+ response_delivery,+ &response_sender,+ correlation,+ &format!("Emulation replay dispatch failed: {error}"),+ );+ }+ }+ continue;+ }+ };+ let raw_json = match self.rewrite_runtime_inspector_command_for_session_owner(frontend_session_id.as_deref(),+ &frontend_payload,+ Some((+ correlation.frontend_command_id(),+ correlation.renderer_call_id(),+ )),) {- Ok(route) => route,+ Ok(raw_json) => raw_json,Err(error) => {self.settle_renderer_replay_error(&mut events,@@ -4658,17 +4778,6 @@ impl CdpConnection {continue;}};- if route.renderer_agent_attachment_id != new_attachment_id {- self.settle_renderer_replay_error(- &mut events,- frontend_session_id.as_deref(),- response_delivery,- &response_sender,- correlation,- "renderer replay attachment is no longer current",- );- continue;- }let pending = {let page = match self.runtime_session_owner_page_mut(frontend_session_id.as_deref()){@@ -6034,6 +6143,7 @@ mod tests {RendererCommandDescriptor::from_frontend_policy(frontend.json().to_owned(),frontend.renderer_policy(),+ RendererInspectorResponseDelivery::DevToolsSession,),).expect("frontend response correlation should register");diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rsindex 2711f21b5..66e655b1b 100644--- a/moli-protocol/src/conn/state/mod.rs+++ b/moli-protocol/src/conn/state/mod.rs@@ -87,7 +87,7 @@ pub(crate) use javascript_dialog::{pub(crate) use pending_renderer_command::{DuplicatePendingRendererCommand, PendingRendererCommandKey, PreparedRendererCallDispatch,PreparedRendererCallTermination, RegisterRendererCallError, RendererCommandCorrelation,- RendererCommandDescriptor,+ RendererCommandDescriptor, RendererCommandReplay,};pub(crate) use profiler::{ProfilerAction, ProfilerInspectorCommand};pub(crate) use service_worker_lifetime::{diff --git a/moli-protocol/src/conn/state/pending_renderer_command.rs b/moli-protocol/src/conn/state/pending_renderer_command.rsindex 9b51cd780..cab42bd28 100644--- a/moli-protocol/src/conn/state/pending_renderer_command.rs+++ b/moli-protocol/src/conn/state/pending_renderer_command.rs@@ -22,22 +22,55 @@ use serde_json::Value;#[derive(Clone, Debug, Eq, PartialEq)]pub(crate) struct RendererCommandDescriptor {replacement: CdpRendererCommandReplacement,- replay_dispatch: CdpRendererCommandReplayDispatch,+ replay: RendererCommandReplay,response_delivery: RendererInspectorResponseDelivery,frontend_payload: String,}+#[derive(Clone, Debug, Eq, PartialEq)]+pub(crate) enum RendererCommandReplay {+ Inspector(CdpRendererCommandReplayDispatch),+ PerformanceGetMetrics,+ SetScriptExecutionDisabled { disabled: bool },+}+impl RendererCommandDescriptor {/// Builds a replay descriptor from the policy already derived at typed CDP/// ingress. Production frontend commands must use this constructor.pub(crate) fn from_frontend_policy(frontend_payload: String,policy: CdpRendererCommandPolicy,+ response_delivery: RendererInspectorResponseDelivery,) -> Self {Self {replacement: policy.replacement(),- replay_dispatch: policy.replay_dispatch(),- response_delivery: policy.response_delivery(),+ replay: RendererCommandReplay::Inspector(policy.replay_dispatch()),+ response_delivery,+ frontend_payload,+ }+ }++ pub(crate) fn performance_get_metrics(+ frontend_payload: String,+ policy: CdpRendererCommandPolicy,+ ) -> Self {+ Self {+ replacement: policy.replacement(),+ replay: RendererCommandReplay::PerformanceGetMetrics,+ response_delivery: RendererInspectorResponseDelivery::DevToolsSession,+ frontend_payload,+ }+ }++ pub(crate) fn set_script_execution_disabled(+ frontend_payload: String,+ policy: CdpRendererCommandPolicy,+ disabled: bool,+ ) -> Self {+ Self {+ replacement: policy.replacement(),+ replay: RendererCommandReplay::SetScriptExecutionDisabled { disabled },+ response_delivery: RendererInspectorResponseDelivery::DevToolsSession,frontend_payload,}}@@ -53,7 +86,7 @@ impl RendererCommandDescriptor {let policy = command.renderer_policy();Ok(Self {replacement: policy.replacement(),- replay_dispatch: policy.replay_dispatch(),+ replay: RendererCommandReplay::Inspector(policy.replay_dispatch()),// Internal Classic/BiDi adapters own their reply channel. A// method being eligible for frontend session output must never// redirect a synthesized adapter command implicitly.@@ -66,8 +99,8 @@ impl RendererCommandDescriptor {self.replacement}- pub(crate) const fn replay_dispatch(&self) -> CdpRendererCommandReplayDispatch {- self.replay_dispatch+ pub(crate) fn replay(&self) -> &RendererCommandReplay {+ &self.replay}pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {@@ -193,7 +226,7 @@ impl PreparedRendererCallDispatch {#[derive(Debug)]pub(crate) struct PreparedRendererCallReplay {correlation: RendererCommandCorrelation,- dispatch: CdpRendererCommandReplayDispatch,+ replay: RendererCommandReplay,response_delivery: RendererInspectorResponseDelivery,frontend_payload: String,response_sender: RendererRuntimeInspectorResponseSender,@@ -240,14 +273,14 @@ impl PreparedRendererCallReplay {self,) -> (RendererCommandCorrelation,- CdpRendererCommandReplayDispatch,+ RendererCommandReplay,RendererInspectorResponseDelivery,String,RendererRuntimeInspectorResponseSender,) {(self.correlation,- self.dispatch,+ self.replay,self.response_delivery,self.frontend_payload,self.response_sender,@@ -398,7 +431,7 @@ impl<T> PendingRendererCommandRegistry<T> {renderer_call_id,dispatched_attachment_id: Some(new_attachment_id),},- dispatch: call.descriptor.replay_dispatch(),+ replay: call.descriptor.replay().clone(),response_delivery: call.descriptor.response_delivery(),frontend_payload: call.descriptor.frontend_payload().to_owned(),response_sender,@@ -817,15 +850,17 @@ mod tests {CdpRendererCommandReplacement::Replay);assert_eq!(- registered.replay_dispatch(),- CdpRendererCommandReplayDispatch::Direct+ registered.replay(),+ &RendererCommandReplay::Inspector(CdpRendererCommandReplayDispatch::Direct));assert_eq!(registered.frontend_payload(), expected_payload);let add_binding = descriptor(32, "Runtime.addBinding");assert_eq!(- add_binding.replay_dispatch(),- CdpRendererCommandReplayDispatch::ResolveRuntimeContext+ add_binding.replay(),+ &RendererCommandReplay::Inspector(+ CdpRendererCommandReplayDispatch::ResolveRuntimeContext+ ));}@@ -841,34 +876,48 @@ mod tests {let descriptor = RendererCommandDescriptor::from_frontend_policy(normalized_payload.clone(),ingress.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,);assert_eq!(descriptor.frontend_payload(), normalized_payload);assert_eq!(- descriptor.replay_dispatch(),- CdpRendererCommandReplayDispatch::ResolveRuntimeContext,+ descriptor.replay(),+ &RendererCommandReplay::Inspector(+ CdpRendererCommandReplayDispatch::ResolveRuntimeContext+ ),"descriptor construction must consume the ingress policy instead of deriving it from the normalized payload");}#[test]- fn synthesized_adapter_command_keeps_its_explicit_reply_sink() {+ fn concrete_target_capability_selects_the_response_sink() {let frontend = ParsedCdpCommand::parse_str(r#"{"id":33,"method":"Debugger.getScriptSource","params":{"scriptId":"1"}}"#,).expect("frontend command must parse at ingress");- let frontend_descriptor = RendererCommandDescriptor::from_frontend_policy(+ let page_descriptor = RendererCommandDescriptor::from_frontend_policy(+ frontend.json().to_owned(),+ frontend.renderer_policy(),+ RendererInspectorResponseDelivery::DevToolsSession,+ );+ let worker_descriptor = RendererCommandDescriptor::from_frontend_policy(frontend.json().to_owned(),frontend.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,);let adapter_descriptor =RendererCommandDescriptor::from_synthesized_payload(frontend.json().to_owned()).expect("adapter payload must be valid Inspector JSON");assert_eq!(- frontend_descriptor.response_delivery(),+ page_descriptor.response_delivery(),RendererInspectorResponseDelivery::DevToolsSession);+ assert_eq!(+ worker_descriptor.response_delivery(),+ RendererInspectorResponseDelivery::CommandReply,+ "the method catalog must not choose a Page-only output capability for Workers"+ );assert_eq!(adapter_descriptor.response_delivery(),RendererInspectorResponseDelivery::CommandReply,@@ -876,6 +925,44 @@ mod tests {);}+ #[test]+ fn non_v8_page_io_descriptors_keep_typed_replay_operations() {+ let performance = ParsedCdpCommand::parse_str(+ r#"{"id":34,"method":"Performance.getMetrics","params":{}}"#,+ )+ .expect("Performance command must parse at ingress");+ let performance_descriptor = RendererCommandDescriptor::performance_get_metrics(+ performance.json().to_owned(),+ performance.renderer_policy(),+ );+ assert_eq!(+ performance_descriptor.replay(),+ &RendererCommandReplay::PerformanceGetMetrics+ );+ assert_eq!(+ performance_descriptor.response_delivery(),+ RendererInspectorResponseDelivery::DevToolsSession+ );++ let emulation = ParsedCdpCommand::parse_str(+ r#"{"id":35,"method":"Emulation.setScriptExecutionDisabled","params":{"value":true}}"#,+ )+ .expect("Emulation command must parse at ingress");+ let emulation_descriptor = RendererCommandDescriptor::set_script_execution_disabled(+ emulation.json().to_owned(),+ emulation.renderer_policy(),+ true,+ );+ assert_eq!(+ emulation_descriptor.replay(),+ &RendererCommandReplay::SetScriptExecutionDisabled { disabled: true }+ );+ assert_eq!(+ emulation_descriptor.response_delivery(),+ RendererInspectorResponseDelivery::DevToolsSession+ );+ }+#[tokio::test]async fn replay_rotates_renderer_id_attachment_and_response_lease() {let frontend_id = FrontendCommandId::new(41);@@ -898,6 +985,7 @@ mod tests {RendererCommandDescriptor::from_frontend_policy(frontend.json().to_owned(),frontend.renderer_policy(),+ RendererInspectorResponseDelivery::DevToolsSession,),).unwrap();diff --git a/moli-protocol/src/domains/debugger.rs b/moli-protocol/src/domains/debugger.rsindex b18dc3adc..f601da785 100644--- a/moli-protocol/src/domains/debugger.rs+++ b/moli-protocol/src/domains/debugger.rs@@ -249,9 +249,11 @@ mod tests {.await;assert_eq!(timer["result"]["result"]["value"], json!(true));+ let response_start = ctx.sent.len();let scheduler_events = ctx.process_command_only_async(json!({"id": 22, "method": "Debugger.pause"})).await;+ ctx.wait_for_test_command_response(22, response_start).await;let pause_position = ctx.sent.iter()diff --git a/moli-protocol/src/domains/dom_debugger.rs b/moli-protocol/src/domains/dom_debugger.rsindex 067821ecf..bc8abdc61 100644--- a/moli-protocol/src/domains/dom_debugger.rs+++ b/moli-protocol/src/domains/dom_debugger.rs@@ -427,6 +427,9 @@ mod tests {let mut messages = Vec::new();for resume in resumes {+ let resume_id = resume["id"]+ .as_u64()+ .expect("Debugger.resume test command must have a numeric id");let resume_session_id = resume.get("sessionId").cloned();let paused = ctx.wait_for_scheduler_message("pause preceding Debugger.resume", |message| {@@ -439,6 +442,7 @@ mod tests {.await;messages.push(paused);+ let response_start = ctx.sent.len();let resume_step = ctx.conn.start_command_dispatch(&resume.to_string());let (mut resume_messages, scheduler_events) = tokio::time::timeout(DOM_DEBUGGER_COMMAND_TIMEOUT,@@ -447,6 +451,14 @@ mod tests {.await.expect("Debugger.resume should complete after its matching pause");assert!(scheduler_events.is_empty(), "{scheduler_events:?}");+ if !resume_messages+ .iter()+ .any(|message| message["id"] == json!(resume_id))+ {+ ctx.wait_for_test_command_response(resume_id, response_start)+ .await;+ resume_messages.push(ctx.take_response_by_id(resume_id));+ }messages.append(&mut resume_messages);}diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rsindex 78cf7c3fa..a98615dd3 100644--- a/moli-protocol/src/domains/emulation.rs+++ b/moli-protocol/src/domains/emulation.rs@@ -1,7 +1,7 @@use crate::conn::{BrowserContext, CdpConnection, CdpSessionRoute, Cmd, CommandOwnerScope, EmulatedDeviceMetrics,- EmulatedGeolocationOverrideState, EmulatedViewportSurface,- RuntimeInspectorAsyncCompletionReceiver, TargetWindowSurfaceState,+ EmulatedGeolocationOverrideState, EmulatedViewportSurface, RendererCommandCorrelation,+ RendererCommandDescriptor, RuntimeInspectorAsyncCompletionReceiver, TargetWindowSurfaceState,};use crate::devtools_runtime::{DevToolsCommand, DevToolsCommandResult, DevToolsDevicePixelRatioSetting, DevToolsError,@@ -45,12 +45,20 @@ pub(crate) struct CompletedEmulationCommandDispatch {enum PendingEmulationRendererDispatch {Pages(Vec<PendingEmulationPageCommand>),- Io(PendingDevToolsIoCommandDispatch),+ IoCommandReply(PendingDevToolsIoCommandDispatch),+ IoSessionOutput {+ pending: PendingDevToolsIoCommandDispatch,+ correlation: RendererCommandCorrelation,+ },}enum CompletedEmulationRendererDispatch {Pages(Vec<CompletedEmulationPageCommand>),- Io(Result<CompletedDevToolsIoCommandDispatch, String>),+ IoCommandReply(Result<CompletedDevToolsIoCommandDispatch, String>),+ IoSessionOutput {+ completed: Result<CompletedDevToolsIoCommandDispatch, String>,+ correlation: RendererCommandCorrelation,+ },}struct PendingEmulationPageCommand {@@ -125,11 +133,18 @@ impl PendingEmulationCommandDispatch {}CompletedEmulationRendererDispatch::Pages(completed)}- PendingEmulationRendererDispatch::Io(pending) => {- CompletedEmulationRendererDispatch::Io(+ PendingEmulationRendererDispatch::IoCommandReply(pending) => {+ CompletedEmulationRendererDispatch::IoCommandReply(pending.wait().await.map_err(|error| error.to_string()),)}+ PendingEmulationRendererDispatch::IoSessionOutput {+ pending,+ correlation,+ } => CompletedEmulationRendererDispatch::IoSessionOutput {+ completed: pending.wait().await.map_err(|error| error.to_string()),+ correlation,+ },};CompletedEmulationCommandDispatch {command_id: self.command_id,@@ -345,14 +360,70 @@ fn start_script_execution_disabled_command("BrowserContextNotLoaded",));}- let Some(page) = loaded_page_mut_for_session(conn, cmd.session_id) else {+ let Some(attachment_id) = loaded_page_mut_for_session(conn, cmd.session_id)+ .and_then(|page| page.renderer_agent_attachment_id())+ else {return EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})));};- let pending = page.start_set_script_execution_disabled_from_io(params.value);+ let renderer_inspector_session_id =+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);+ let Some(command_id) = cmd.id else {+ let page = loaded_page_mut_for_session(conn, cmd.session_id)+ .expect("the captured Emulation Page must remain loaded synchronously");+ let pending = page.start_set_script_execution_disabled_from_io(params.value);+ return EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {+ command_id: cmd.id,+ session_id: cmd.session_id.map(str::to_owned),+ pending: PendingEmulationRendererDispatch::IoCommandReply(pending),+ });+ };+ let descriptor = RendererCommandDescriptor::set_script_execution_disabled(+ cmd.json.to_owned(),+ cmd.renderer_policy(),+ params.value,+ );+ let prepared = match conn.try_register_renderer_call_for_session_owner(+ cmd.session_id,+ command_id,+ Some(attachment_id),+ descriptor,+ ) {+ Ok(prepared) => prepared,+ Err(error) => {+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error));+ }+ };+ let (correlation, response, response_rx) = prepared.into_parts();+ drop(response_rx);+ let pending = loaded_page_mut_for_session(conn, cmd.session_id)+ .filter(|page| page.renderer_agent_attachment_id() == Some(attachment_id))+ .ok_or_else(|| "Emulation renderer attachment changed before IO dispatch".to_owned())+ .and_then(|page| {+ page.start_set_script_execution_disabled_from_io_with_response(+ renderer_inspector_session_id,+ params.value,+ response,+ )+ .map_err(|error| error.to_string())+ });+ let pending = match pending {+ Ok(pending) => pending,+ Err(error) => {+ let removed = conn.take_renderer_call_if_correlation_matches_for_session_owner(+ cmd.session_id,+ correlation,+ );+ debug_assert!(removed);+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error));+ }+ };EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: cmd.session_id.map(str::to_owned),- pending: PendingEmulationRendererDispatch::Io(pending),+ pending: PendingEmulationRendererDispatch::IoSessionOutput {+ pending,+ correlation,+ },})}@@ -2368,9 +2439,10 @@ pub(crate) fn complete_pending_emulation_command(conn: &mut CdpConnection,completed: CompletedEmulationCommandDispatch,) -> CommandOutputPlan {+ let session_id = completed.session_id.clone();let completed_pages = match completed.completed {CompletedEmulationRendererDispatch::Pages(completed_pages) => completed_pages,- CompletedEmulationRendererDispatch::Io(completed) => {+ CompletedEmulationRendererDispatch::IoCommandReply(completed) => {return match completed {Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {CommandOutputPlan::result(json!({}))@@ -2381,6 +2453,28 @@ pub(crate) fn complete_pending_emulation_command(Err(error) => CommandOutputPlan::error(-32000, error),};}+ CompletedEmulationRendererDispatch::IoSessionOutput {+ completed: Ok(CompletedDevToolsIoCommandDispatch::Dispatched),+ ..+ } => return CommandOutputPlan::default(),+ CompletedEmulationRendererDispatch::IoSessionOutput {+ completed,+ correlation,+ } => {+ if !conn.take_renderer_call_if_correlation_matches_for_session_owner(+ session_id.as_deref(),+ correlation,+ ) {+ return CommandOutputPlan::default();+ }+ return match completed {+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {+ CommandOutputPlan::error(-32000, "Emulation IO command was canceled")+ }+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => unreachable!(),+ Err(error) => CommandOutputPlan::error(-32000, error),+ };+ }};for completed_page in completed_pages {let completion = match completed_page.completed {diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rsindex 473cbb6da..59171b8c2 100644--- a/moli-protocol/src/domains/emulation/tests.rs+++ b/moli-protocol/src/domains/emulation/tests.rs@@ -194,11 +194,17 @@ async fn script_execution_disabled_completes_through_io_pending_dispatch() {"params": { "value": true }}).to_string();+ let response_start = ctx.sent.len();let pending = ctx.conn.try_start_pending_command_dispatch(&raw).expect("the script execution override should use IO pending dispatch");- let messages = complete_pending_command_task_for_test(&mut ctx, pending).await;+ let mut messages = complete_pending_command_task_for_test(&mut ctx, pending).await;+ if !messages.iter().any(|message| message["id"] == json!(9101)) {+ ctx.wait_for_test_command_response(9101, response_start)+ .await;+ messages.push(ctx.take_response_by_id(9101));+ }assert!(messages.iter().any(|message| {message["id"] == json!(9101)@@ -214,6 +220,40 @@ async fn script_execution_disabled_completes_through_io_pending_dispatch() {);}+#[tokio::test(flavor = "multi_thread")]+async fn auxiliary_session_first_io_emulation_response_uses_its_session_host() {+ let mut ctx = TestContext::new();+ load_session_page_for_pending_emulation_test(&mut ctx).await;+ assert!(+ ctx.conn+ .browser_context+ .as_mut()+ .expect("browser context")+ .assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned())+ );+ ctx.conn+ .apply_runtime_binding_state_for_session_owner_async(Some("SID-aux"))+ .await+ .expect("target attachment should establish the auxiliary renderer session");++ ctx.process_async(json!({+ "id": 9_111,+ "sessionId": "SID-aux",+ "method": "Emulation.setScriptExecutionDisabled",+ "params": { "value": true }+ }))+ .await;++ ctx.expect_result(9_111, json!({}), Some("SID-aux"));+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .script_execution_disabled+ );+}+#[tokio::test(flavor = "multi_thread")]async fn timezone_override_can_complete_through_pending_command_dispatch() {let mut ctx = TestContext::new();diff --git a/moli-protocol/src/domains/performance.rs b/moli-protocol/src/domains/performance.rsindex e01f2c978..d4cc960c4 100644--- a/moli-protocol/src/domains/performance.rs+++ b/moli-protocol/src/domains/performance.rs@@ -1,6 +1,6 @@use crate::conn::{CdpConnection, CdpRendererCommandAccess, Cmd, CommandOwnerScope, PerformanceTimeDomain,- monotonic_timestamp_seconds,+ RendererCommandCorrelation, RendererCommandDescriptor, monotonic_timestamp_seconds,};use crate::domains::actions::PerformanceAction;use crate::domains::command_output::CommandOutputPlan;@@ -41,15 +41,23 @@ pub(crate) struct CompletedPerformanceCommandDispatch {enum PendingPerformanceRendererCommand {Main(PendingPageCommand),- Io {+ IoCommandReply {pending: PendingDevToolsIoCommandDispatch,snapshot: RendererPerformanceMetricSnapshot,},+ IoSessionOutput {+ pending: PendingDevToolsIoCommandDispatch,+ correlation: RendererCommandCorrelation,+ },}enum CompletedPerformanceRendererCommand {Main(CompletedPageCommand),- Io(RendererPerformanceMetricSnapshot),+ IoCommandReply(RendererPerformanceMetricSnapshot),+ IoSessionOutput {+ completed: Result<CompletedDevToolsIoCommandDispatch, String>,+ correlation: RendererCommandCorrelation,+ },}pub(crate) enum PerformanceCommandTaskStep {@@ -68,17 +76,24 @@ impl PendingPerformanceCommandDispatch {.wait().await.map(CompletedPerformanceRendererCommand::Main),- PendingPerformanceRendererCommand::Io { pending, snapshot } => {+ PendingPerformanceRendererCommand::IoCommandReply { pending, snapshot } => {match pending.wait().await {- Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {- Ok(CompletedPerformanceRendererCommand::Io(snapshot))- }+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => Ok(+ CompletedPerformanceRendererCommand::IoCommandReply(snapshot),+ ),Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {Err(anyhow::anyhow!("Performance IO command was canceled"))}Err(error) => Err(error),}}+ PendingPerformanceRendererCommand::IoSessionOutput {+ pending,+ correlation,+ } => Ok(CompletedPerformanceRendererCommand::IoSessionOutput {+ completed: pending.wait().await.map_err(|error| error.to_string()),+ correlation,+ }),};CompletedPerformanceCommandDispatch {command_id: self.command_id,@@ -222,23 +237,108 @@ pub(crate) fn try_start_performance_command_dispatch(return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());}let owner_scope = CommandOwnerScope::capture(conn, cmd.session_id);- let page = match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {- Ok(page) => page,- Err(_) => {- return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());- }- };if renderer_access == CdpRendererCommandAccess::Io {- let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);- let (pending, snapshot) = page.start_performance_metric_snapshot_from_io();+ let (renderer_page, attachment_id, snapshot) = {+ let page =+ match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {+ Ok(page) => page,+ Err(_) => {+ return PerformanceCommandTaskStep::Complete(+ default_metrics_command_output_plan(),+ );+ }+ };+ (+ crate::conn::RendererPageResidenceIdentity::from_page(page),+ page.renderer_agent_attachment_id(),+ page.cached_performance_metric_snapshot(),+ )+ };+ let Some(command_id) = cmd.id else {+ let page = loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access)+ .expect("the captured Performance Page must remain loaded synchronously");+ let (pending, snapshot) = page.start_performance_metric_snapshot_from_io();+ return PerformanceCommandTaskStep::Pending(PendingPerformanceCommandDispatch {+ command_id: cmd.id,+ owner_scope,+ renderer_access,+ renderer_page,+ pending: Box::new(PendingPerformanceRendererCommand::IoCommandReply {+ pending,+ snapshot,+ }),+ });+ };+ let Some(attachment_id) = attachment_id else {+ return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());+ };+ let renderer_inspector_session_id =+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);+ let result = performance_metrics_result(&snapshot);+ let descriptor = RendererCommandDescriptor::performance_get_metrics(+ cmd.json.to_owned(),+ cmd.renderer_policy(),+ );+ let prepared = match conn.try_register_renderer_call_for_session_owner(+ cmd.session_id,+ command_id,+ Some(attachment_id),+ descriptor,+ ) {+ Ok(prepared) => prepared,+ Err(error) => {+ return PerformanceCommandTaskStep::Complete(CommandOutputPlan::error(+ -32000, error,+ ));+ }+ };+ let (correlation, response, response_rx) = prepared.into_parts();+ drop(response_rx);+ let pending = loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access)+ .ok()+ .filter(|page| {+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page+ && page.renderer_agent_attachment_id() == Some(attachment_id)+ })+ .ok_or_else(|| "Performance renderer attachment changed before IO dispatch".to_owned())+ .and_then(|page| {+ page.start_performance_get_metrics_from_io_with_response(+ renderer_inspector_session_id,+ result,+ response,+ )+ .map_err(|error| error.to_string())+ });+ let pending = match pending {+ Ok(pending) => pending,+ Err(error) => {+ let removed = conn.take_renderer_call_if_correlation_matches_for_session_owner(+ cmd.session_id,+ correlation,+ );+ debug_assert!(removed);+ return PerformanceCommandTaskStep::Complete(CommandOutputPlan::error(+ -32000, error,+ ));+ }+ };return PerformanceCommandTaskStep::Pending(PendingPerformanceCommandDispatch {command_id: cmd.id,owner_scope,renderer_access,renderer_page,- pending: Box::new(PendingPerformanceRendererCommand::Io { pending, snapshot }),+ pending: Box::new(PendingPerformanceRendererCommand::IoSessionOutput {+ pending,+ correlation,+ }),});}+ let page = match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {+ Ok(page) => page,+ Err(_) => {+ return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());+ }+ };let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);let pending = match page.start_performance_metric_snapshot() {Ok(pending) => pending,@@ -266,7 +366,11 @@ fn default_metrics_command_output_plan() -> CommandOutputPlan {fn performance_metrics_command_output_plan(snapshot: &RendererPerformanceMetricSnapshot,) -> CommandOutputPlan {- CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(snapshot) }))+ CommandOutputPlan::result(performance_metrics_result(snapshot))+}++pub(crate) fn performance_metrics_result(snapshot: &RendererPerformanceMetricSnapshot) -> Value {+ json!({ "metrics": build_performance_metrics(snapshot) })}pub(crate) async fn complete_pending_performance_command(@@ -296,7 +400,7 @@ pub(crate) async fn complete_pending_performance_command(.and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok()).unwrap_or_default()}- Ok(CompletedPerformanceRendererCommand::Io(snapshot)) => {+ Ok(CompletedPerformanceRendererCommand::IoCommandReply(snapshot)) => {let remains_current = loaded_page_mut_for_renderer_access(owner_scope.conn_mut(),session_id.as_deref(),@@ -312,6 +416,27 @@ pub(crate) async fn complete_pending_performance_command(RendererPerformanceMetricSnapshot::default()}}+ Ok(CompletedPerformanceRendererCommand::IoSessionOutput {+ completed,+ correlation,+ }) => {+ if matches!(+ completed,+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched)+ ) {+ return CommandOutputPlan::default();+ }+ if !owner_scope+ .conn_mut()+ .take_renderer_call_if_correlation_matches_for_session_owner(+ session_id.as_deref(),+ correlation,+ )+ {+ return CommandOutputPlan::default();+ }+ RendererPerformanceMetricSnapshot::default()+ }Err(_) => RendererPerformanceMetricSnapshot::default(),};CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(&snapshot) }))@@ -393,7 +518,7 @@ fn build_performance_metrics(snapshot: &RendererPerformanceMetricSnapshot) -> Ve#[cfg(test)]mod tests {use super::*;- use crate::conn::{BackgroundTarget, BrowserContext, CdpCommandTaskStep};+ use crate::conn::{BrowserContext, CdpCommandTaskStep};use crate::testing::TestContext;use serde_json::json;use std::collections::HashMap;@@ -553,16 +678,12 @@ mod tests {bc.set_target_url("data:text/html,performance-test".to_owned());bc.set_active_target_id("TID-1".to_owned());bc.attach_active_session("SID-1".to_owned());- let page = ctx- .conn- .load_page_via_runtime_async(&format!("data:text/html,{html}"))- .await- .expect("test page should load");- let _ = bc- .active_target- .runtime_slot- .replace_loaded_page(Some(page));ctx.conn.browser_context = Some(bc);+ ctx.install_navigation_fixture_for_session_owner(+ &format!("data:text/html,{html}"),+ Some("SID-1"),+ )+ .await;}fn metric_map(response: &Value) -> HashMap<String, f64> {@@ -582,7 +703,9 @@ mod tests {async fn complete_command_task_step_for_test(ctx: &mut TestContext,step: CdpCommandTaskStep,+ command_id: u64,) -> Vec<Value> {+ let response_start = ctx.sent.len();let mut step = step;loop {match step {@@ -590,7 +713,18 @@ mod tests {let completed = pending.wait().await;step = ctx.conn.complete_pending_command_dispatch(completed).await;}- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,+ CdpCommandTaskStep::Complete(outcome) => {+ let mut messages = outcome.into_parts().0;+ if !messages+ .iter()+ .any(|message| message["id"] == json!(command_id))+ {+ ctx.wait_for_test_command_response(command_id, response_start)+ .await;+ messages.push(ctx.take_response_by_id(command_id));+ }+ return messages;+ }}}}@@ -695,6 +829,10 @@ mod tests {.expect("browser context").assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned()));+ ctx.conn+ .apply_runtime_binding_state_for_session_owner_async(Some("SID-aux"))+ .await+ .expect("target attachment should establish the auxiliary renderer session");ctx.process_async(json!({"id": 4_100,@@ -777,7 +915,7 @@ mod tests {}).to_string();let step = ctx.conn.start_command_dispatch(&raw);- let mut messages = complete_command_task_step_for_test(&mut ctx, step).await;+ let mut messages = complete_command_task_step_for_test(&mut ctx, step, 4_001).await;let response = messages.iter()@@ -814,7 +952,7 @@ mod tests {}).to_string();let step = ctx.conn.start_command_dispatch(&raw);- let old_messages = complete_command_task_step_for_test(&mut ctx, step).await;+ let old_messages = complete_command_task_step_for_test(&mut ctx, step, 4_011).await;let old_response = old_messages.iter().find(|message| message["id"] == json!(4_011))@@ -823,22 +961,11 @@ mod tests {assert!(old_metrics["Documents"] >= 1.0);assert!(old_metrics["Nodes"] >= 6.0);- let replacement = ctx- .conn- .load_page_via_runtime_async(- "data:text/html,<!doctype html><body><article>replacement</article></body>",- )- .await- .expect("replacement performance page should load");- let previous = ctx- .conn- .browser_context- .as_mut()- .expect("browser context")- .active_target- .runtime_slot- .replace_loaded_page(Some(replacement));- drop(previous);+ ctx.install_navigation_fixture_for_session_owner(+ "data:text/html,<!doctype html><body><article>replacement</article></body>",+ Some("SID-1"),+ )+ .await;let replacement_raw = json!({"id": 4_012,@@ -847,7 +974,7 @@ mod tests {}).to_string();let step = ctx.conn.start_command_dispatch(&replacement_raw);- let replacement_messages = complete_command_task_step_for_test(&mut ctx, step).await;+ let replacement_messages = complete_command_task_step_for_test(&mut ctx, step, 4_012).await;let replacement_response = replacement_messages.iter().find(|message| message["id"] == json!(4_012))@@ -860,26 +987,21 @@ mod tests {#[tokio::test(flavor = "multi_thread")]async fn performance_get_metrics_targets_loaded_background_owner_without_promotion() {let mut ctx = TestContext::new();- let page = ctx- .conn- .load_page_via_runtime_async(- "data:text/html,<!doctype html><body><main><section></section><section></section></main></body>",- )- .await- .expect("background performance page should load");- let mut background = BackgroundTarget::with_url(- "TID-background".to_owned(),- Some("SID-background".to_owned()),- page.final_url().as_str().to_owned(),- );- background.replace_loaded_page(Some(page));-+ let background_url = "data:text/html,<!doctype html><body><main><section></section><section></section></main></body>";let mut bc = BrowserContext::new("BID-1".into());bc.set_active_target_id("TID-active".to_owned());bc.attach_active_session("SID-active".to_owned());bc.set_target_url("data:text/html,<body>active</body>".to_owned());- bc.background_targets.push(background);+ bc.stage_background_target(+ "TID-background".to_owned(),+ Some("SID-background".to_owned()),+ background_url.to_owned(),+ None,+ None,+ );ctx.conn.browser_context = Some(bc);+ ctx.install_navigation_fixture_for_session_owner(background_url, Some("SID-background"))+ .await;ctx.process_async(json!({"id": 5,diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rsindex 2933c10a9..36d439720 100644--- a/moli-protocol/src/domains/runtime/dispatcher.rs+++ b/moli-protocol/src/domains/runtime/dispatcher.rs@@ -1871,8 +1871,11 @@ fn start_pending_runtime_io_inspector_dispatch(inspector_json: String,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {- let descriptor =- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());+ let descriptor = RendererCommandDescriptor::from_frontend_policy(+ inspector_json,+ cmd.renderer_policy(),+ RendererInspectorResponseDelivery::DevToolsSession,+ );conn.start_runtime_io_protocol_message_for_session_owner_with_deferred_response(cmd.session_id,descriptor,@@ -1890,8 +1893,11 @@ fn start_pending_runtime_context_resolved_inspector_dispatch(inspector_json: String,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {- let descriptor =- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());+ let descriptor = RendererCommandDescriptor::from_frontend_policy(+ inspector_json,+ cmd.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,+ );conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response(cmd.session_id,action,@@ -1913,8 +1919,11 @@ fn start_pending_runtime_inspector_dispatch(inspector_json: String,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {- let descriptor =- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());+ let descriptor = RendererCommandDescriptor::from_frontend_policy(+ inspector_json,+ cmd.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,+ );conn.start_runtime_protocol_message_for_session_owner_with_deferred_response(cmd.session_id,descriptor,@@ -1931,8 +1940,11 @@ fn start_shared_worker_frontend_inspector_dispatch(inspector_json: String,) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {- let descriptor =- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());+ let descriptor = RendererCommandDescriptor::from_frontend_policy(+ inspector_json,+ cmd.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,+ );conn.start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(cmd.session_id,descriptor,@@ -1952,8 +1964,11 @@ fn start_service_worker_frontend_inspector_dispatch(inspector_json: String,) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {if let Some(command_id) = cmd.id {- let descriptor =- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());+ let descriptor = RendererCommandDescriptor::from_frontend_policy(+ inspector_json,+ cmd.renderer_policy(),+ RendererInspectorResponseDelivery::CommandReply,+ );conn.start_service_worker_runtime_protocol_message_for_session_with_deferred_response(cmd.session_id,descriptor,@@ -7615,6 +7630,7 @@ fn start_pending_runtime_binding_inspector_phase(let descriptor = RendererCommandDescriptor::from_frontend_policy(inspector_json,task.renderer_policy,+ RendererInspectorResponseDelivery::CommandReply,);conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response(completed.session_id(),@@ -7635,6 +7651,7 @@ fn start_pending_runtime_binding_inspector_phase(let descriptor = RendererCommandDescriptor::from_frontend_policy(inspector_json,task.renderer_policy,+ RendererInspectorResponseDelivery::CommandReply,);conn.start_runtime_protocol_message_for_session_owner_with_deferred_response(completed.session_id(),diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rsindex a1b4a8a5d..0424b1d2b 100644--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs@@ -673,13 +673,23 @@ async fn loaded_page_terminate_execution_dispatches_through_v8_runtime_agent() {"method": "Runtime.terminateExecution"}).to_string();+ let response_start = ctx.sent.len();let step = ctx.conn.start_command_dispatch(&raw);assert!(matches!(&step, CdpCommandTaskStep::Pending(_)),"Runtime.terminateExecution should dispatch to V8 Runtime agent instead of failing as UnknownMethod");- let (messages, scheduler_events) = complete_command_task_step_for_test(&mut ctx, step).await;+ let (mut messages, scheduler_events) =+ complete_command_task_step_for_test(&mut ctx, step).await;+ if !messages+ .iter()+ .any(|message| message["id"] == json!(11_009))+ {+ ctx.wait_for_test_command_response(11_009, response_start)+ .await;+ messages.push(ctx.take_response_by_id(11_009));+ }assert!(scheduler_events.is_empty(),"Runtime.terminateExecution should not enqueue scheduler work: {scheduler_events:?}"diff --git a/moli-protocol/src/domains/target/tests/tests_background_staging.rs b/moli-protocol/src/domains/target/tests/tests_background_staging.rsindex 38fbbc345..3acc82a9c 100644--- a/moli-protocol/src/domains/target/tests/tests_background_staging.rs+++ b/moli-protocol/src/domains/target/tests/tests_background_staging.rs@@ -4104,11 +4104,15 @@ async fn same_context_background_session_can_reenable_its_own_script_execution_b.as_ref().expect("active browser context");assert!(!active.script_execution_disabled);+ // A completed renderer call may retain its monotonic correlation+ // allocator in the parked session; only the effective setting must+ // collapse back to the default.assert!(active.parked_page_session_state(&second_target_id)- .is_none(),- "script execution re-enable should collapse staged parked state back to default"+ .is_none_or(|state| !state.script_execution_disabled),+ "script execution re-enable should clear the staged parked setting: {:#?}",+ active.parked_page_session_state(&second_target_id));}diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rsindex 7461645d3..11cc17fb6 100644--- a/moli-protocol/src/testing.rs+++ b/moli-protocol/src/testing.rs@@ -23,7 +23,6 @@ use moli_core::{RendererOutputStreamIdentity, RendererOutputTransportMessage, runtime::NavigationRuntimeConfig,};use moli_fetch::FetchConfig;-use moli_page_types::RendererInspectorResponseDelivery;#[cfg(test)]use std::net::SocketAddr;#[cfg(test)]@@ -382,7 +381,22 @@ impl TestContext {pub async fn process_async(&mut self, msg: impl serde::Serialize) {let command = ParsedCdpCommand::from_serializable(msg).expect("test message must be a valid serialisable CDP command");+ let command_id = command.request().id();+ let session_id = command.request().session_id().map(str::to_owned);+ let response_start = self.sent.len();Box::pin(self.process_parsed_command_like_scheduler(&command, true)).await;+ Box::pin(self.route_ready_test_command_response(command_id, response_start)).await;+ if self+ .conn+ .renderer_runtime_command_cause_for_frontend(session_id.as_deref(), command_id)+ .is_some()+ && !self+ .pending_runtime_deferred_replies+ .iter()+ .any(|pending| pending.command_id() == Some(command_id))+ {+ Box::pin(self.wait_for_test_command_response(command_id, response_start)).await;+ }}/// Dispatch one command and keep running the real scheduler inputs until@@ -393,15 +407,8 @@ impl TestContext {.expect("test message must be a valid serialisable CDP command");let command_id = command.request().id();let response_start = self.sent.len();- let response_uses_renderer_publication = command.renderer_policy().response_delivery()- == RendererInspectorResponseDelivery::DevToolsSession;Box::pin(self.process_parsed_command_like_scheduler(&command, true)).await;- Box::pin(self.wait_for_test_command_response(- command_id,- response_start,- response_uses_renderer_publication,- ))- .await;+ Box::pin(self.wait_for_test_command_response(command_id, response_start)).await;}#[cfg(test)]@@ -1224,39 +1231,50 @@ impl TestContext {TestSchedulerTurnOutcome::Processed(input_kind)}- async fn wait_for_test_command_response(+ pub(crate) async fn wait_for_test_command_response(&mut self,command_id: u64,response_start: usize,- response_uses_renderer_publication: bool,) {- loop {- if self- .sent- .get(response_start..)- .unwrap_or_default()- .iter()- .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))- {- return;+ let response = tokio::time::timeout(TEST_SCHEDULER_INPUT_TIMEOUT, async {+ loop {+ if self+ .sent+ .get(response_start..)+ .unwrap_or_default()+ .iter()+ .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))+ {+ return;+ }+ assert!(+ matches!(+ Box::pin(self.wait_for_one_test_scheduler_turn()).await,+ TestSchedulerTurnOutcome::Processed(_)+ ),+ "CDP command `{command_id}` lost all scheduler input before its response"+ );}- assert!(- self.background_navigation_scheduler_enabled- || response_uses_renderer_publication- || self- .pending_runtime_deferred_replies- .iter()- .any(|pending| pending.command_id() == Some(command_id)),- "CDP command `{command_id}` completed without producing a response or a typed pending reply"- );- assert!(- matches!(- Box::pin(self.wait_for_one_test_scheduler_turn()).await,- TestSchedulerTurnOutcome::Processed(_)- ),- "CDP command `{command_id}` lost all scheduler input before its response"- );- }+ })+ .await;+ assert!(+ response.is_ok(),+ "timed out waiting for CDP command `{command_id}` response"+ );+ }++ async fn route_ready_test_command_response(&mut self, command_id: u64, response_start: usize) {+ while !self+ .sent+ .get(response_start..)+ .unwrap_or_default()+ .iter()+ .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))+ && matches!(+ Box::pin(self.run_one_ready_test_scheduler_turn()).await,+ TestSchedulerTurnOutcome::Processed(_)+ )+ {}}async fn wait_for_one_test_scheduler_turn(&mut self) -> TestSchedulerTurnOutcome {diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rsindex 1dff3b5c9..9db4b4ef8 100644--- a/moli-renderer-v8/src/devtools/command.rs+++ b/moli-renderer-v8/src/devtools/command.rs@@ -149,10 +149,14 @@ pub struct RendererDevToolsIoCommandEnvelope {pub(crate) enum RendererDevToolsIoCommandPayload {Inspector(RendererInspectorCommandEnvelope),- PerformanceGetMetrics,+ PerformanceGetMetrics {+ result: Value,+ response: Option<RendererRuntimeInspectorResponseSender>,+ },SetScriptExecutionDisabled {control: RendererScriptExecutionControl,disabled: bool,+ response: Option<RendererRuntimeInspectorResponseSender>,},}@@ -179,7 +183,24 @@ impl RendererDevToolsIoCommandEnvelope {pub(crate) fn performance_get_metrics(ticket: RendererInspectorIngressTicket) -> Self {Self::new_agent_command(ticket,- RendererDevToolsIoCommandPayload::PerformanceGetMetrics,+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics {+ result: Value::Null,+ response: None,+ },+ )+ }++ pub(crate) fn performance_get_metrics_with_response(+ ticket: RendererInspectorIngressTicket,+ result: Value,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Self {+ Self::new_agent_command(+ ticket,+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics {+ result,+ response: Some(response),+ },)}@@ -190,7 +211,27 @@ impl RendererDevToolsIoCommandEnvelope {) -> Self {Self::new_agent_command(ticket,- RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { control, disabled },+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {+ control,+ disabled,+ response: None,+ },+ )+ }++ pub(crate) fn set_script_execution_disabled_with_response(+ ticket: RendererInspectorIngressTicket,+ control: RendererScriptExecutionControl,+ disabled: bool,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Self {+ Self::new_agent_command(+ ticket,+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {+ control,+ disabled,+ response: Some(response),+ },)}@@ -219,7 +260,7 @@ impl RendererDevToolsIoCommandEnvelope {RendererDevToolsIoCommandPayload::Inspector(_) => {RendererDevToolsIoCommandKind::Inspector}- RendererDevToolsIoCommandPayload::PerformanceGetMetrics => {+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics { .. } => {RendererDevToolsIoCommandKind::Performance}RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { .. } => {diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex d5eea0960..59f784ca6 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -204,6 +204,33 @@ impl RendererPageHandle {)}+ #[doc(hidden)]+ pub fn enqueue_performance_get_metrics_io_command_with_response(+ &self,+ attachment: RendererAgentAttachmentId,+ inspector_session_id: Option<String>,+ result: serde_json::Value,+ response: RendererRuntimeInspectorResponseSender,+ ) -> RendererRuntimeInspectorIoCommandRoute {+ debug_assert_eq!(+ response.renderer_agent_attachment_id(),+ Some(attachment),+ "Performance response must belong to the command attachment"+ );+ self.devtools_target.io_ref().enqueue_command(+ self.devtools_agent_token,+ RendererDevToolsIoCommandEnvelope::performance_get_metrics_with_response(+ RendererInspectorIngressTicket::new(+ Some(attachment),+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ result,+ response,+ ),+ )+ }+pub fn enqueue_runtime_inspector_main_command(&self,envelope: RendererInspectorCommandEnvelope,@@ -242,6 +269,34 @@ impl RendererPageHandle {)}+ #[doc(hidden)]+ pub fn enqueue_set_script_execution_disabled_io_command_with_response(+ &self,+ attachment: RendererAgentAttachmentId,+ inspector_session_id: Option<String>,+ disabled: bool,+ response: RendererRuntimeInspectorResponseSender,+ ) -> RendererRuntimeInspectorIoCommandRoute {+ debug_assert_eq!(+ response.renderer_agent_attachment_id(),+ Some(attachment),+ "Emulation response must belong to the command attachment"+ );+ self.devtools_target.io_ref().enqueue_command(+ self.devtools_agent_token,+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled_with_response(+ RendererInspectorIngressTicket::new(+ Some(attachment),+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ self.script_execution_control.clone(),+ disabled,+ response,+ ),+ )+ }+pub fn arm_runtime_inspector_session_detach(&self,) -> RendererRuntimeInspectorSessionDetachGuard {diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rsindex ee5c9c2b0..779deb775 100644--- a/moli-renderer-v8/src/runtime/page_dom.rs+++ b/moli-renderer-v8/src/runtime/page_dom.rs@@ -3838,6 +3838,13 @@ impl PageVm {stored_runtime_bindings: &[crate::protocol_types::RuntimeBindingRegistration],session_runtime_bindings: &[crate::protocol_types::RuntimeBindingRegistration],) {+ // Target attachment applies binding state before exposing the session+ // to frontend commands. Even an empty state must establish the+ // concrete renderer DevTools session/output capability: otherwise an+ // auxiliary session whose first command is a non-V8 IO agent has no+ // session host through which to publish its terminal response.+ self.vm_mut()+ .ensure_runtime_inspector_session(inspector_session_id);self.set_stored_runtime_bindings(stored_runtime_bindings);self.set_inspector_session_runtime_bindings(inspector_session_id, session_runtime_bindings);}diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex 35062633d..62d9172ee 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -6900,6 +6900,14 @@ impl ScriptVm {});}+ pub(super) fn ensure_runtime_inspector_session(&mut self, inspector_session_id: Option<&str>) {+ let renderer_document_isolate = self.renderer_document_isolate.clone();+ let page_inspector = &self.page_inspector;+ renderer_document_isolate.with_renderer_document_isolate_and_inspector_mut(|_, backend| {+ page_inspector.ensure_frontend_session(backend, inspector_session_id);+ });+ }+pub(super) fn page_diagnostics_snapshot(&mut self) -> Result<RendererPageDiagnosticsSnapshot> {self.sync_runtime_observable_source_events()?;let runtime_observable_source = selfdiff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex 6f81bdf7a..c9975e14a 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -171,6 +171,15 @@ impl DocumentInspectorBinding {}}+ pub(super) fn ensure_frontend_session(+ &self,+ backend: &mut RendererInspectorIsolateBackend,+ inspector_session_id: Option<&str>,+ ) {+ self.agent+ .ensure_frontend(backend, inspector_session_key(inspector_session_id));+ }+pub(super) fn end_runtime_command_output_for_session(&self,inspector_session_id: Option<&str>,diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rsindex 6669ac91e..112b0aeb6 100644--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs@@ -418,7 +418,28 @@ impl InspectorOutbound {callback: RendererRuntimeInspectorResponseSender,delivery: RendererInspectorResponseDelivery,) {- let callback = match delivery {+ let callback = self.route_frontend_response(callback, delivery);+ self.register_response_callback(callback);+ }++ /// Publishes a synchronous non-V8 agent response through this concrete+ /// frontend session's attachment-scoped output capability.+ pub(in crate::script_vm) fn publish_devtools_session_response(+ &self,+ callback: RendererRuntimeInspectorResponseSender,+ message: Value,+ ) {+ let callback = self+ .route_frontend_response(callback, RendererInspectorResponseDelivery::DevToolsSession);+ let _ = callback.send(message);+ }++ fn route_frontend_response(+ &self,+ callback: RendererRuntimeInspectorResponseSender,+ delivery: RendererInspectorResponseDelivery,+ ) -> RendererRuntimeInspectorResponseSender {+ match delivery {RendererInspectorResponseDelivery::CommandReply => callback,RendererInspectorResponseDelivery::DevToolsSession => {let host = self@@ -437,8 +458,7 @@ impl InspectorOutbound {.expect("frontend session output requires an attachment-scoped Page journal");callback.route_to_devtools_session_output(host)}- };- self.register_response_callback(callback);+ }}pub(in crate::script_vm) fn cancel_response_callback(&self, call_id: i32) {diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex 0f1d336ed..56ec1d607 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -224,15 +224,13 @@ impl RendererInspectorSessionExecutorLocal {}fn dispatch_io_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {- let session_key = command.ticket().session().clone();- self.sessions- .borrow()- .get(&(context_group_id, session_key))- .filter(|session| session.agent_token == command.agent_token)- .cloned()- });- let session = session.flatten();+ let session_key = command.ticket().session().clone();+ let session = self+ .sessions+ .borrow()+ .get(&(context_group_id, session_key))+ .filter(|session| session.agent_token == command.agent_token)+ .cloned();self.dispatch_io_command_to_session(command, session);}@@ -265,14 +263,12 @@ impl RendererInspectorSessionExecutorLocal {let Some(command) = self.target.io_ref().claim_for_interrupt() else {return;};- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {- let session_key = command.ticket().session();- self.interrupt_sessions- .borrow()- .get(&(command.agent_token, session_key.clone()))- .cloned()- });- let session = session.flatten();+ let session_key = command.ticket().session();+ let session = self+ .interrupt_sessions+ .borrow()+ .get(&(command.agent_token, session_key.clone()))+ .cloned();self.dispatch_io_command_to_session(command, session);}@@ -280,14 +276,12 @@ impl RendererInspectorSessionExecutorLocal {let Some(command) = self.target.io_ref().claim_for_owner() else {return;};- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {- let session_key = command.ticket().session();- self.interrupt_sessions- .borrow()- .get(&(command.agent_token, session_key.clone()))- .cloned()- });- let session = session.flatten();+ let session_key = command.ticket().session();+ let session = self+ .interrupt_sessions+ .borrow()+ .get(&(command.agent_token, session_key.clone()))+ .cloned();self.dispatch_io_command_to_session(command, session);}@@ -337,13 +331,25 @@ impl RendererInspectorSessionExecutorLocal {let mut first_dispatch = self.target.io_ref().first_dispatch_guard(&mut command);match command.kind() {RendererDevToolsIoCommandKind::Performance => {- assert!(- matches!(- command.into_payload(),- RendererDevToolsIoCommandPayload::PerformanceGetMetrics- ),- "Performance IO command kind must carry a Performance payload"- );+ let RendererDevToolsIoCommandPayload::PerformanceGetMetrics { result, response } =+ command.into_payload()+ else {+ unreachable!("Performance IO command kind must carry a Performance payload")+ };+ if let Some(response) = response {+ let Some(session) = session else {+ send_inspector_dispatch_error(+ Some(response),+ "Inspector session is not available",+ );+ return;+ };+ let call_id = response.call_id();+ session.outbound.publish_devtools_session_response(+ response,+ json!({ "id": call_id, "result": result }),+ );+ }first_dispatch.release();return;}@@ -351,11 +357,26 @@ impl RendererInspectorSessionExecutorLocal {let RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {control,disabled,+ response,} = command.into_payload()else {unreachable!("Emulation IO command kind must carry an Emulation payload")};+ if response.is_some() && session.is_none() {+ send_inspector_dispatch_error(response, "Inspector session is not available");+ return;+ }control.set_disabled(disabled);+ if let Some(response) = response {+ let call_id = response.call_id();+ session+ .expect("a checked frontend Emulation command must have a session")+ .outbound+ .publish_devtools_session_response(+ response,+ json!({ "id": call_id, "result": {} }),+ );+ }first_dispatch.release();return;}