Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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_id
diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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
.sessions
diff --git a/moli-renderer-v8/src/script_vm/inspector_main.rs b/moli-renderer-v8/src/script_vm/inspector_main.rs
index 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.rs
index 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