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 Page IO agent ingress
ldm0f90729edf39d
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex 0199ce67e..cb4888f65 100644--- a/moli-core/src/page/command_dispatch.rs+++ b/moli-core/src/page/command_dispatch.rs@@ -16,9 +16,21 @@ pub struct PendingRuntimeInspectorCommandDispatch {kind: PendingRuntimeInspectorCommandDispatchKind,}+/// One non-V8 renderer agent command admitted through the Page IO+/// `DevToolsSession` receiver.+pub struct PendingDevToolsIoCommandDispatch {+ route: RendererRuntimeInspectorIoCommandRoute,+}+enum PendingRuntimeInspectorCommandDispatchKind {MainIngress(Box<RendererRuntimeInspectorMainCommandRoute>),- Io(RendererRuntimeInspectorIoCommandRoute),+ Io(PendingDevToolsIoCommandDispatch),+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum CompletedDevToolsIoCommandDispatch {+ Dispatched,+ Canceled,}/// Identifies which execution owner consumed one routable Inspector command.@@ -144,10 +156,18 @@ impl Page {route: RendererRuntimeInspectorIoCommandRoute,) -> PendingRuntimeInspectorCommandDispatch {Self::pending_runtime_inspector_command_dispatch(- PendingRuntimeInspectorCommandDispatchKind::Io(route),+ PendingRuntimeInspectorCommandDispatchKind::Io(+ Self::pending_devtools_io_command_dispatch(route),+ ),)}+ pub(crate) fn pending_devtools_io_command_dispatch(+ route: RendererRuntimeInspectorIoCommandRoute,+ ) -> PendingDevToolsIoCommandDispatch {+ PendingDevToolsIoCommandDispatch { route }+ }+pub(crate) fn pending_main_ingress_runtime_inspector_command_dispatch(route: RendererRuntimeInspectorMainCommandRoute,) -> PendingRuntimeInspectorCommandDispatch {@@ -403,12 +423,12 @@ impl PendingRuntimeInspectorCommandDispatch {}}}- PendingRuntimeInspectorCommandDispatchKind::Io(route) => {- match route.wait_for_claim().await.map_err(anyhow::Error::msg)? {- RendererRuntimeInspectorIoCommandClaim::Inspector => {+ PendingRuntimeInspectorCommandDispatchKind::Io(pending) => {+ match pending.wait().await? {+ CompletedDevToolsIoCommandDispatch::Dispatched => {Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)}- RendererRuntimeInspectorIoCommandClaim::Canceled => {+ CompletedDevToolsIoCommandDispatch::Canceled => {Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)}}@@ -416,3 +436,21 @@ impl PendingRuntimeInspectorCommandDispatch {}}}++impl PendingDevToolsIoCommandDispatch {+ pub async fn wait(self) -> Result<CompletedDevToolsIoCommandDispatch> {+ match self+ .route+ .wait_for_first_dispatch()+ .await+ .map_err(anyhow::Error::msg)?+ {+ RendererRuntimeInspectorIoCommandClaim::Dispatched => {+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched)+ }+ RendererRuntimeInspectorIoCommandClaim::Canceled => {+ Ok(CompletedDevToolsIoCommandDispatch::Canceled)+ }+ }+ }+}diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex b7257c225..bcb9140cc 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -8,9 +8,10 @@ use super::protocol_support::{RuntimeIsolatedWorldDefinition,};use super::{- CompletedPageCommand, PendingPageCommand, PendingRuntimeInspectorCommandDispatch,- RendererCommandTurnOutput, RendererInspectorSessionRestoreSnapshot,- RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage, RendererRuntimeRealmInfo,+ CompletedPageCommand, PendingDevToolsIoCommandDispatch, PendingPageCommand,+ PendingRuntimeInspectorCommandDispatch, RendererCommandTurnOutput,+ RendererInspectorSessionRestoreSnapshot, RendererRuntimeCommandOutput,+ RendererRuntimeInspectorMessage, RendererRuntimeRealmInfo,};use crate::RendererOutputFence;use crate::renderer::{@@ -826,6 +827,26 @@ impl Page {self.start_page_command(RendererPageCommand::PerformanceMetricSnapshot)}+ /// Admits `Performance.getMetrics` through the same IO session lane used+ /// by interruptible V8 Inspector commands. The snapshot remains the latest+ /// owner-published value because collecting a fresh JS-derived snapshot is+ /// not re-entrant while the isolate is executing JavaScript.+ pub fn start_performance_metric_snapshot_from_io(+ &self,+ ) -> (+ PendingDevToolsIoCommandDispatch,+ RendererPerformanceMetricSnapshot,+ ) {+ let route = self.handle.enqueue_performance_get_metrics_io_command(+ self.renderer_agent_attachment_id,+ self.renderer_devtools_command_session_id.clone(),+ );+ (+ Self::pending_devtools_io_command_dispatch(route),+ self.cached_performance_metric_snapshot(),+ )+ }+pub fn cached_performance_metric_snapshot(&self) -> RendererPerformanceMetricSnapshot {self.page_state.performance_metric_snapshot().clone()}diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rsindex cc9e6a52b..8963c348d 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -39,7 +39,8 @@ use crate::renderer::{};use anyhow::Result;pub use command_dispatch::{- CompletedPageCommand, CompletedRuntimeInspectorCommandDispatch, PendingPageCommand,+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand,+ CompletedRuntimeInspectorCommandDispatch, PendingDevToolsIoCommandDispatch, PendingPageCommand,PendingRuntimeInspectorCommandDispatch,};diff --git a/moli-core/src/page/settings_support.rs b/moli-core/src/page/settings_support.rsindex 94396c170..c7a902636 100644--- a/moli-core/src/page/settings_support.rs+++ b/moli-core/src/page/settings_support.rs@@ -7,7 +7,7 @@ use super::protocol_support::{EmulatedIdleOverride, EmulatedMediaOverrides, PermissionOverrideRegistration,SubresourceResourceType, ViewportSurface,};-use super::{CompletedPageCommand, Page, PendingPageCommand};+use super::{CompletedPageCommand, Page, PendingDevToolsIoCommandDispatch, PendingPageCommand};use crate::renderer::{RendererPageCommand, RendererPageCookieFacadeSnapshotReply, RendererPageReply,};@@ -235,10 +235,20 @@ impl Page {.await}- /// Applies the DevTools IO-agent setting without entering the renderer- /// owner's Main command queue.- pub fn set_script_execution_disabled_from_io(&self, disabled: bool) {- self.handle.set_script_execution_disabled_from_io(disabled);+ /// Admits the DevTools IO-agent setting through the target's shared IO+ /// session lane without entering the renderer owner's Main command queue.+ pub fn start_set_script_execution_disabled_from_io(+ &self,+ disabled: bool,+ ) -> PendingDevToolsIoCommandDispatch {+ let route = self+ .handle+ .enqueue_set_script_execution_disabled_io_command(+ self.renderer_agent_attachment_id,+ self.renderer_devtools_command_session_id.clone(),+ disabled,+ );+ Self::pending_devtools_io_command_dispatch(route)}pub async fn set_bypass_content_security_policy_async(&mut self, bypass: bool) -> Result<()> {diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rsindex 38c01e1b2..78cf7c3fa 100644--- a/moli-protocol/src/domains/emulation.rs+++ b/moli-protocol/src/domains/emulation.rs@@ -17,7 +17,10 @@ use crate::domains::actions::EmulationAction;use crate::domains::command_output::CommandOutputPlan;use moli_core::{RendererRuntimeInspectorResponseSender,- page::{CompletedPageCommand, PendingPageCommand},+ page::{+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand, PendingDevToolsIoCommandDispatch,+ PendingPageCommand,+ },};use serde_json::json;@@ -31,13 +34,23 @@ mod tests;pub(crate) struct PendingEmulationCommandDispatch {command_id: Option<u64>,session_id: Option<String>,- pending: Vec<PendingEmulationPageCommand>,+ pending: PendingEmulationRendererDispatch,}pub(crate) struct CompletedEmulationCommandDispatch {command_id: Option<u64>,session_id: Option<String>,- completed: Vec<CompletedEmulationPageCommand>,+ completed: CompletedEmulationRendererDispatch,+}++enum PendingEmulationRendererDispatch {+ Pages(Vec<PendingEmulationPageCommand>),+ Io(PendingDevToolsIoCommandDispatch),+}++enum CompletedEmulationRendererDispatch {+ Pages(Vec<CompletedEmulationPageCommand>),+ Io(Result<CompletedDevToolsIoCommandDispatch, String>),}struct PendingEmulationPageCommand {@@ -88,26 +101,36 @@ enum PendingEmulationPageOperation {impl PendingEmulationCommandDispatch {pub(crate) async fn wait(self) -> CompletedEmulationCommandDispatch {- let mut completed = Vec::with_capacity(self.pending.len());- for pending in self.pending {- let PendingEmulationPageCommand {- target,- operation,- pending,- runtime_response_rx,- } = pending;- let completed_page = pending.wait().await.map_err(|error| error.to_string());- if completed_page.is_ok()- && let Some(response_rx) = runtime_response_rx- {- let _ = response_rx.await;+ let completed = match self.pending {+ PendingEmulationRendererDispatch::Pages(pending_pages) => {+ let mut completed = Vec::with_capacity(pending_pages.len());+ for pending in pending_pages {+ let PendingEmulationPageCommand {+ target,+ operation,+ pending,+ runtime_response_rx,+ } = pending;+ let completed_page = pending.wait().await.map_err(|error| error.to_string());+ if completed_page.is_ok()+ && let Some(response_rx) = runtime_response_rx+ {+ let _ = response_rx.await;+ }+ completed.push(CompletedEmulationPageCommand {+ target,+ operation,+ completed: completed_page,+ });+ }+ CompletedEmulationRendererDispatch::Pages(completed)}- completed.push(CompletedEmulationPageCommand {- target,- operation,- completed: completed_page,- });- }+ PendingEmulationRendererDispatch::Io(pending) => {+ CompletedEmulationRendererDispatch::Io(+ pending.wait().await.map_err(|error| error.to_string()),+ )+ }+ };CompletedEmulationCommandDispatch {command_id: self.command_id,session_id: self.session_id,@@ -325,8 +348,12 @@ fn start_script_execution_disabled_command(let Some(page) = loaded_page_mut_for_session(conn, cmd.session_id) else {return EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})));};- page.set_script_execution_disabled_from_io(params.value);- EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})))+ let pending = page.start_set_script_execution_disabled_from_io(params.value);+ EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {+ command_id: cmd.id,+ session_id: cmd.session_id.map(str::to_owned),+ pending: PendingEmulationRendererDispatch::Io(pending),+ })}fn start_locale_override_command(@@ -377,7 +404,7 @@ fn start_locale_override_command(EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: cmd.session_id.map(str::to_owned),- pending,+ pending: PendingEmulationRendererDispatch::Pages(pending),})}@@ -560,7 +587,7 @@ fn start_update_geolocation_override_command(EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: cmd.session_id.map(str::to_owned),- pending,+ pending: PendingEmulationRendererDispatch::Pages(pending),})}@@ -625,7 +652,7 @@ fn start_emulated_media_command(EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: cmd.session_id.map(str::to_owned),- pending,+ pending: PendingEmulationRendererDispatch::Pages(pending),})}@@ -649,12 +676,12 @@ fn start_user_agent_override_command(Ok(Some(pending)) => EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: cmd.session_id.map(str::to_owned),- pending: vec![PendingEmulationPageCommand {+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {target: PendingEmulationPageTarget::SessionOwner { owner_scope },operation: PendingEmulationPageOperation::SetUserAgentLoader,pending,runtime_response_rx: None,- }],+ }]),}),Ok(None) => EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({}))),Err(message) if message == "BrowserContextNotLoaded" => EmulationCommandTaskStep::Complete(@@ -779,7 +806,7 @@ fn start_clear_device_metrics_override_command(EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,session_id: session_id.clone(),- pending: vec![+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {target: PendingEmulationPageTarget::SessionOwner {owner_scope: owner_scope.clone(),@@ -794,7 +821,7 @@ fn start_clear_device_metrics_override_command(pending: pending_runtime,runtime_response_rx,},- ],+ ]),})}Err(error) => EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error)),@@ -844,7 +871,7 @@ fn start_devtools_set_viewport_command(Ok(Some(PendingEmulationCommandDispatch {command_id,session_id: session_id.clone(),- pending: vec![+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {target: PendingEmulationPageTarget::SessionOwner {owner_scope: owner_scope.clone(),@@ -859,7 +886,7 @@ fn start_devtools_set_viewport_command(pending: pending_runtime,runtime_response_rx,},- ],+ ]),}))}@@ -1532,7 +1559,7 @@ async fn complete_emulation_page_updates(PendingEmulationCommandDispatch {command_id: None,session_id,- pending,+ pending: PendingEmulationRendererDispatch::Pages(pending),}.wait().await,@@ -2111,7 +2138,7 @@ async fn execute_devtools_set_viewport_for_browser_contexts(.session_id.as_ref().map(|session_id| session_id.as_str().to_owned()),- pending,+ pending: PendingEmulationRendererDispatch::Pages(pending),}.wait().await,@@ -2280,7 +2307,13 @@ fn complete_pending_devtools_emulation_command(conn: &mut CdpConnection,completed: CompletedEmulationCommandDispatch,) -> Result<DevToolsCommandResult, DevToolsError> {- for completed_page in completed.completed {+ let CompletedEmulationRendererDispatch::Pages(completed_pages) = completed.completed else {+ return Err(DevToolsError::new(+ DevToolsErrorKind::Internal,+ "DevTools emulation command completed through the CDP-only IO receiver",+ ));+ };+ for completed_page in completed_pages {let completion = completed_page.completed.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))?;@@ -2335,7 +2368,21 @@ pub(crate) fn complete_pending_emulation_command(conn: &mut CdpConnection,completed: CompletedEmulationCommandDispatch,) -> CommandOutputPlan {- for completed_page in completed.completed {+ let completed_pages = match completed.completed {+ CompletedEmulationRendererDispatch::Pages(completed_pages) => completed_pages,+ CompletedEmulationRendererDispatch::Io(completed) => {+ return match completed {+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {+ CommandOutputPlan::result(json!({}))+ }+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {+ CommandOutputPlan::error(-32000, "Emulation IO command was canceled")+ }+ Err(error) => CommandOutputPlan::error(-32000, error),+ };+ }+ };+ for completed_page in completed_pages {let completion = match completed_page.completed {Ok(completion) => completion,Err(error) => return CommandOutputPlan::error(-32000, error),@@ -2401,12 +2448,12 @@ fn single_pending_emulation_dispatch(PendingEmulationCommandDispatch {command_id,session_id: session_id.clone(),- pending: vec![PendingEmulationPageCommand {+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {target: PendingEmulationPageTarget::SessionOwner { owner_scope },operation,pending,runtime_response_rx,- }],+ }]),}}diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rsindex 280fc567d..473cbb6da 100644--- a/moli-protocol/src/domains/emulation/tests.rs+++ b/moli-protocol/src/domains/emulation/tests.rs@@ -183,7 +183,7 @@ async fn bidi_set_extra_headers_merges_global_user_context_and_context_layers()}#[tokio::test(flavor = "multi_thread")]-async fn script_execution_disabled_completes_without_waiting_for_main_owner() {+async fn script_execution_disabled_completes_through_io_pending_dispatch() {let mut ctx = TestContext::new();load_session_page_for_pending_emulation_test(&mut ctx).await;@@ -194,10 +194,11 @@ async fn script_execution_disabled_completes_without_waiting_for_main_owner() {"params": { "value": true }}).to_string();- let CdpCommandTaskStep::Complete(outcome) = ctx.conn.start_command_dispatch(&raw) else {- panic!("the IO-routed script execution override must not wait for the Main owner");- };- let messages = outcome.into_parts().0;+ 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;assert!(messages.iter().any(|message| {message["id"] == json!(9101)diff --git a/moli-protocol/src/domains/performance.rs b/moli-protocol/src/domains/performance.rsindex 05223bf32..e01f2c978 100644--- a/moli-protocol/src/domains/performance.rs+++ b/moli-protocol/src/domains/performance.rs@@ -5,7 +5,8 @@ use crate::conn::{use crate::domains::actions::PerformanceAction;use crate::domains::command_output::CommandOutputPlan;use moli_core::page::{- CompletedPageCommand, Page, PendingPageCommand, RendererPerformanceMetricSnapshot,+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand, Page,+ PendingDevToolsIoCommandDispatch, PendingPageCommand, RendererPerformanceMetricSnapshot,};use serde::Deserialize;use serde_json::{Value, json};@@ -27,7 +28,7 @@ pub(crate) struct PendingPerformanceCommandDispatch {owner_scope: CommandOwnerScope,renderer_access: CdpRendererCommandAccess,renderer_page: crate::conn::RendererPageResidenceIdentity,- pending: PendingPageCommand,+ pending: Box<PendingPerformanceRendererCommand>,}pub(crate) struct CompletedPerformanceCommandDispatch {@@ -35,7 +36,20 @@ pub(crate) struct CompletedPerformanceCommandDispatch {owner_scope: CommandOwnerScope,renderer_access: CdpRendererCommandAccess,renderer_page: crate::conn::RendererPageResidenceIdentity,- completed: Result<CompletedPageCommand, String>,+ completed: Result<CompletedPerformanceRendererCommand, String>,+}++enum PendingPerformanceRendererCommand {+ Main(PendingPageCommand),+ Io {+ pending: PendingDevToolsIoCommandDispatch,+ snapshot: RendererPerformanceMetricSnapshot,+ },+}++enum CompletedPerformanceRendererCommand {+ Main(CompletedPageCommand),+ Io(RendererPerformanceMetricSnapshot),}pub(crate) enum PerformanceCommandTaskStep {@@ -49,12 +63,29 @@ impl PendingPerformanceCommandDispatch {}pub async fn wait(self) -> CompletedPerformanceCommandDispatch {+ let completed = match *self.pending {+ PendingPerformanceRendererCommand::Main(pending) => pending+ .wait()+ .await+ .map(CompletedPerformanceRendererCommand::Main),+ PendingPerformanceRendererCommand::Io { pending, snapshot } => {+ match pending.wait().await {+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {+ Ok(CompletedPerformanceRendererCommand::Io(snapshot))+ }+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {+ Err(anyhow::anyhow!("Performance IO command was canceled"))+ }+ Err(error) => Err(error),+ }+ }+ };CompletedPerformanceCommandDispatch {command_id: self.command_id,owner_scope: self.owner_scope,renderer_access: self.renderer_access,renderer_page: self.renderer_page,- completed: self.pending.wait().await.map_err(|error| error.to_string()),+ completed: completed.map_err(|error| error.to_string()),}}}@@ -198,9 +229,15 @@ pub(crate) fn try_start_performance_command_dispatch(}};if renderer_access == CdpRendererCommandAccess::Io {- return PerformanceCommandTaskStep::Complete(performance_metrics_command_output_plan(- &page.cached_performance_metric_snapshot(),- ));+ let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);+ 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::Io { pending, snapshot }),+ });}let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);let pending = match page.start_performance_metric_snapshot() {@@ -214,7 +251,7 @@ pub(crate) fn try_start_performance_command_dispatch(owner_scope,renderer_access,renderer_page,- pending,+ pending: Box::new(PendingPerformanceRendererCommand::Main(pending)),})}@@ -246,15 +283,35 @@ pub(crate) async fn complete_pending_performance_command(let session_id = owner_scope.session_id().map(str::to_owned);let mut owner_scope = owner_scope.enter(conn);let snapshot = match completed {- Ok(completed_page) => loaded_page_mut_for_renderer_access(- owner_scope.conn_mut(),- session_id.as_deref(),- renderer_access,- )- .ok()- .filter(|page| crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page)- .and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok())- .unwrap_or_default(),+ Ok(CompletedPerformanceRendererCommand::Main(completed_page)) => {+ loaded_page_mut_for_renderer_access(+ owner_scope.conn_mut(),+ session_id.as_deref(),+ renderer_access,+ )+ .ok()+ .filter(|page| {+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page+ })+ .and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok())+ .unwrap_or_default()+ }+ Ok(CompletedPerformanceRendererCommand::Io(snapshot)) => {+ let remains_current = loaded_page_mut_for_renderer_access(+ owner_scope.conn_mut(),+ session_id.as_deref(),+ renderer_access,+ )+ .ok()+ .is_some_and(|page| {+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page+ });+ if remains_current {+ snapshot+ } else {+ RendererPerformanceMetricSnapshot::default()+ }+ }Err(_) => RendererPerformanceMetricSnapshot::default(),};CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(&snapshot) }))@@ -756,8 +813,8 @@ mod tests {"sessionId": "SID-1"}).to_string();- let old_messages =- complete_immediate_command_task_step_for_test(ctx.conn.start_command_dispatch(&raw));+ let step = ctx.conn.start_command_dispatch(&raw);+ let old_messages = complete_command_task_step_for_test(&mut ctx, step).await;let old_response = old_messages.iter().find(|message| message["id"] == json!(4_011))@@ -789,9 +846,8 @@ mod tests {"sessionId": "SID-1"}).to_string();- let replacement_messages = complete_immediate_command_task_step_for_test(- ctx.conn.start_command_dispatch(&replacement_raw),- );+ let step = ctx.conn.start_command_dispatch(&replacement_raw);+ let replacement_messages = complete_command_task_step_for_test(&mut ctx, step).await;let replacement_response = replacement_messages.iter().find(|message| message["id"] == json!(4_012))diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rsindex 9c1418f0a..ed6a15294 100644--- a/moli-renderer-v8/src/devtools/command.rs+++ b/moli-renderer-v8/src/devtools/command.rs@@ -3,6 +3,7 @@use crate::runtime::{RendererInspectorPageCommand, RendererPageCommand, RendererRuntimeInspectorResponseSender,};+use crate::script_execution_control::RendererScriptExecutionControl;use moli_page_types::{DevToolsSessionKey, RendererAgentAttachmentId};use serde_json::Value;use std::sync::atomic::{AtomicU64, Ordering};@@ -133,6 +134,120 @@ pub struct RendererInspectorCommandEnvelope {payload: RendererInspectorCommandPayload,}+/// One command delivered by the renderer's IO DevTools receiver.+///+/// Chromium chooses the IO receiver at the `DevToolsSession` boundary, before+/// it chooses the renderer agent that will execute the command. Keep that+/// ordering structural here as well: V8 Inspector, Performance, and Emulation+/// commands share one `(target, session, IO)` first-dispatch lane.+#[doc(hidden)]+pub struct RendererDevToolsIoCommandEnvelope {+ ticket: RendererInspectorIngressTicket,+ payload: RendererDevToolsIoCommandPayload,+}++pub(crate) enum RendererDevToolsIoCommandPayload {+ Inspector(RendererInspectorCommandEnvelope),+ PerformanceGetMetrics,+ SetScriptExecutionDisabled {+ control: RendererScriptExecutionControl,+ disabled: bool,+ },+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererDevToolsIoCommandKind {+ Inspector,+ Performance,+ Emulation,+}++impl RendererDevToolsIoCommandEnvelope {+ pub(crate) fn inspector(envelope: RendererInspectorCommandEnvelope) -> Self {+ assert_eq!(+ envelope.ticket().route(),+ RendererInspectorCommandRoute::Io,+ "an Inspector payload entering the IO receiver must use the IO route"+ );+ Self {+ ticket: envelope.ticket().clone(),+ payload: RendererDevToolsIoCommandPayload::Inspector(envelope),+ }+ }++ pub(crate) fn performance_get_metrics(ticket: RendererInspectorIngressTicket) -> Self {+ Self::new_agent_command(+ ticket,+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics,+ )+ }++ pub(crate) fn set_script_execution_disabled(+ ticket: RendererInspectorIngressTicket,+ control: RendererScriptExecutionControl,+ disabled: bool,+ ) -> Self {+ Self::new_agent_command(+ ticket,+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { control, disabled },+ )+ }++ fn new_agent_command(+ ticket: RendererInspectorIngressTicket,+ payload: RendererDevToolsIoCommandPayload,+ ) -> Self {+ assert_eq!(+ ticket.route(),+ RendererInspectorCommandRoute::Io,+ "a renderer IO agent payload must use the IO route"+ );+ Self { ticket, payload }+ }++ pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {+ &self.ticket+ }++ pub(crate) fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {+ RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch+ }++ pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {+ match &self.payload {+ RendererDevToolsIoCommandPayload::Inspector(_) => {+ RendererDevToolsIoCommandKind::Inspector+ }+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics => {+ RendererDevToolsIoCommandKind::Performance+ }+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { .. } => {+ RendererDevToolsIoCommandKind::Emulation+ }+ }+ }++ pub(crate) fn inspector_envelope(&self) -> Option<&RendererInspectorCommandEnvelope> {+ match &self.payload {+ RendererDevToolsIoCommandPayload::Inspector(envelope) => Some(envelope),+ _ => None,+ }+ }++ pub(crate) fn inspector_envelope_mut(+ &mut self,+ ) -> Option<&mut RendererInspectorCommandEnvelope> {+ match &mut self.payload {+ RendererDevToolsIoCommandPayload::Inspector(envelope) => Some(envelope),+ _ => None,+ }+ }++ pub(crate) fn into_payload(self) -> RendererDevToolsIoCommandPayload {+ self.payload+ }+}+/// One command delivered by the renderer's Main DevTools receiver.////// Unlike `RendererInspectorCommandEnvelope`, this envelope is deliberatelydiff --git a/moli-renderer-v8/src/devtools/ingress/io.rs b/moli-renderer-v8/src/devtools/ingress/io.rsindex 4cb8a7b69..75aae61f3 100644--- a/moli-renderer-v8/src/devtools/ingress/io.rs+++ b/moli-renderer-v8/src/devtools/ingress/io.rs@@ -20,9 +20,10 @@ use crate::{route::RendererInspectorSessionExecutorRouteId,},runtime::{- RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,- RendererInspectorIngressTicket, RendererInspectorPauseCommandEffect,- RendererRuntimeInspectorResponseSender,+ RendererDevToolsIoCommandEnvelope, RendererDevToolsIoCommandKind,+ RendererDevToolsIoCommandPayload, RendererInspectorCommandEnvelope,+ RendererInspectorCommandRoute, RendererInspectorIngressTicket,+ RendererInspectorPauseCommandEffect, RendererRuntimeInspectorResponseSender,},};@@ -49,8 +50,8 @@ pub(crate) enum RendererInspectorIoCommandConsumer {pub(crate) struct RendererInspectorIoCommand {command_id: u64,pub(crate) agent_token: RendererDevToolsAgentToken,- envelope: RendererInspectorCommandEnvelope,- claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,+ envelope: RendererDevToolsIoCommandEnvelope,+ first_dispatch_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,claimed_by: Option<RendererInspectorIoCommandConsumer>,}@@ -69,20 +70,39 @@ impl RendererInspectorIoCommand {self.envelope.first_dispatch_lifecycle()}+ pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {+ self.envelope.kind()+ }+pub(crate) fn raw_json(&self) -> &str {- self.envelope.io_raw_json()+ self.envelope+ .inspector_envelope()+ .expect("only an Inspector IO payload has protocol JSON")+ .io_raw_json()}pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {- self.envelope.io_response()+ self.envelope+ .inspector_envelope()+ .and_then(RendererInspectorCommandEnvelope::io_response)}pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {- self.envelope.pause_effect()+ self.envelope+ .inspector_envelope()+ .map_or(RendererInspectorPauseCommandEffect::None, |envelope| {+ envelope.pause_effect()+ })}pub(crate) fn take_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {- self.envelope.take_io_response()+ self.envelope+ .inspector_envelope_mut()+ .and_then(RendererInspectorCommandEnvelope::take_io_response)+ }++ pub(crate) fn into_payload(self) -> RendererDevToolsIoCommandPayload {+ self.envelope.into_payload()}#[cfg(test)]@@ -99,14 +119,15 @@ impl RendererDevToolsIngressCommand for RendererInspectorIoCommand {#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub enum RendererRuntimeInspectorIoCommandClaim {- Inspector,+ Dispatched,Canceled,}pub struct RendererRuntimeInspectorIoCommandRoute {command_id: u64,ticket: RendererInspectorIngressTicket,- claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorIoCommandClaim>>,+ first_dispatch_rx:+ Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorIoCommandClaim>>,ingress: RendererInspectorIoIngress,}@@ -119,14 +140,14 @@ impl RendererRuntimeInspectorIoCommandRoute {&self.ticket}- pub async fn wait_for_claim(+ pub async fn wait_for_first_dispatch(mut self,) -> Result<RendererRuntimeInspectorIoCommandClaim, &'static str> {- self.claim_rx+ self.first_dispatch_rx.take()- .expect("runtime inspector IO command claim receiver should only be awaited once")+ .expect("runtime Inspector IO first dispatch should only be awaited once").await- .map_err(|_| "runtime inspector IO command claim channel closed")+ .map_err(|_| "runtime Inspector IO first-dispatch channel closed")}}@@ -178,6 +199,7 @@ pub(crate) struct RendererInspectorIoFirstDispatchGuard {ingress: RendererInspectorIoIngress,active: Option<(RendererDevToolsSessionLaneKey, u64)>,consumer: RendererInspectorIoCommandConsumer,+ first_dispatch_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,}pub(crate) struct RendererInspectorIoPostDispatchWakeGuard {@@ -219,7 +241,11 @@ impl RendererInspectorIoFirstDispatchGuard {.interrupt_armed.store(false, Ordering::Release);}- self.ingress.finish_first_dispatch(lane, command_id)+ let has_ready = self.ingress.finish_first_dispatch(lane, command_id);+ if let Some(first_dispatch_tx) = self.first_dispatch_tx.take() {+ let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Dispatched);+ }+ has_ready}}@@ -297,15 +323,15 @@ impl RendererInspectorIoIngress {pub(crate) fn enqueue_command(&self,agent_token: RendererDevToolsAgentToken,- envelope: RendererInspectorCommandEnvelope,+ envelope: RendererDevToolsIoCommandEnvelope,) -> RendererRuntimeInspectorIoCommandRoute {assert_eq!(envelope.ticket().route(),RendererInspectorCommandRoute::Io,- "only IO Inspector commands may enter RendererInspectorIoIngress"+ "only IO DevTools commands may enter RendererInspectorIoIngress");let ticket = envelope.ticket().clone();- let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();+ let (first_dispatch_tx, first_dispatch_rx) = tokio::sync::oneshot::channel();let mut state = self.shared.state.lock();let command_id = ticket.sequence();let lane_key = RendererDevToolsSessionLaneKey::new(agent_token, ticket.session().clone());@@ -313,7 +339,7 @@ impl RendererInspectorIoIngress {command_id,agent_token,envelope,- claim_tx: Some(claim_tx),+ first_dispatch_tx: Some(first_dispatch_tx),claimed_by: None,};if let Err(rejected) = state.lanes.enqueue(lane_key, command) {@@ -333,7 +359,7 @@ impl RendererInspectorIoIngress {RendererRuntimeInspectorIoCommandRoute {command_id,ticket,- claim_rx: Some(claim_rx),+ first_dispatch_rx: Some(first_dispatch_rx),ingress: self.clone(),}}@@ -378,15 +404,12 @@ impl RendererInspectorIoIngress {let mut state = self.shared.state.lock();let (_, mut command) = state.lanes.claim_next(|_| true)?;command.claimed_by = Some(consumer);- if let Some(claim_tx) = command.claim_tx.take() {- let _ = claim_tx.send(RendererRuntimeInspectorIoCommandClaim::Inspector);- }Some(command)}pub(crate) fn first_dispatch_guard(&self,- command: &RendererInspectorIoCommand,+ command: &mut RendererInspectorIoCommand,) -> RendererInspectorIoFirstDispatchGuard {let lane_key = RendererDevToolsSessionLaneKey::new(command.agent_token,@@ -409,6 +432,7 @@ impl RendererInspectorIoIngress {consumer: command.claimed_by.expect("a first-dispatch guard requires a claimed IO command"),+ first_dispatch_tx: command.first_dispatch_tx.take(),}}@@ -528,8 +552,8 @@ impl std::fmt::Debug for RendererInspectorIoIngress {}fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {- if let Some(claim_tx) = command.claim_tx.take() {- let _ = claim_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled);+ if let Some(first_dispatch_tx) = command.first_dispatch_tx.take() {+ let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled);}let Some(response) = command.take_response() else {return;@@ -548,7 +572,8 @@ fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {mod tests {use super::*;use crate::{- devtools::pause::RendererInspectorPauseBridge, runtime::RendererInspectorIngressTicket,+ devtools::pause::RendererInspectorPauseBridge,+ runtime::{RendererInspectorCommandEnvelope, RendererInspectorIngressTicket},};fn ingress() -> RendererInspectorIoIngress {@@ -564,7 +589,7 @@ mod tests {) -> RendererRuntimeInspectorIoCommandRoute {ingress.enqueue_command(agent_token,- RendererInspectorCommandEnvelope::new_io(+ RendererDevToolsIoCommandEnvelope::inspector(RendererInspectorCommandEnvelope::new_io(RendererInspectorIngressTicket::new(None,session.map(str::to_owned),@@ -572,7 +597,15 @@ mod tests {),raw_json.to_owned(),None,- ),+ )),+ )+ }++ fn io_ticket(session: &str) -> RendererInspectorIngressTicket {+ RendererInspectorIngressTicket::new(+ None,+ Some(session.to_owned()),+ RendererInspectorCommandRoute::Io,)}@@ -645,9 +678,9 @@ mod tests {1,"round {round} must have one successful consumer");- let command = claimed.pop().expect("exactly one claimed command");+ let mut command = claimed.pop().expect("exactly one claimed command");assert_eq!(command.raw_json(), format!("command-{round}"));- ingress.first_dispatch_guard(&command).release();+ ingress.first_dispatch_guard(&mut command).release();drop(route);}@@ -665,17 +698,76 @@ mod tests {let _a2 = enqueue(&ingress, agent, Some("session-a"), "a2");let _b1 = enqueue(&ingress, agent, Some("session-b"), "b1");- let first = ingress.claim_for_owner().expect("first ready session");+ let mut first = ingress.claim_for_owner().expect("first ready session");assert_eq!(first.raw_json(), "a1");- let second = ingress+ let mut second = ingress.claim_for_interrupt().expect("other session must remain independently ready");assert_eq!(second.raw_json(), "b1");assert!(ingress.claim_for_pause().is_none());- ingress.first_dispatch_guard(&first).release();- let third = ingress.claim_for_pause().expect("a2 after a1 dispatch");+ ingress.first_dispatch_guard(&mut first).release();+ ingress.first_dispatch_guard(&mut second).release();+ let mut third = ingress.claim_for_pause().expect("a2 after a1 dispatch");assert_eq!(third.raw_json(), "a2");+ ingress.first_dispatch_guard(&mut third).release();+ }++ #[tokio::test]+ async fn one_io_lane_orders_inspector_performance_and_emulation_first_dispatch() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let inspector = enqueue(&ingress, agent, Some("session-mixed"), "inspector");+ let performance = ingress.enqueue_command(+ agent,+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(io_ticket("session-mixed")),+ );+ let emulation = ingress.enqueue_command(+ agent,+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled(+ io_ticket("session-mixed"),+ crate::script_execution_control::RendererScriptExecutionControl::default(),+ true,+ ),+ );++ let mut first = ingress+ .claim_for_interrupt()+ .expect("Inspector must be the first mixed IO command");+ assert_eq!(first.kind(), RendererDevToolsIoCommandKind::Inspector);+ assert!(+ ingress.claim_for_owner().is_none(),+ "Performance must not overtake an active Inspector first dispatch"+ );+ ingress.first_dispatch_guard(&mut first).release();+ assert_eq!(+ inspector.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)+ );++ let mut second = ingress+ .claim_for_owner()+ .expect("Performance must follow Inspector");+ assert_eq!(second.kind(), RendererDevToolsIoCommandKind::Performance);+ assert!(+ ingress.claim_for_pause().is_none(),+ "Emulation must not overtake an active Performance first dispatch"+ );+ ingress.first_dispatch_guard(&mut second).release();+ assert_eq!(+ performance.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)+ );++ let mut third = ingress+ .claim_for_pause()+ .expect("Emulation must follow Performance");+ assert_eq!(third.kind(), RendererDevToolsIoCommandKind::Emulation);+ ingress.first_dispatch_guard(&mut third).release();+ assert_eq!(+ emulation.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)+ );}#[tokio::test]@@ -687,19 +779,20 @@ mod tests {.collect::<Vec<_>>();let first_route = routes.remove(0);- let first = ingress+ let mut first = ingress.claim_for_interrupt().expect("the session head should be claimable");- let mut first_dispatch = ingress.first_dispatch_guard(&first);+ let mut first_dispatch = ingress.first_dispatch_guard(&mut first);+ first_dispatch.release();assert_eq!(- first_route.wait_for_claim().await,- Ok(RendererRuntimeInspectorIoCommandClaim::Inspector)+ first_route.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched));ingress.detach_session(agent, &DevToolsSessionKey::Attached("session-a".to_owned()));for (index, route) in routes.into_iter().enumerate() {assert_eq!(- route.wait_for_claim().await,+ route.wait_for_first_dispatch().await,Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),"detach must cancel queued command {}",index + 1@@ -709,7 +802,6 @@ mod tests {assert!(ingress.claim_for_interrupt().is_none());assert!(ingress.claim_for_pause().is_none());- first_dispatch.release();assert!(ingress.shared.state.lock().lanes.session_count() == 0,"the detached lane must retire after its active first dispatch releases"@@ -725,19 +817,20 @@ mod tests {let b1_route = enqueue(&ingress, agent, Some("session-b"), "b1");let b2_route = enqueue(&ingress, agent, Some("session-b"), "b2");- let active = ingress+ let mut active = ingress.claim_for_owner().expect("one session head should become active");- let mut first_dispatch = ingress.first_dispatch_guard(&active);+ let mut first_dispatch = ingress.first_dispatch_guard(&mut active);+ first_dispatch.release();assert_eq!(- a1_route.wait_for_claim().await,- Ok(RendererRuntimeInspectorIoCommandClaim::Inspector)+ a1_route.wait_for_first_dispatch().await,+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched));ingress.close("test target closed");for route in [a2_route, b1_route, b2_route] {assert_eq!(- route.wait_for_claim().await,+ route.wait_for_first_dispatch().await,Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),"close must cancel every unclaimed session command");@@ -746,7 +839,6 @@ mod tests {assert!(ingress.claim_for_interrupt().is_none());assert!(ingress.claim_for_pause().is_none());- first_dispatch.release();assert!(ingress.shared.state.lock().lanes.session_count() == 0,"the active lane must retire safely after target close"@@ -754,14 +846,14 @@ mod tests {let late = enqueue(&ingress, agent, Some("session-late"), "late");assert_eq!(- late.wait_for_claim().await,+ late.wait_for_first_dispatch().await,Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),"a closed target must reject late IO ingress");}#[test]- #[should_panic(expected = "only IO Inspector commands")]+ #[should_panic(expected = "must use the IO route")]fn main_thread_command_cannot_enter_io_ingress() {let ingress = ingress();let page_command = crate::runtime::RendererPageCommand::dispatch_runtime_protocol_message(@@ -771,6 +863,7 @@ mod tests {let crate::runtime::RendererPageCommand::Inspector(envelope) = page_command else {panic!("runtime protocol message must use an Inspector envelope");};+ let envelope = RendererDevToolsIoCommandEnvelope::inspector(envelope);let _ = ingress.enqueue_command(RendererDevToolsAgentToken::allocate(), envelope);}}diff --git a/moli-renderer-v8/src/devtools/pause/tests.rs b/moli-renderer-v8/src/devtools/pause/tests.rsindex a22241feb..9eaf02c0d 100644--- a/moli-renderer-v8/src/devtools/pause/tests.rs+++ b/moli-renderer-v8/src/devtools/pause/tests.rs@@ -54,14 +54,16 @@ fn enqueue_command() -> crate::devtools::ingress::io::RendererRuntimeInspectorIoCommandRoute {ingress.enqueue_command(agent_token,- crate::runtime::RendererInspectorCommandEnvelope::new_io(- crate::runtime::RendererInspectorIngressTicket::new(- None,- inspector_session_id,- crate::runtime::RendererInspectorCommandRoute::Io,+ crate::runtime::RendererDevToolsIoCommandEnvelope::inspector(+ crate::runtime::RendererInspectorCommandEnvelope::new_io(+ crate::runtime::RendererInspectorIngressTicket::new(+ None,+ inspector_session_id,+ crate::runtime::RendererInspectorCommandRoute::Io,+ ),+ raw_json,+ Some(response),),- raw_json,- Some(response),),)}@@ -133,10 +135,10 @@ fn step_transition_keeps_the_exact_command_cause_through_repause() {command_route.ticket().route(),RendererInspectorCommandRoute::Io);- let command = io_ingress+ let mut command = io_ingress.wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = io_ingress.first_dispatch_guard(&command);+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);assert_eq!(command.ticket(), command_route.ticket());let dispatch = bridge.begin_command_dispatch(command.command_id(),@@ -200,10 +202,10 @@ fn step_cause_ends_with_the_owner_turn_when_no_repause_occurs() {r#"{"id":43,"method":"Debugger.stepOut","params":{}}"#.to_owned(),response,);- let command = io_ingress+ let mut command = io_ingress.wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = io_ingress.first_dispatch_guard(&command);+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);let dispatch = bridge.begin_command_dispatch(command.command_id(),command.ticket(),@@ -259,10 +261,10 @@ fn failed_step_command_does_not_own_a_later_resume_transition() {r#"{"id":42,"method":"Debugger.stepOut","params":{}}"#.to_owned(),response,);- let command = io_ingress+ let mut command = io_ingress.wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = io_ingress.first_dispatch_guard(&command);+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);let dispatch = bridge.begin_command_dispatch(command.command_id(),command.ticket(),diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex fed337a27..150ed1e2e 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -402,11 +402,12 @@ pub use self::protocol_output::{};pub use self::service_worker_run::RendererServiceWorkerRunIdentity;pub use crate::devtools::command::{- RendererDevToolsMainCommandEnvelope, RendererInspectorCommandEnvelope,- RendererInspectorCommandRoute, RendererInspectorFirstDispatchLifecycle,- RendererInspectorIngressTicket,+ RendererDevToolsIoCommandEnvelope, RendererDevToolsMainCommandEnvelope,+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorFirstDispatchLifecycle, RendererInspectorIngressTicket,};pub(crate) use crate::devtools::command::{+ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,RendererDevToolsMainNestedDispatch, RendererInspectorPauseCommandEffect,};pub use crate::devtools::ingress::io::{diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex 3aa499ab1..1c8c40b1d 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -173,9 +173,28 @@ impl RendererPageHandle {&self,envelope: RendererInspectorCommandEnvelope,) -> RendererRuntimeInspectorIoCommandRoute {- self.devtools_target- .io_ref()- .enqueue_command(self.devtools_agent_token, envelope)+ self.devtools_target.io_ref().enqueue_command(+ self.devtools_agent_token,+ RendererDevToolsIoCommandEnvelope::inspector(envelope),+ )+ }++ #[doc(hidden)]+ pub fn enqueue_performance_get_metrics_io_command(+ &self,+ attachment: Option<RendererAgentAttachmentId>,+ inspector_session_id: Option<String>,+ ) -> RendererRuntimeInspectorIoCommandRoute {+ self.devtools_target.io_ref().enqueue_command(+ self.devtools_agent_token,+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(+ RendererInspectorIngressTicket::new(+ attachment,+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ ),+ )}pub fn enqueue_runtime_inspector_main_command(@@ -193,10 +212,27 @@ impl RendererPageHandle {self.devtools_target.pause_ref().is_pause_active()}- /// Publishes the DevTools IO-agent script policy without borrowing the+ /// Enqueues the DevTools IO-agent script policy without borrowing the/// owner-resident `PageVm` that may currently be executing JavaScript.- pub fn set_script_execution_disabled_from_io(&self, disabled: bool) {- self.script_execution_control.set_disabled(disabled);+ #[doc(hidden)]+ pub fn enqueue_set_script_execution_disabled_io_command(+ &self,+ attachment: Option<RendererAgentAttachmentId>,+ inspector_session_id: Option<String>,+ disabled: bool,+ ) -> RendererRuntimeInspectorIoCommandRoute {+ self.devtools_target.io_ref().enqueue_command(+ self.devtools_agent_token,+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled(+ RendererInspectorIngressTicket::new(+ attachment,+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ self.script_execution_control.clone(),+ disabled,+ ),+ )}pub fn arm_runtime_inspector_session_detach(diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex 50e3bdfbc..ec7f28188 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -20,6 +20,7 @@ use crate::{},inspector_microtasks::with_scoped_inspector_microtasks,runtime::{+ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,RendererDevToolsMainNestedDispatch, RendererOwnerReply,RendererRuntimeInspectorResponseSender, dispatch_nested_main_page_command,},@@ -223,13 +224,15 @@ impl RendererInspectorSessionExecutorLocal {}fn dispatch_io_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {- 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();+ 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();self.dispatch_io_command_to_session(command, session);}@@ -262,12 +265,14 @@ impl RendererInspectorSessionExecutorLocal {let Some(command) = self.target.io_ref().claim_for_interrupt() else {return;};- let session_key = command.ticket().session();- let session = self- .interrupt_sessions- .borrow()- .get(&(command.agent_token, session_key.clone()))- .cloned();+ 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();self.dispatch_io_command_to_session(command, session);}@@ -275,12 +280,14 @@ impl RendererInspectorSessionExecutorLocal {let Some(command) = self.target.io_ref().claim_for_owner() else {return;};- let session_key = command.ticket().session();- let session = self- .interrupt_sessions- .borrow()- .get(&(command.agent_token, session_key.clone()))- .cloned();+ 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();self.dispatch_io_command_to_session(command, session);}@@ -327,7 +334,33 @@ impl RendererInspectorSessionExecutorLocal {mut command: RendererInspectorIoCommand,session: Option<RendererInspectorSessionRoute>,) {- let mut first_dispatch = self.target.io_ref().first_dispatch_guard(&command);+ 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"+ );+ first_dispatch.release();+ return;+ }+ RendererDevToolsIoCommandKind::Emulation => {+ let RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {+ control,+ disabled,+ } = command.into_payload()+ else {+ unreachable!("Emulation IO command kind must carry an Emulation payload")+ };+ control.set_disabled(disabled);+ first_dispatch.release();+ return;+ }+ RendererDevToolsIoCommandKind::Inspector => {}+ }let Some(session) = session else {send_inspector_dispatch_error(command.take_response(),