Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(devtools): unify the renderer Main receiver
ldm0368c08753472
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex e8722e194..0199ce67e 100644--- a/moli-core/src/page/command_dispatch.rs+++ b/moli-core/src/page/command_dispatch.rs@@ -95,8 +95,20 @@ impl Page {if let Some(attachment_id) = self.renderer_agent_attachment_id {command.bind_inspector_attachment(attachment_id);}+ let pending = if self.renderer_agent_attachment_id.is_some() {+ self.handle.enqueue_protocol_command_in_inspector_session(+ command,+ self.renderer_devtools_command_session_id.clone(),+ )?+ } else {+ // CLI, embedding and other renderer-owner callers reuse the thin+ // protocol-turn capture policy, but they are not a+ // DevToolsSession receiver and must not acquire a Main ingress+ // lane that is scoped to a renderer attachment.+ self.handle.enqueue_protocol_command(command)?+ };Ok(PendingPageCommand {- pending: self.handle.enqueue_protocol_command(command)?,+ pending,renderer_agent_attachment_id: self.renderer_agent_attachment_id,})}@@ -383,6 +395,9 @@ impl PendingRuntimeInspectorCommandDispatch {RendererRuntimeInspectorMainCommandCompletion::Inspector => {Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)}+ RendererRuntimeInspectorMainCommandCompletion::Page(_) => Err(anyhow::anyhow!(+ "a Runtime Inspector command entered nested non-V8 Page dispatch"+ )),RendererRuntimeInspectorMainCommandCompletion::Canceled => {Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)}diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex 97af0fc60..5b95413d3 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -772,19 +772,17 @@ impl Page {&mut self,inspector_session_id: Option<&str>,) -> Result<bool> {- let pause_guard = self.handle.arm_runtime_inspector_session_detach();- let reply = self- .dispatch_page_command_async(RendererPageCommand::detach_runtime_inspector_session(- inspector_session_id.map(str::to_owned),- pause_guard,- ))- .await?;- expect_page_reply!(- reply,- "detach runtime inspector session page command",- "a bool reply",- RendererPageReply::Bool(detached) => Ok(detached),- )+ self.handle+ .detach_runtime_inspector_session(inspector_session_id.map(str::to_owned))?;+ if self.renderer_devtools_command_session_id.as_deref() == inspector_session_id {+ // `runtime_session_owner_slot_mut` stamps the current frontend+ // session onto the Page before command construction. Do not leave+ // a detached auxiliary session as the fallback provenance for a+ // later owner-side observation that is not itself entered through+ // a CDP session lookup.+ self.renderer_devtools_command_session_id = None;+ }+ Ok(true)}pub async fn runtime_console_messages_with_context_async(diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rsindex c3ea274a3..cc9e6a52b 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -187,6 +187,7 @@ pub struct Page {page_state: PageStateCache,handle: RendererPageHandle,renderer_agent_attachment_id: Option<RendererAgentAttachmentId>,+ renderer_devtools_command_session_id: Option<String>,page_creation_artifacts: Option<Box<RendererPageCreationArtifacts>>,}@@ -211,6 +212,7 @@ impl Page {page_state: PageStateCache::new(page_state),handle,renderer_agent_attachment_id: None,+ renderer_devtools_command_session_id: None,page_creation_artifacts: None,}}@@ -224,6 +226,7 @@ impl Page {page_state: PageStateCache::new(page_state),handle,renderer_agent_attachment_id: None,+ renderer_devtools_command_session_id: None,page_creation_artifacts: Some(Box::new(page_creation_artifacts)),}}@@ -243,6 +246,11 @@ impl Page {self.handle.devtools_agent_token()}+ #[doc(hidden)]+ pub fn set_renderer_devtools_command_session_id(&mut self, session_id: Option<String>) {+ self.renderer_devtools_command_session_id = session_id;+ }+#[doc(hidden)]pub fn renderer_agent_attachment_id(&self) -> Option<RendererAgentAttachmentId> {self.renderer_agent_attachment_iddiff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex d1fa7ac0f..6fd552c0f 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -3285,9 +3285,16 @@ impl CdpConnection {&mut self,session_id: Option<&str>,) -> Result<&mut TargetRuntimeSlot, String> {- self.target_session_owner_mut(session_id)+ let renderer_inspector_session_id =+ self.target_renderer_runtime_inspector_session_id_for_session(session_id);+ let slot = self+ .target_session_owner_mut(session_id).and_then(TargetSessionOwnerMut::into_runtime_slot_mut)- .ok_or_else(|| "NoDocumentLoaded".to_owned())+ .ok_or_else(|| "NoDocumentLoaded".to_owned())?;+ if let Some(page) = slot.loaded_page_mut() {+ page.set_renderer_devtools_command_session_id(renderer_inspector_session_id);+ }+ Ok(slot)}pub(crate) fn runtime_session_owner_slot(diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex 69c7d295f..6145adf17 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -221,7 +221,8 @@ pub use runtime::{RendererBrowserContextRuntimeOwnerAccess, RendererCaptureScreenshotReply,RendererCaptureScreenshotRequest, RendererCapturedScreenshot, RendererCommandTurnCompletion,RendererCommandTurnOutput, RendererCountEntry, RendererDedicatedWorkerTargetEvent,- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentBoxModel,+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken,+ RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex 1a1737299..058c46104 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -48,6 +48,7 @@ mod javascript_dialog;mod lifecycle_decision;mod main_document_ready_gate;mod navigation;+mod nested_main;mod owner;mod owner_deadline_index;mod owner_local;@@ -299,6 +300,7 @@ pub(super) use self::page_state::RendererPageEntry;pub use self::page_state::RendererPageRecord;pub(crate) use self::page_state::RendererPageSlotHandle;pub use self::page_state::RendererPageState;+pub(crate) use self::page_surface::RendererDevToolsMainNestedDispatch;use self::page_surface::RendererPageTable;pub use self::page_surface::RendererRuntimeInspectorMessageResponseOrder;pub use self::page_surface::{@@ -307,14 +309,14 @@ pub use self::page_surface::{RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererCaptureScreenshotReply,RendererCapturedScreenshot, RendererCommandTurnCompletion, RendererCommandTurnOutput,RendererCountEntry, RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,- RendererDevToolsAgentToken, RendererDocumentBoxModel, RendererDocumentChildNodeSnapshotEvent,- RendererDocumentChildNodeSnapshotEvents, RendererDocumentChildNodeSnapshots,- RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,- RendererDocumentIsolateAccountingDiagnostics, RendererDocumentNodeAttributesResolution,- RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,- RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,- RendererDocumentNodeTextResolution, RendererDocumentQuerySelectorNode,- RendererDocumentQuerySelectorResolution,+ RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,+ RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,+ RendererDocumentChildNodeSnapshots, RendererDocumentFrontendNodeIdsResolution,+ RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,+ RendererDocumentNodeAttributesResolution, RendererDocumentNodeClientRect,+ RendererDocumentNodeGeometry, RendererDocumentNodePropertyResolution,+ RendererDocumentNodeReference, RendererDocumentNodeTextResolution,+ RendererDocumentQuerySelectorNode, RendererDocumentQuerySelectorResolution,RendererDocumentQuerySelectorWithChildNodeSnapshotEvents,RendererDocumentSourcedSameDocumentNavigation,RendererDocumentSourcedTopLevelLocationNavigation, RendererDomAttributeMutation,@@ -442,6 +444,7 @@ pub(crate) use crate::service_worker_runtime::{ServiceWorkerSyncRegistrationResult, ServiceWorkerVersionId, ServiceWorkerWorkerMessage,service_worker_exposed_client_id,};+pub(crate) use nested_main::dispatch_nested_main_page_command;static NEXT_RENDERER_OWNER_LOCAL_HOST_ID: AtomicU64 = AtomicU64::new(1);diff --git a/moli-renderer-v8/src/runtime/nested_main.rs b/moli-renderer-v8/src/runtime/nested_main.rsnew file mode 100644index 000000000..850499623--- /dev/null+++ b/moli-renderer-v8/src/runtime/nested_main.rs@@ -0,0 +1,85 @@+use std::{cell::RefCell, marker::PhantomData, ptr::NonNull, rc::Rc};++use anyhow::{Result, anyhow};++use super::{+ RendererCommandTurnOutput, RendererPageCommand, RendererPageReply,+ RendererRuntimeCommandOutput, owner_local_store::RendererPageLocalEntry, page_vm::PageVm,+};+use crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard;++#[derive(Clone)]+struct ActiveNestedMainPage {+ page_vm: NonNull<PageVm>,+ entry_slot: super::RendererPageSlotHandle,+}++thread_local! {+ static ACTIVE_NESTED_MAIN_PAGE: RefCell<Option<ActiveNestedMainPage>> = const {+ RefCell::new(None)+ };+}++/// Dynamic owner-stack binding used by Chromium-style nested Main dispatch.+///+/// V8 invokes its pause loop synchronously on the renderer owner thread. The+/// outer Page command remains suspended on that same stack, so the pointer is+/// valid only for this guard's lifetime and is never sent to another thread.+pub(super) struct ActiveNestedMainPageGuard {+ previous: Option<ActiveNestedMainPage>,+ _owner_local: PhantomData<Rc<()>>,+}++impl Drop for ActiveNestedMainPageGuard {+ fn drop(&mut self) {+ ACTIVE_NESTED_MAIN_PAGE.with(|active| {+ *active.borrow_mut() = self.previous.take();+ });+ }+}++pub(super) fn bind_active_nested_main_page(+ entry: &mut RendererPageLocalEntry,+) -> ActiveNestedMainPageGuard {+ let active_page = ActiveNestedMainPage {+ page_vm: NonNull::from(entry.page_vm_mut()),+ entry_slot: entry.slot.clone(),+ };+ let previous = ACTIVE_NESTED_MAIN_PAGE.with(|active| active.borrow_mut().replace(active_page));+ ActiveNestedMainPageGuard {+ previous,+ _owner_local: PhantomData,+ }+}++pub(crate) fn dispatch_nested_main_page_command(+ command: RendererPageCommand,+ mut first_dispatch: RendererInspectorMainFirstDispatchGuard,+) -> Result<RendererCommandTurnOutput> {+ let active = ACTIVE_NESTED_MAIN_PAGE+ .try_with(|active| active.borrow().clone())+ .ok()+ .flatten()+ .ok_or_else(|| anyhow!("nested Main receiver has no active Page owner stack"))?;++ // Release the per-session lane at the actual agent dispatch boundary, not+ // when the pause loop merely claims the queued command.+ let _post_dispatch_wake = first_dispatch.release_for_dispatch();+ // SAFETY: `bind_active_nested_main_page` installs this pointer immediately+ // around the owner-local Page dispatch that can enter V8. A normal debugger+ // pause synchronously suspends that outer dispatch, and this callback runs+ // on the same owner thread before the guard is dropped. Instrumentation+ // pauses never claim Main work. The nested borrow ends before V8 resumes+ // the outer Page call.+ let page_vm = unsafe { active.page_vm.as_ptr().as_mut() }+ .ok_or_else(|| anyhow!("nested Main Page pointer was unexpectedly null"))?;+ let reply: RendererPageReply = page_vm.dispatch_renderer_page_command(command)?;+ let page_state = active.entry_slot.active_page_state()?;+ RendererCommandTurnOutput::new(+ reply,+ page_state,+ RendererRuntimeCommandOutput::default(),+ None,+ None,+ )+}diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex e2514c596..597493fc4 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -240,6 +240,14 @@ pub enum RendererOwnerCommand {token: RendererPageToken,command: RendererPageCommand,},+ /// Renderer-side cleanup after the browser/protocol owner has already+ /// disconnected a DevTools session and closed both of its ingress lanes.+ /// This is lifecycle work, not another frontend Inspector command.+ FinalizeRuntimeInspectorSessionDetach {+ token: RendererPageToken,+ inspector_session_id: Option<String>,+ pause_guard: RendererRuntimeInspectorSessionDetachGuard,+ },WaitForNetworkIdle {token: RendererPageToken,timeout_ms: u64,@@ -280,6 +288,7 @@ pub enum RendererOwnerReply {PreparedRendererDocumentCommitConfigurationUpdated,PreparedRendererDocumentCanceled,AsyncPageCommandRan(Box<RendererCommandTurnOutput>),+ RuntimeInspectorSessionDetachFinalized(bool),PageRemoved,TestingCurrentPageState(Arc<RendererPageState>),TestingRendererPageView(RendererPageView),@@ -2340,6 +2349,41 @@ impl RendererOwnerHandle {},))}+ RendererOwnerCommand::FinalizeRuntimeInspectorSessionDetach {+ token,+ inspector_session_id,+ pause_guard: _pause_guard,+ } => {+ let mut entry = match checkout_entry_for_owner_turn_on_bound_owner_local_store(+ token,+ ) {+ Ok(entry) => entry,+ Err(+ RendererPageLocalEntryCheckoutError::Retired+ | RendererPageLocalEntryCheckoutError::Missing,+ ) => {+ return Ok(RendererOwnerReply::RuntimeInspectorSessionDetachFinalized(+ false,+ ))+ .into();+ }+ Err(RendererPageLocalEntryCheckoutError::Busy) => {+ return Err(anyhow!(+ "renderer page {} remained checked out while finalizing Inspector session detach",+ token.page_id.as_u64()+ ))+ .into();+ }+ };+ let detached = entry+ .page_vm_mut()+ .detach_runtime_inspector_session(inspector_session_id.as_deref());+ restore_entry_after_command_on_bound_owner_local_store(token, entry);+ Ok(RendererOwnerReply::RuntimeInspectorSessionDetachFinalized(+ detached,+ ))+ .into()+ }RendererOwnerCommand::WaitForNetworkIdle {token,timeout_ms,@@ -4692,6 +4736,16 @@ impl RendererOwnerHandle {command: RendererPageCommand,capture_policy: super::RendererPageStateCapturePolicy,) -> RenderRuntimeDispatchOutcome {+ if let RendererPageCommand::DevToolsMain(envelope) = command {+ let (mut first_dispatch, command) = envelope.into_owner_parts();+ // Crossing into the Page owner's command dispatcher is the Main+ // receiver's first-dispatch boundary. Unwrap here so the existing+ // typed continuations (promise awaits, navigation followers and+ // wait commands) keep seeing the concrete command rather than a+ // transport envelope.+ let _post_dispatch_wake = first_dispatch.release_for_dispatch();+ return Box::pin(self.run_live_page_command_turn(token, command, capture_policy)).await;+ }match command {RendererPageCommand::WaitForSelector {selector,@@ -6208,7 +6262,7 @@ impl RendererOwnerHandle {command_admission_output_predecessor,turn: Box::new(RenderRuntimeTurn::RunLivePageCommand {token,- command: RendererPageCommand::from_inspector_envelope(envelope),+ command: RendererPageCommand::DevToolsMain(envelope),capture_policy,}),}diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex 63212a096..b32674887 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -204,6 +204,42 @@ impl RendererPageHandle {RendererRuntimeInspectorSessionDetachGuard::new(self.inspector_pause_bridge.clone())}+ /// Disconnects one frontend Inspector route without waiting for the Page+ /// owner to return from JavaScript.+ ///+ /// Chromium acknowledges `Target.detachFromTarget` after dropping the+ /// browser-side DevToolsSession pipes; destruction of the renderer-side+ /// V8InspectorSession is a subsequent Main-thread task. Mirror that+ /// boundary here: cancel both ingress lanes synchronously, then enqueue an+ /// owner-only cleanup whose reply is deliberately detached. The retained+ /// pause guard also releases a nested debugger loop so the cleanup can+ /// eventually reach the owner.+ pub fn detach_runtime_inspector_session(+ &self,+ inspector_session_id: Option<String>,+ ) -> anyhow::Result<()> {+ let session = DevToolsSessionKey::from_wire_session_id(+ inspector_session_id+ .as_deref()+ .filter(|session_id| !session_id.is_empty()),+ );+ self.inspector_main_ingress+ .detach_session(self.devtools_agent_token, &session);+ self.inspector_io_ingress+ .detach_session(self.devtools_agent_token, &session);++ let pause_guard = self.arm_runtime_inspector_session_detach();+ let reply_rx = self.render_runtime.enqueue(+ RendererOwnerCommand::FinalizeRuntimeInspectorSessionDetach {+ token: self.token(),+ inspector_session_id,+ pause_guard,+ },+ )?;+ drop(reply_rx);+ Ok(())+ }+pub fn enqueue_async_command(&self,command: RendererPageCommand,@@ -211,6 +247,8 @@ impl RendererPageHandle {self.enqueue_async_command_with_capture_policy(command,RendererPageStateCapturePolicy::FullReport,+ false,+ None,)}@@ -228,6 +266,22 @@ impl RendererPageHandle {self.enqueue_async_command_with_capture_policy(command,RendererPageStateCapturePolicy::ProtocolTurn,+ false,+ None,+ )+ }++ #[doc(hidden)]+ pub fn enqueue_protocol_command_in_inspector_session(+ &self,+ command: RendererPageCommand,+ inspector_session_id: Option<String>,+ ) -> anyhow::Result<RendererPageCommandPending> {+ self.enqueue_async_command_with_capture_policy(+ command,+ RendererPageStateCapturePolicy::ProtocolTurn,+ true,+ inspector_session_id,)}@@ -235,6 +289,8 @@ impl RendererPageHandle {&self,command: RendererPageCommand,capture_policy: RendererPageStateCapturePolicy,+ route_protocol_main_receiver: bool,+ inspector_session_id: Option<String>,) -> anyhow::Result<RendererPageCommandPending> {let javascript_dialog_watch = command.interruptible_by_javascript_dialog()@@ -249,6 +305,19 @@ impl RendererPageHandle {stage = "page_handle_command_dispatch",);}+ if route_protocol_main_receiver {+ let route = self.inspector_main_ingress.enqueue_protocol_page_command(+ self.token(),+ self.devtools_agent_token,+ command,+ inspector_session_id,+ capture_policy,+ );+ return Ok(RendererPageCommandPending {+ dispatch: RendererPageCommandPendingDispatch::InspectorMain(Box::new(route)),+ javascript_dialog_watch,+ });+ }let command = match command {RendererPageCommand::Inspector(envelope) => {let route = self.inspector_main_ingress.enqueue_owner_command(@@ -405,6 +474,7 @@ impl RendererPageCommandPending {RendererPageCommandPendingDispatch::InspectorMain(route) => {match route.wait_for_completion().await? {RendererRuntimeInspectorMainCommandCompletion::Owner(output) => Ok(*output),+ RendererRuntimeInspectorMainCommandCompletion::Page(output) => Ok(*output),RendererRuntimeInspectorMainCommandCompletion::Inspector => Err(anyhow!("an owner-only Inspector Main command entered nested dispatch")),diff --git a/moli-renderer-v8/src/runtime/owner_local_store.rs b/moli-renderer-v8/src/runtime/owner_local_store.rsindex c17021bad..e554d2d91 100644--- a/moli-renderer-v8/src/runtime/owner_local_store.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store.rs@@ -4187,6 +4187,7 @@ impl RendererOwnerLocalStore {.document_replacement_lifecycle_action_snapshot();let command_epoch = Self::advance_command_epoch(entry);let slot = entry.slot.clone();+ let _nested_main_page = super::nested_main::bind_active_nested_main_page(entry);let reply = slot.dispatch_async_owned(command_epoch, entry.page_vm_mut(), command).await;diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rsindex 7c7e0ce42..d11dae45b 100644--- a/moli-renderer-v8/src/runtime/page_commands.rs+++ b/moli-renderer-v8/src/runtime/page_commands.rs@@ -8,7 +8,20 @@ impl PageVm {) -> Result<RendererPageReply> {let throttling_started =renderer_page_command_uses_cpu_throttling(&command).then(std::time::Instant::now);- let result = match command {+ let result = self.dispatch_renderer_page_command(command);+ self.apply_cpu_throttling_delay_after_page_command(throttling_started)+ .await;+ result+ }++ pub(in crate::runtime) fn dispatch_renderer_page_command(+ &mut self,+ command: RendererPageCommand,+ ) -> Result<RendererPageReply> {+ match command {+ RendererPageCommand::DevToolsMain(_) => Err(anyhow!(+ "the Page owner must unwrap a Main DevTools transport envelope before agent dispatch"+ )),RendererPageCommand::Inspector(command) => {self.dispatch_renderer_inspector_command(command)}@@ -1110,10 +1123,7 @@ impl PageVm {RendererPageCommand::PanicForTesting => {panic!("renderer page command panicked for testing")}- };- self.apply_cpu_throttling_delay_after_page_command(throttling_started)- .await;- result+ }}fn dispatch_renderer_inspector_command(@@ -1362,6 +1372,9 @@ impl PageVm {}fn renderer_page_command_uses_cpu_throttling(command: &RendererPageCommand) -> bool {+ if let RendererPageCommand::DevToolsMain(envelope) = command {+ return renderer_page_command_uses_cpu_throttling(envelope.payload());+ }if let RendererPageCommand::Inspector(envelope) = command {return envelope.uses_cpu_throttling();}diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex 87c6b5739..ce1814f1f 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -3653,10 +3653,144 @@ pub struct RendererInspectorCommandEnvelope {pause_effect: RendererInspectorPauseCommandEffect,main_dispatch_boundary: RendererInspectorMainDispatchBoundary,payload: RendererInspectorCommandPayload,- main_ingress_first_dispatch:+}++/// One command delivered by the renderer's Main DevTools receiver.+///+/// Unlike `RendererInspectorCommandEnvelope`, this envelope is deliberately+/// agent-neutral: protocol commands that ultimately need the renderer Page,+/// DOM, CSS, Accessibility, or V8 agents all enter the same Main receiver.+/// The boxed payload keeps that admission boundary structural without adding+/// a second allowlist of `RendererPageCommand` variants.+#[doc(hidden)]+pub struct RendererDevToolsMainCommandEnvelope {+ ticket: RendererInspectorIngressTicket,+ payload: Box<RendererPageCommand>,+ first_dispatch:Option<crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard>,}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererDevToolsMainNestedDispatch {+ InspectorSession,+ PageAgent,+ OwnerOnly,+}++impl RendererDevToolsMainCommandEnvelope {+ pub(crate) fn from_protocol_command(command: RendererPageCommand) -> Self {+ Self::from_protocol_command_in_session(command, None)+ }++ pub(crate) fn from_protocol_command_in_session(+ command: RendererPageCommand,+ inspector_session_id: Option<String>,+ ) -> Self {+ let ticket = match &command {+ RendererPageCommand::Inspector(envelope) => envelope.ticket().clone(),+ RendererPageCommand::DevToolsMain(_) => {+ panic!("a Main DevTools command cannot be enveloped twice")+ }+ _ => RendererInspectorIngressTicket::new(+ None,+ inspector_session_id,+ RendererInspectorCommandRoute::MainThread,+ ),+ };+ Self {+ ticket,+ payload: Box::new(command),+ first_dispatch: None,+ }+ }++ pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {+ &self.ticket+ }++ pub(crate) fn payload(&self) -> &RendererPageCommand {+ self.payload.as_ref()+ }++ pub(crate) fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {+ RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch+ }++ pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {+ match self.payload.as_ref() {+ RendererPageCommand::Inspector(envelope)+ if envelope.can_dispatch_at_nested_inspector_session_boundary() =>+ {+ RendererDevToolsMainNestedDispatch::InspectorSession+ }+ RendererPageCommand::Inspector(_) => RendererDevToolsMainNestedDispatch::OwnerOnly,+ RendererPageCommand::DevToolsMain(_) => {+ unreachable!("a Main DevTools command cannot contain another Main envelope")+ }+ _ => RendererDevToolsMainNestedDispatch::PageAgent,+ }+ }++ pub(crate) fn inspector_envelope(&self) -> Option<&RendererInspectorCommandEnvelope> {+ match self.payload.as_ref() {+ RendererPageCommand::Inspector(envelope) => Some(envelope),+ _ => None,+ }+ }++ pub(crate) fn into_nested_inspector_envelope(self) -> RendererInspectorCommandEnvelope {+ assert_eq!(+ self.nested_dispatch(),+ RendererDevToolsMainNestedDispatch::InspectorSession,+ "only a session-boundary Inspector command may enter nested V8 dispatch"+ );+ let RendererPageCommand::Inspector(envelope) = *self.payload else {+ unreachable!("nested Inspector dispatch kind requires an Inspector payload")+ };+ envelope+ }++ pub(crate) fn into_inspector_envelope(self) -> Option<RendererInspectorCommandEnvelope> {+ match *self.payload {+ RendererPageCommand::Inspector(envelope) => Some(envelope),+ _ => None,+ }+ }++ pub(crate) fn into_nested_page_command(self) -> RendererPageCommand {+ assert_eq!(+ self.nested_dispatch(),+ RendererDevToolsMainNestedDispatch::PageAgent,+ "only a non-V8 Main agent command may enter nested Page dispatch"+ );+ *self.payload+ }++ pub(crate) fn bind_first_dispatch(+ &mut self,+ first_dispatch: crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard,+ ) {+ assert!(+ self.first_dispatch.is_none(),+ "a Main DevTools envelope can own only one first-dispatch permit"+ );+ self.first_dispatch = Some(first_dispatch);+ }++ pub(crate) fn into_owner_parts(+ mut self,+ ) -> (+ crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard,+ RendererPageCommand,+ ) {+ let first_dispatch = self+ .first_dispatch+ .take()+ .expect("an owner-dispatched Main DevTools command must retain its lane permit");+ (first_dispatch, *self.payload)+ }+}+enum RendererInspectorCommandPayload {MainThread(RendererInspectorPageCommand),Io {@@ -3677,7 +3811,6 @@ impl RendererInspectorCommandEnvelope {pause_effect: RendererInspectorPauseCommandEffect::None,main_dispatch_boundary: RendererInspectorMainDispatchBoundary::PageOwner,payload: RendererInspectorCommandPayload::MainThread(command),- main_ingress_first_dispatch: None,}}@@ -3719,7 +3852,6 @@ impl RendererInspectorCommandEnvelope {pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),main_dispatch_boundary,payload: RendererInspectorCommandPayload::MainThread(command),- main_ingress_first_dispatch: None,}}@@ -3741,7 +3873,6 @@ impl RendererInspectorCommandEnvelope {pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),main_dispatch_boundary: RendererInspectorMainDispatchBoundary::InspectorSession,payload: RendererInspectorCommandPayload::Io { raw_json, response },- main_ingress_first_dispatch: None,}}@@ -3766,28 +3897,14 @@ impl RendererInspectorCommandEnvelope {}pub(crate) fn into_main_thread_parts(- mut self,+ self,) -> (RendererInspectorIngressTicket, RendererInspectorPageCommand) {- if let Some(mut first_dispatch) = self.main_ingress_first_dispatch.take() {- first_dispatch.release();- }let RendererInspectorCommandPayload::MainThread(command) = self.payload else {panic!("an Inspector IO envelope cannot enter Page owner dispatch");};(self.ticket, command)}- pub(crate) fn bind_main_ingress_first_dispatch(- &mut self,- first_dispatch: crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard,- ) {- assert!(- self.main_ingress_first_dispatch.is_none(),- "a Main Inspector envelope can own only one ingress dispatch permit"- );- self.main_ingress_first_dispatch = Some(first_dispatch);- }-fn main_thread_payload(&self) -> &RendererInspectorPageCommand {let RendererInspectorCommandPayload::MainThread(command) = &self.payload else {panic!("an Inspector IO envelope cannot enter Page owner dispatch");@@ -3842,10 +3959,6 @@ impl RendererInspectorCommandEnvelope {String,RendererRuntimeInspectorResponseSender,) {- assert!(- self.main_ingress_first_dispatch.is_none(),- "a direct nested Main dispatch must keep its first-dispatch guard outside the envelope"- );assert_eq!(self.main_dispatch_boundary,RendererInspectorMainDispatchBoundary::InspectorSession,@@ -3982,28 +4095,19 @@ fn main_protocol_can_dispatch_at_inspector_session_boundary(return false;}- if matches!(method, Some("Runtime.compileScript"))- && params.is_some_and(|params| {- params.contains_key("contextId") || params.contains_key("executionContextId")- })- || matches!(method, Some("Runtime.runScript"))- && params.is_some_and(|params| params.contains_key("executionContextId"))- {- return false;- }-match owner_context_resolution_action {- // A default-world evaluate needs no renderer context-id rewrite. It is- // the useful Chromium-style nested Main case while JavaScript is- // paused. Explicit context targeting remains an owner operation.- Some("evaluate") => !params.is_some_and(|params| {- params.contains_key("contextId") || params.contains_key("executionContextId")- }),- // An object/unique-context target is already complete. A missing or- // numeric executionContextId requires PageVm to choose/rewrite it.+ // Page.createIsolatedWorld and Runtime.executionContextCreated expose+ // V8 Inspector's native context id. Context-targeted commands can+ // therefore enter Chromium's nested Main receiver without borrowing+ // PageVm; an unknown or retired id is rejected by V8 itself.+ Some("evaluate") => true,+ // A target supplied by object, unique context, or numeric Inspector+ // context is complete. Only the target-less compatibility form needs+ // PageVm to insert Moli's default execution context.Some("callFunctionOn") => params.is_some_and(|params| {- !params.contains_key("executionContextId")- && (params.contains_key("objectId") || params.contains_key("uniqueContextId"))+ params.contains_key("objectId")+ || params.contains_key("uniqueContextId")+ || params.contains_key("executionContextId")}),Some(_) => false,None => true,@@ -4103,6 +4207,8 @@ pub(crate) enum RendererInspectorPageCommand {#[non_exhaustive]pub enum RendererPageCommand {+ #[doc(hidden)]+ DevToolsMain(RendererDevToolsMainCommandEnvelope),Inspector(RendererInspectorCommandEnvelope),EvaluateExpression {expression: String,@@ -4627,10 +4733,6 @@ pub enum RendererRuntimeRemoteObjectResolution {}impl RendererPageCommand {- pub(crate) fn from_inspector_envelope(envelope: RendererInspectorCommandEnvelope) -> Self {- Self::Inspector(envelope)- }-fn inspector_command(inspector_session_id: Option<String>,command: RendererInspectorPageCommand,diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex 100796ec5..3f12d2646 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -5,7 +5,10 @@ use super::context_registry::{};use crate::{inspector_microtasks::with_scoped_inspector_microtasks,- runtime::RendererRuntimeInspectorResponseSender,+ runtime::{+ RendererDevToolsMainNestedDispatch, RendererOwnerReply,+ RendererRuntimeInspectorResponseSender, dispatch_nested_main_page_command,+ },script_vm::{inspector_io::{RendererInspectorInterruptTarget, RendererInspectorIoCommand,@@ -179,31 +182,42 @@ impl RendererInspectorSessionExecutorLocal {}fn run_message_loop_on_pause(&self, context_group_id: i32) {- if !self.bridge.enter_pause() {+ let Some(pause_loop_policy) = self.bridge.enter_pause() else {return;- }+ };let mut prefer_main = true;while let Some(command) = self.bridge.wait_for_pause_work(|| {- let command = if prefer_main {- self.main_ingress+ let command = match pause_loop_policy {+ crate::script_vm::inspector_pause::RendererInspectorPauseLoopPolicy::IoOnly => {+ self.io_ingress+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Io)+ }+ crate::script_vm::inspector_pause::RendererInspectorPauseLoopPolicy::MainAndIo+ if prefer_main => self+ .main_ingress.claim_for_pause().map(RendererInspectorNestedCommand::Main).or_else(|| {self.io_ingress.claim_for_pause().map(RendererInspectorNestedCommand::Io)- })- } else {- self.io_ingress- .claim_for_pause()- .map(RendererInspectorNestedCommand::Io)- .or_else(|| {- self.main_ingress- .claim_for_pause()- .map(RendererInspectorNestedCommand::Main)- })+ }),+ crate::script_vm::inspector_pause::RendererInspectorPauseLoopPolicy::MainAndIo => {+ self.io_ingress+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Io)+ .or_else(|| {+ self.main_ingress+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Main)+ })+ }};- if command.is_some() {+ if command.is_some()+ && pause_loop_policy+ == crate::script_vm::inspector_pause::RendererInspectorPauseLoopPolicy::MainAndIo+ {prefer_main = !prefer_main;}command@@ -232,6 +246,20 @@ impl RendererInspectorSessionExecutorLocal {}fn dispatch_main_command(&self, context_group_id: i32, command: RendererInspectorMainCommand) {+ match command.nested_dispatch() {+ RendererDevToolsMainNestedDispatch::PageAgent => {+ let first_dispatch = self.main_ingress.first_dispatch_guard(&command);+ let (page_command, reply_tx) = command.into_nested_page_parts();+ let result = dispatch_nested_main_page_command(page_command, first_dispatch)+ .map(|output| RendererOwnerReply::AsyncPageCommandRan(Box::new(output)));+ let _ = reply_tx.send(result);+ return;+ }+ RendererDevToolsMainNestedDispatch::InspectorSession => {}+ RendererDevToolsMainNestedDispatch::OwnerOnly => {+ unreachable!("an owner-only Main command cannot be claimed by the pause loop")+ }+ }let session_key = command.ticket().session().clone();let session = self.sessionsdiff --git a/moli-renderer-v8/src/script_vm/inspector_main.rs b/moli-renderer-v8/src/script_vm/inspector_main.rsindex 5616bd126..e77ae990a 100644--- a/moli-renderer-v8/src/script_vm/inspector_main.rs+++ b/moli-renderer-v8/src/script_vm/inspector_main.rs@@ -13,8 +13,10 @@ use serde_json::json;use crate::{render_runtime::RenderRuntimeHandle,runtime::{- RendererCommandTurnOutput, RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,- RendererInspectorIngressTicket, RendererInspectorPauseCommandEffect, RendererOwnerReply,+ RendererCommandTurnOutput, RendererDevToolsMainCommandEnvelope,+ RendererDevToolsMainNestedDispatch, RendererInspectorCommandEnvelope,+ RendererInspectorCommandRoute, RendererInspectorIngressTicket,+ RendererInspectorPauseCommandEffect, RendererOwnerReply, RendererPageCommand,RendererPageStateCapturePolicy, RendererPageToken, RendererRuntimeInspectorResponseSender,},script_vm::{@@ -33,12 +35,14 @@ pub(crate) enum RendererInspectorMainCommandConsumer {enum RendererInspectorMainCommandClaim {Owner,Inspector,+ Page,Canceled,}pub enum RendererRuntimeInspectorMainCommandCompletion {Owner(Box<RendererCommandTurnOutput>),Inspector,+ Page(Box<RendererCommandTurnOutput>),Canceled,}@@ -47,7 +51,7 @@ pub(crate) struct RendererInspectorMainCommand {page_token: RendererPageToken,pub(crate) agent_token: RendererDevToolsAgentToken,capture_policy: RendererPageStateCapturePolicy,- envelope: RendererInspectorCommandEnvelope,+ envelope: RendererDevToolsMainCommandEnvelope,claim_tx: Option<tokio::sync::oneshot::Sender<RendererInspectorMainCommandClaim>>,owner_reply_tx: Option<tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>>,claimed_by: Option<RendererInspectorMainCommandConsumer>,@@ -70,15 +74,28 @@ impl RendererInspectorMainCommand {#[cfg(test)]pub(crate) fn raw_json(&self) -> &str {- self.envelope.main_protocol_raw_json()+ self.envelope+ .inspector_envelope()+ .expect("a raw Inspector message requires an Inspector payload")+ .main_protocol_raw_json()}pub(crate) fn response(&self) -> &RendererRuntimeInspectorResponseSender {- self.envelope.main_protocol_response()+ self.envelope+ .inspector_envelope()+ .expect("an Inspector response requires an Inspector payload")+ .main_protocol_response()}pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {- self.envelope.pause_effect()+ self.envelope+ .inspector_envelope()+ .expect("an Inspector pause effect requires an Inspector payload")+ .pause_effect()+ }++ pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {+ self.envelope.nested_dispatch()}pub(crate) fn into_protocol_parts(@@ -88,7 +105,23 @@ impl RendererInspectorMainCommand {String,RendererRuntimeInspectorResponseSender,) {- self.envelope.into_main_protocol_parts()+ self.envelope+ .into_nested_inspector_envelope()+ .into_main_protocol_parts()+ }++ pub(crate) fn into_nested_page_parts(+ mut self,+ ) -> (+ RendererPageCommand,+ tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>,+ ) {+ let command = self.envelope.into_nested_page_command();+ let reply_tx = self+ .owner_reply_tx+ .take()+ .expect("a nested Page command must retain its completion sender");+ (command, reply_tx)}#[cfg(test)]@@ -141,6 +174,22 @@ impl RendererRuntimeInspectorMainCommandRoute {RendererInspectorMainCommandClaim::Inspector => {Ok(RendererRuntimeInspectorMainCommandCompletion::Inspector)}+ RendererInspectorMainCommandClaim::Page => {+ let reply = self+ .owner_reply_rx+ .take()+ .expect("a pause-claimed Page command must retain its reply receiver")+ .await+ .map_err(|_| anyhow::anyhow!("nested Main Page reply channel closed"))??;+ match reply {+ RendererOwnerReply::AsyncPageCommandRan(output) => {+ Ok(RendererRuntimeInspectorMainCommandCompletion::Page(output))+ }+ _ => Err(anyhow::anyhow!(+ "nested Main Page dispatch returned an unexpected renderer reply"+ )),+ }+ }RendererInspectorMainCommandClaim::Canceled => {Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)}@@ -213,7 +262,7 @@ pub(crate) struct RendererInspectorMainPostDispatchWakeGuard {pub(crate) struct RendererInspectorMainOwnerDispatch {page_token: RendererPageToken,capture_policy: RendererPageStateCapturePolicy,- envelope: RendererInspectorCommandEnvelope,+ envelope: RendererDevToolsMainCommandEnvelope,reply_tx: tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>,}@@ -223,7 +272,7 @@ impl RendererInspectorMainOwnerDispatch {) -> (RendererPageToken,RendererPageStateCapturePolicy,- RendererInspectorCommandEnvelope,+ RendererDevToolsMainCommandEnvelope,tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>,) {(@@ -311,7 +360,9 @@ impl RendererInspectorMainIngress {self.enqueue_with_policy(page_token,agent_token,- envelope,+ RendererDevToolsMainCommandEnvelope::from_protocol_command(+ RendererPageCommand::Inspector(envelope),+ ),RendererPageStateCapturePolicy::ProtocolTurn,)}@@ -323,20 +374,46 @@ impl RendererInspectorMainIngress {envelope: RendererInspectorCommandEnvelope,capture_policy: RendererPageStateCapturePolicy,) -> RendererRuntimeInspectorMainCommandRoute {- self.enqueue_with_policy(page_token, agent_token, envelope, capture_policy)+ self.enqueue_with_policy(+ page_token,+ agent_token,+ RendererDevToolsMainCommandEnvelope::from_protocol_command(+ RendererPageCommand::Inspector(envelope),+ ),+ capture_policy,+ )+ }++ pub(crate) fn enqueue_protocol_page_command(+ &self,+ page_token: RendererPageToken,+ agent_token: RendererDevToolsAgentToken,+ command: RendererPageCommand,+ inspector_session_id: Option<String>,+ capture_policy: RendererPageStateCapturePolicy,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ self.enqueue_with_policy(+ page_token,+ agent_token,+ RendererDevToolsMainCommandEnvelope::from_protocol_command_in_session(+ command,+ inspector_session_id,+ ),+ capture_policy,+ )}fn enqueue_with_policy(&self,page_token: RendererPageToken,agent_token: RendererDevToolsAgentToken,- envelope: RendererInspectorCommandEnvelope,+ envelope: RendererDevToolsMainCommandEnvelope,capture_policy: RendererPageStateCapturePolicy,) -> RendererRuntimeInspectorMainCommandRoute {assert_eq!(envelope.ticket().route(),RendererInspectorCommandRoute::MainThread,- "only MainThread Inspector commands may enter RendererInspectorMainIngress"+ "only MainThread DevTools commands may enter RendererInspectorMainIngress");let ticket = envelope.ticket().clone();let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();@@ -429,9 +506,7 @@ impl RendererInspectorMainIngress {.get(&lane_key).and_then(|lane| lane.queued.front()).is_some_and(|command| {- !command- .envelope- .can_dispatch_at_nested_inspector_session_boundary()+ command.nested_dispatch() == RendererDevToolsMainNestedDispatch::OwnerOnly});if pause_dispatch_blocked {state.ready_sessions.push_back(lane_key);@@ -455,12 +530,24 @@ impl RendererInspectorMainIngress {RendererInspectorMainCommandClaim::Owner}RendererInspectorMainCommandConsumer::Pause => {- RendererInspectorMainCommandClaim::Inspector+ match command.nested_dispatch() {+ RendererDevToolsMainNestedDispatch::InspectorSession => {+ RendererInspectorMainCommandClaim::Inspector+ }+ RendererDevToolsMainNestedDispatch::PageAgent => {+ RendererInspectorMainCommandClaim::Page+ }+ RendererDevToolsMainNestedDispatch::OwnerOnly => {+ unreachable!("owner-only commands are skipped by pause claim")+ }+ }}};let _ = claim_tx.send(claim);}- if consumer == RendererInspectorMainCommandConsumer::Pause {+ if consumer == RendererInspectorMainCommandConsumer::Pause+ && command.nested_dispatch() == RendererDevToolsMainNestedDispatch::InspectorSession+ {command.owner_reply_tx.take();}return Some(command);@@ -513,7 +600,7 @@ impl RendererInspectorMainIngress {owner_reply_tx,..} = command;- envelope.bind_main_ingress_first_dispatch(first_dispatch);+ envelope.bind_first_dispatch(first_dispatch);RendererInspectorMainOwnerDispatch {page_token,capture_policy,@@ -694,6 +781,9 @@ fn fail_main_command(command: RendererInspectorMainCommand, message: &str) {if let Some(owner_reply_tx) = owner_reply_tx {let _ = owner_reply_tx.send(Err(anyhow::anyhow!(message.to_owned())));}+ let Some(envelope) = envelope.into_inspector_envelope() else {+ return;+ };if !envelope.is_main_protocol_command_with_deferred_response() {return;}@@ -830,8 +920,109 @@ mod tests {assert!(third.raw_json().contains(r#""a2""#));}+ #[tokio::test]+ async fn detach_rejects_late_main_work_until_active_first_dispatch_retires() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let _active_route = enqueue(+ &ingress,+ agent,+ Some("session-detaching"),+ r#"{"id":1,"method":"Runtime.getProperties","params":{"objectId":"active"}}"#,+ );+ let queued_route = enqueue(+ &ingress,+ agent,+ Some("session-detaching"),+ r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"queued"}}"#,+ );+ let active = ingress+ .claim_for_owner()+ .expect("the session head should become active");+ let mut first_dispatch = ingress.first_dispatch_guard(&active);++ ingress.detach_session(+ agent,+ &DevToolsSessionKey::Attached("session-detaching".to_owned()),+ );+ assert!(matches!(+ queued_route.wait_for_completion().await,+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)+ ));++ let late_route = enqueue(+ &ingress,+ agent,+ Some("session-detaching"),+ r#"{"id":3,"method":"Runtime.getProperties","params":{"objectId":"late"}}"#,+ );+ assert!(matches!(+ late_route.wait_for_completion().await,+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)+ ));++ first_dispatch.release();+ assert!(+ ingress.shared.state.lock().sessions.is_empty(),+ "the detached lane must retire after its active first dispatch releases"+ );++ let _reattached_route = enqueue(+ &ingress,+ agent,+ Some("session-detaching"),+ r#"{"id":4,"method":"Runtime.getProperties","params":{"objectId":"reattached"}}"#,+ );+ assert!(+ ingress.claim_for_owner().is_some(),+ "a later attachment may create a fresh lane for the same wire session id"+ );+ }++ #[test]+ fn mixed_v8_and_page_agents_share_one_main_session_lane() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let page_token =+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(1));+ let _page = ingress.enqueue_protocol_page_command(+ page_token,+ agent,+ RendererPageCommand::PerformanceMetricSnapshot,+ Some("session-a".to_owned()),+ RendererPageStateCapturePolicy::ProtocolTurn,+ );+ let _v8 = enqueue(+ &ingress,+ agent,+ Some("session-a"),+ r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"v8"}}"#,+ );++ let page = ingress+ .claim_for_pause()+ .expect("the Page agent command should be first");+ assert_eq!(+ page.nested_dispatch(),+ RendererDevToolsMainNestedDispatch::PageAgent+ );+ assert!(+ ingress.claim_for_pause().is_none(),+ "the V8 command must remain behind the Page agent first-dispatch boundary"+ );++ ingress.first_dispatch_guard(&page).release();+ let v8 = ingress+ .claim_for_pause()+ .expect("the V8 command should follow Page first-dispatch");+ assert_eq!(+ v8.nested_dispatch(),+ RendererDevToolsMainNestedDispatch::InspectorSession+ );+ }+#[test]- fn nested_main_accepts_runtime_evaluation_but_not_page_owner_context_rewrite() {+ fn nested_main_accepts_runtime_evaluation_with_or_without_explicit_context() {let ingress = ingress();let agent = RendererDevToolsAgentToken::allocate();let _default_evaluate = enqueue_with_action(@@ -856,11 +1047,13 @@ mod tests {Some("evaluate"),r#"{"id":2,"method":"Runtime.evaluate","params":{"contextId":41,"expression":"2 + 2"}}"#,);- assert!(- ingress.claim_for_pause().is_none(),- "context-id rewriting belongs to Page owner dispatch"+ let explicit_context = ingress+ .claim_for_pause()+ .expect("an Inspector-native context id should remain pumpable by nested Main");+ assert_eq!(+ explicit_context.claimed_by(),+ Some(RendererInspectorMainCommandConsumer::Pause));- assert!(ingress.claim_for_owner().is_some());}#[test]@@ -891,7 +1084,7 @@ mod tests {#[test]#[should_panic(- expected = "only MainThread Inspector commands may enter RendererInspectorMainIngress"+ expected = "only MainThread DevTools commands may enter RendererInspectorMainIngress")]fn io_command_cannot_enter_main_ingress() {let ingress = ingress();diff --git a/moli-renderer-v8/src/script_vm/inspector_pause.rs b/moli-renderer-v8/src/script_vm/inspector_pause.rsindex 401cd8a75..341394694 100644--- a/moli-renderer-v8/src/script_vm/inspector_pause.rs+++ b/moli-renderer-v8/src/script_vm/inspector_pause.rs@@ -43,9 +43,23 @@ enum RendererInspectorPausePhase {Paused,}+/// Selects which DevTools receivers may be pumped by V8's nested pause loop.+///+/// Chromium runs a nestable Main-thread message loop for ordinary debugger+/// pauses, but instrumentation pauses only process interrupting Inspector+/// work. The policy is captured from the `Debugger.paused` notification before+/// V8 calls `run_message_loop_on_pause`, so the loop never needs to inspect a+/// command method or infer priority from its queue.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(super) enum RendererInspectorPauseLoopPolicy {+ MainAndIo,+ IoOnly,+}+struct RendererInspectorPauseBridgeState {next_preface_id: u64,phase: RendererInspectorPausePhase,+ pause_loop_policy: RendererInspectorPauseLoopPolicy,quit_requested: bool,session_detach_arms: usize,target_closed: bool,@@ -179,6 +193,7 @@ impl RendererInspectorPauseBridge {state: Mutex::new(RendererInspectorPauseBridgeState {next_preface_id: 1,phase: RendererInspectorPausePhase::Running,+ pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo,quit_requested: false,session_detach_arms: 0,target_closed: false,@@ -200,6 +215,7 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {formatter.debug_struct("RendererInspectorPauseBridge").field("phase", &state.phase)+ .field("pause_loop_policy", &state.pause_loop_policy).field("quit_requested", &state.quit_requested).field("session_detach_arms", &state.session_detach_arms).field("target_closed", &state.target_closed)@@ -408,13 +424,13 @@ impl RendererInspectorPauseBridge {.expect("runtime inspector session detach arm count underflow");}- pub(super) fn enter_pause(&self) -> bool {+ pub(super) fn enter_pause(&self) -> Option<RendererInspectorPauseLoopPolicy> {let mut state = self.shared.state.lock();if state.target_closed || state.phase != RendererInspectorPausePhase::Entering {- return false;+ return None;}state.phase = RendererInspectorPausePhase::Paused;- true+ Some(state.pause_loop_policy)}pub(crate) fn wait_for_pause_work<T>(&self, mut claim: impl FnMut() -> Option<T>) -> Option<T> {@@ -441,6 +457,7 @@ impl RendererInspectorPauseBridge {pub(super) fn leave_pause(&self) {let mut state = self.shared.state.lock();state.phase = RendererInspectorPausePhase::Running;+ state.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo;state.quit_requested = false;// Commands that lost the nested-loop race stay in their route-specific// ingress. Main retains its owner task; IO retains owner and interrupt@@ -467,6 +484,7 @@ impl RendererInspectorPauseBridge {RendererInspectorPausePhase::Running => {}RendererInspectorPausePhase::Entering => {state.phase = RendererInspectorPausePhase::Running;+ state.pause_loop_policy = RendererInspectorPauseLoopPolicy::MainAndIo;state.quit_requested = false;}RendererInspectorPausePhase::Paused => {@@ -573,8 +591,27 @@ impl RendererInspectorPauseBridge {if command_transition_complete {state.pending_command_transition = None;}- if is_paused_notification && state.phase == RendererInspectorPausePhase::Running {- state.phase = RendererInspectorPausePhase::Entering;+ if is_paused_notification {+ let is_instrumentation_pause = message+ .get("params")+ .and_then(|params| params.get("reason"))+ .and_then(Value::as_str)+ == Some("instrumentation");+ if state.phase == RendererInspectorPausePhase::Running {+ state.phase = RendererInspectorPausePhase::Entering;+ state.pause_loop_policy = if is_instrumentation_pause {+ RendererInspectorPauseLoopPolicy::IoOnly+ } else {+ RendererInspectorPauseLoopPolicy::MainAndIo+ };+ } else if state.phase == RendererInspectorPausePhase::Entering+ && is_instrumentation_pause+ {+ // Multiple V8InspectorSessions observe the same isolate pause.+ // Any session identifying it as instrumentation tightens the+ // shared loop policy before V8 enters the client loop.+ state.pause_loop_policy = RendererInspectorPauseLoopPolicy::IoOnly;+ }}if state.phase == RendererInspectorPausePhase::Running && !resumes_reported_pause {RendererInspectorPauseNotificationRoute::OrdinaryTurn@@ -795,7 +832,10 @@ mod tests {}))).is_empty());- assert!(bridge.enter_pause());+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo)+ );let (response, _response_rx) = response_sender(41);let command_route = enqueue_command(@@ -863,7 +903,10 @@ mod tests {}))).is_empty());- assert!(bridge.enter_pause());+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo)+ );let (response, _response_rx) = response_sender(43);let command_route = enqueue_command(@@ -919,7 +962,10 @@ mod tests {}))).is_empty());- assert!(bridge.enter_pause());+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo)+ );let (response, _response_rx) = response_sender(42);let command_route = enqueue_command(@@ -1020,7 +1066,10 @@ mod tests {.is_empty(),"paused notification should publish at the pause boundary");- assert!(bridge.enter_pause());+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo)+ );bridge.leave_pause();assert_eq!(bridge.shared.state.lock().phase,@@ -1050,6 +1099,47 @@ mod tests {);}+ #[test]+ fn instrumentation_pause_selects_io_only_nested_loop_policy() {+ let bridge = RendererInspectorPauseBridge::default();+ configure_page(&bridge, PageId::new_for_testing(1));+ let route = outbound_route(&bridge);++ assert!(+ expect_immediate_preface(route.route_notification(&json!({+ "method": "Debugger.paused",+ "params": {+ "reason": "instrumentation",+ "callFrames": [],+ },+ })))+ .is_empty()+ );+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::IoOnly),+ "instrumentation pauses must not pump the Main DevTools receiver"+ );+ bridge.leave_pause();++ assert!(+ expect_immediate_preface(route.route_notification(&json!({+ "method": "Debugger.paused",+ "params": {+ "reason": "other",+ "callFrames": [],+ },+ })))+ .is_empty()+ );+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo),+ "ordinary pauses must restore the nestable Main receiver"+ );+ bridge.leave_pause();+ }+#[tokio::test]async fn dropping_io_route_cancels_the_unclaimed_command() {let bridge = RendererInspectorPauseBridge::default();@@ -1127,7 +1217,10 @@ mod tests {assert!(expect_immediate_preface(route_paused(&bridge)).is_empty());bridge.request_quit();- assert!(bridge.enter_pause());+ assert_eq!(+ bridge.enter_pause(),+ Some(RendererInspectorPauseLoopPolicy::MainAndIo)+ );let io_ingress = io_ingress(&bridge);assert!(io_ingress.wait_and_claim_for_pause(&bridge).is_none());bridge.leave_pause();@@ -1147,7 +1240,7 @@ mod tests {route_paused(&bridge),RendererInspectorPauseNotificationRoute::Drop);- assert!(!bridge.enter_pause());+ assert_eq!(bridge.enter_pause(), None);assert_eq!(bridge.shared.state.lock().phase,RendererInspectorPausePhase::Running@@ -1167,7 +1260,7 @@ mod tests {route_paused(&bridge),RendererInspectorPauseNotificationRoute::Drop);- assert!(!bridge.enter_pause());+ assert_eq!(bridge.enter_pause(), None);assert_eq!(bridge.shared.state.lock().phase,RendererInspectorPausePhase::Running