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: add nested main inspector receiver
ldm01b5ffc8f5dd5
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex fe8311082..f6f54fbf0 100644--- a/moli-core/src/page/command_dispatch.rs+++ b/moli-core/src/page/command_dispatch.rs@@ -1,7 +1,8 @@use super::{Page, RendererAgentAttachmentId, RendererCommandTurnOutput, RendererPageCommand,RendererPageCommandPending, RendererPageReply, RendererRuntimeInspectorCommandClaim,- RendererRuntimeInspectorCommandRoute, RendererRuntimeInspectorMessage,+ RendererRuntimeInspectorCommandRoute, RendererRuntimeInspectorMainCommandCompletion,+ RendererRuntimeInspectorMainCommandRoute, RendererRuntimeInspectorMessage,};use crate::RendererOutputFence;use anyhow::{Result, bail};@@ -16,7 +17,7 @@ pub struct PendingRuntimeInspectorCommandDispatch {}enum PendingRuntimeInspectorCommandDispatchKind {- MainThread(PendingPageCommand),+ MainIngress(Box<RendererRuntimeInspectorMainCommandRoute>),Io(RendererRuntimeInspectorCommandRoute),}@@ -127,19 +128,19 @@ impl Page {PendingRuntimeInspectorCommandDispatch { kind }}- pub(crate) fn pending_main_thread_runtime_inspector_command_dispatch(- pending: PendingPageCommand,+ pub(crate) fn pending_io_runtime_inspector_command_dispatch(+ route: RendererRuntimeInspectorCommandRoute,) -> PendingRuntimeInspectorCommandDispatch {Self::pending_runtime_inspector_command_dispatch(- PendingRuntimeInspectorCommandDispatchKind::MainThread(pending),+ PendingRuntimeInspectorCommandDispatchKind::Io(route),)}- pub(crate) fn pending_io_runtime_inspector_command_dispatch(- route: RendererRuntimeInspectorCommandRoute,+ pub(crate) fn pending_main_ingress_runtime_inspector_command_dispatch(+ route: RendererRuntimeInspectorMainCommandRoute,) -> PendingRuntimeInspectorCommandDispatch {Self::pending_runtime_inspector_command_dispatch(- PendingRuntimeInspectorCommandDispatchKind::Io(route),+ PendingRuntimeInspectorCommandDispatchKind::MainIngress(Box::new(route)),)}@@ -365,11 +366,28 @@ impl PendingPageCommand {impl PendingRuntimeInspectorCommandDispatch {pub async fn wait(self) -> Result<CompletedRuntimeInspectorCommandDispatch> {match self.kind {- PendingRuntimeInspectorCommandDispatchKind::MainThread(pending) => pending- .wait()- .await- .map(Box::new)- .map(CompletedRuntimeInspectorCommandDispatch::Owner),+ PendingRuntimeInspectorCommandDispatchKind::MainIngress(route) => {+ let renderer_agent_attachment_id = route.ticket().attachment();+ match route.wait_for_completion().await? {+ RendererRuntimeInspectorMainCommandCompletion::Owner(mut output) => {+ if let Some(attachment_id) = renderer_agent_attachment_id {+ output.bind_renderer_agent_attachment(attachment_id);+ }+ Ok(CompletedRuntimeInspectorCommandDispatch::Owner(Box::new(+ CompletedPageCommand {+ output: *output,+ renderer_agent_attachment_id,+ },+ )))+ }+ RendererRuntimeInspectorMainCommandCompletion::Inspector => {+ Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)+ }+ RendererRuntimeInspectorMainCommandCompletion::Canceled => {+ Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)+ }+ }+ }PendingRuntimeInspectorCommandDispatchKind::Io(route) => {match route.wait_for_claim().await.map_err(anyhow::Error::msg)? {RendererRuntimeInspectorCommandClaim::Inspector => {diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex 0e749fca6..6c4f056d7 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -520,23 +520,19 @@ impl Page {) -> Result<PendingRuntimeInspectorCommandDispatch> {match inspector_route {RendererInspectorCommandRoute::MainThread => {- let command = match owner_context_resolution_action {- Some(action) => RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(- inspector_session_id,- RendererInspectorCommandRoute::MainThread,- action,- raw_json,- deferred_response,- ),- None => RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(- inspector_session_id,- RendererInspectorCommandRoute::MainThread,+ let route = self.handle.enqueue_runtime_inspector_main_command(+ RendererInspectorCommandEnvelope::new_main_protocol(+ RendererInspectorIngressTicket::new(+ self.renderer_agent_attachment_id,+ inspector_session_id,+ RendererInspectorCommandRoute::MainThread,+ ),+ owner_context_resolution_action,raw_json,deferred_response,),- };- self.start_page_command(command)- .map(Self::pending_main_thread_runtime_inspector_command_dispatch)+ );+ Ok(Self::pending_main_ingress_runtime_inspector_command_dispatch(route))}RendererInspectorCommandRoute::Io => {if owner_context_resolution_action.is_some() {diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rsindex e8b134251..b9a9e4005 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -114,6 +114,7 @@ pub use moli_renderer_v8::{RendererPointerEventProperties, RendererPopupActivationSource,RendererResourceTextSearchOutcome, RendererRuntimeCommandOutput, RendererRuntimeHeapUsage,RendererRuntimeInspectorCommandClaim, RendererRuntimeInspectorCommandRoute,+ RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,RendererRuntimeInspectorProtocolMessage, RendererRuntimeInspectorProtocolMessageValueMut,RendererRuntimeObservableSourceItem, RendererRuntimeObservableSourceSummary,diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rsindex 61204bd66..256e93241 100644--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs@@ -5022,7 +5022,7 @@ async fn websocket_cdp_fetch_routes_pending_background_parser_script_to_exact_se}#[tokio::test]-async fn websocket_cdp_debugger_step_out_main_thread_waits_for_io_resume() {+async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_pause() {let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"@@ -5088,50 +5088,64 @@ async fn websocket_cdp_debugger_step_out_main_thread_waits_for_io_resume() {json!("inner"));- socket- .send(WsMessage::Text(- json!({- "id": 6_u64,- "method": "Debugger.stepOut",- "sessionId": session_id,- "params": {}- })- .to_string()- .into(),- ))- .await- .expect("queue MainThread Debugger.stepOut while paused");-- // Chromium routes step controls over its main DevToolsSession, not its IO- // session. Moli's Page owner is still inside the Runtime.evaluate that- // entered this pause, so the step command must remain queued until the IO- // resume releases that owner call.- let resumed = send_cdp_command(+ let mut stepped = send_cdp_command(&mut socket,- 7,- "Debugger.resume",+ 6,+ "Debugger.stepOut",Some(&session_id),json!({}),).await;- assert!(- resumed.iter().all(|message| message["id"] != json!(6_u64)),- "MainThread stepOut must not dispatch from the IO-only pause loop: {resumed:#?}"- );- observed.extend(resumed);-- let mut saw_evaluate_response = observed.iter().any(|message| message["id"] == json!(5_u64));- let mut saw_step_response = observed.iter().any(|message| message["id"] == json!(6_u64));- if !saw_evaluate_response || !saw_step_response {- observed.extend(+ if !stepped.iter().any(|message| {+ message["method"] == json!("Debugger.paused")+ && message["params"]["reason"] == json!("step")+ && message["params"]["callFrames"][0]["functionName"] == json!("outer")+ }) {+ stepped.extend(recv_until_match(&mut socket, |message| {- saw_evaluate_response |= message["id"] == json!(5_u64);- saw_step_response |= message["id"] == json!(6_u64);- saw_evaluate_response && saw_step_response+ message["sessionId"].as_str() == Some(session_id.as_str())+ && message["method"] == json!("Debugger.paused")+ && message["params"]["reason"] == json!("step")+ && message["params"]["callFrames"][0]["functionName"] == json!("outer")}).await,);}+ let response_position = stepped+ .iter()+ .position(|message| message["id"] == json!(6_u64))+ .expect("stepOut should respond");+ let resumed_position = stepped+ .iter()+ .position(|message| message["method"] == json!("Debugger.resumed"))+ .expect("stepOut should emit Debugger.resumed");+ let caller_pause_position = stepped+ .iter()+ .position(|message| {+ message["method"] == json!("Debugger.paused")+ && message["params"]["reason"] == json!("step")+ && message["params"]["callFrames"][0]["functionName"] == json!("outer")+ })+ .expect("stepOut should pause in the caller");+ assert!(+ response_position < resumed_position && resumed_position < caller_pause_position,+ "stepOut must preserve response -> resumed -> caller pause: {stepped:#?}"+ );++ observed.extend(+ send_cdp_command(+ &mut socket,+ 7,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await,+ );+ if !observed.iter().any(|message| message["id"] == json!(5_u64)) {+ observed+ .extend(recv_until_match(&mut socket, |message| message["id"] == json!(5_u64)).await);+ }let evaluate = observed.iter().find(|message| message["id"] == json!(5_u64))@@ -5141,33 +5155,12 @@ async fn websocket_cdp_debugger_step_out_main_thread_waits_for_io_resume() {json!(42),"resuming the exact pause must return to the blocked Runtime command: {observed:#?}");- let step = observed- .iter()- .find(|message| message["id"] == json!(6_u64))- .expect("queued stepOut response after resume");- assert!(- step.get("error").is_some(),- "stepOut reaches V8 only after execution is no longer paused: {observed:#?}"- );- let resume_position = observed- .iter()- .position(|message| message["id"] == json!(7_u64))- .expect("IO resume response position");- let step_position = observed- .iter()- .position(|message| message["id"] == json!(6_u64))- .expect("MainThread stepOut response position");- assert!(- resume_position < step_position,- "IO resume must overtake the queued MainThread stepOut: {observed:#?}"- );-let _ = socket.close(None).await;protocol_server.abort();}#[tokio::test]-async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_until_resume() {+async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"@@ -5252,14 +5245,63 @@ async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_unti!observed.iter().any(|message| message["id"] == json!(6_u64)),"Runtime.evaluate must remain pending while the renderer owner is paused: {observed:#?}");+ // Chromium's normal debugger loop pumps its main-thread DevTools receiver.+ // This command must therefore reach the auxiliary V8 session even though+ // the ordinary Page owner turn that entered the pause has not returned.+ let auxiliary_evaluate = tokio::time::timeout(+ Duration::from_secs(5),+ send_cdp_command(+ &mut socket,+ 7,+ "Runtime.evaluate",+ Some(&auxiliary_session_id),+ json!({ "expression": "21 * 2", "returnByValue": true }),+ ),+ )+ .await+ .expect("auxiliary Main Runtime.evaluate must complete in the debugger loop");+ assert!(+ auxiliary_evaluate.iter().any(|message| {+ message["id"] == json!(7_u64)+ && message["sessionId"] == json!(auxiliary_session_id)+ && message["result"]["result"]["value"] == json!(42)+ }),+ "pause-loop Main Runtime.evaluate should complete before resume: {auxiliary_evaluate:#?}"+ );++ let auxiliary_object = tokio::time::timeout(+ Duration::from_secs(5),+ send_cdp_command(+ &mut socket,+ 51,+ "Runtime.evaluate",+ Some(&auxiliary_session_id),+ json!({ "expression": "({ answer: 42 })" }),+ ),+ )+ .await+ .expect("object-valued Main Runtime.evaluate must complete in the debugger loop");+ assert!(+ auxiliary_object.iter().any(|message| {+ message["id"] == json!(51_u64)+ && message["sessionId"] == json!(auxiliary_session_id)+ && message["result"]["result"]["type"] == json!("object")+ && message["result"]["result"]["objectId"]+ .as_str()+ .is_some_and(|object_id| !object_id.is_empty())+ }),+ "pause-loop object response must remain owner-independent: {auxiliary_object:#?}"+ );+socket.send(WsMessage::Text(json!({- "id": 7_u64,+ "id": 52_u64,"method": "Runtime.evaluate","sessionId": auxiliary_session_id,"params": {- "expression": "21 * 2",+ "expression": "Promise.resolve(43)",+ "awaitPromise": true,"returnByValue": true}})@@ -5267,33 +5309,28 @@ async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_unti.into(),)).await- .expect("queue auxiliary MainThread Runtime.evaluate while paused");+ .expect("send pause-loop awaitPromise Runtime.evaluate");- let resumed = send_cdp_command(- &mut socket,- 8,- "Debugger.resume",- Some(&session_id),- json!({}),- )- .await;- assert!(- resumed.iter().all(|message| message["id"] != json!(7_u64)),- "auxiliary MainThread evaluate must not dispatch from the IO-only pause loop: {resumed:#?}"+ observed.extend(+ send_cdp_command(+ &mut socket,+ 8,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await,);- observed.extend(resumed);-- let mut saw_paused_evaluate = observed.iter().any(|message| message["id"] == json!(6_u64));- let mut saw_auxiliary_evaluate = observed.iter().any(|message| message["id"] == json!(7_u64));- if !saw_paused_evaluate || !saw_auxiliary_evaluate {- observed.extend(- recv_until_match(&mut socket, |message| {- saw_paused_evaluate |= message["id"] == json!(6_u64);- saw_auxiliary_evaluate |= message["id"] == json!(7_u64);- saw_paused_evaluate && saw_auxiliary_evaluate- })- .await,- );+ if !observed.iter().any(|message| message["id"] == json!(6_u64)) {+ observed+ .extend(recv_until_match(&mut socket, |message| message["id"] == json!(6_u64)).await);+ }+ if !observed+ .iter()+ .any(|message| message["id"] == json!(52_u64))+ {+ observed+ .extend(recv_until_match(&mut socket, |message| message["id"] == json!(52_u64)).await);}let evaluate = observed.iter()@@ -5304,26 +5341,14 @@ async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_untijson!(42),"resuming the exact pause must return to the blocked Runtime command: {observed:#?}");- let auxiliary_evaluate = observed- .iter()- .find(|message| message["id"] == json!(7_u64))- .expect("auxiliary Runtime.evaluate should complete after Debugger.resume");- assert_eq!(- auxiliary_evaluate["result"]["result"]["value"],- json!(42),- "the queued auxiliary MainThread command must run normally after resume: {observed:#?}"- );- let resume_position = observed- .iter()- .position(|message| message["id"] == json!(8_u64))- .expect("IO resume response position");- let auxiliary_position = observed- .iter()- .position(|message| message["id"] == json!(7_u64))- .expect("auxiliary MainThread response position");assert!(- resume_position < auxiliary_position,- "IO resume must overtake the queued auxiliary MainThread command: {observed:#?}"+ observed.iter().any(|message| {+ message["id"] == json!(52_u64)+ && message["sessionId"] == json!(auxiliary_session_id)+ && message["result"]["result"]["value"] == json!(43)+ }),+ "awaitPromise should settle after Debugger.resume without a deferred-reply deadlock: \+ {observed:#?}");let _ = socket.close(None).await;diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex 48048d339..0abecfad1 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -281,6 +281,7 @@ pub use runtime::{RendererRuntimeCommandOutput, RendererRuntimeEvaluationResult, RendererRuntimeHeapSpaceUsage,RendererRuntimeHeapUsage, RendererRuntimeInspectorAsyncCompletion,RendererRuntimeInspectorCommandClaim, RendererRuntimeInspectorCommandRoute,+ RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,RendererRuntimeInspectorProtocolMessage, RendererRuntimeInspectorProtocolMessageValueMut,RendererRuntimeInspectorResponseChannel, RendererRuntimeInspectorResponseSender,diff --git a/moli-renderer-v8/src/render_runtime.rs b/moli-renderer-v8/src/render_runtime.rsindex ea051414e..0b8b05831 100644--- a/moli-renderer-v8/src/render_runtime.rs+++ b/moli-renderer-v8/src/render_runtime.rs@@ -8,6 +8,7 @@ use tokio::sync::{mpsc, oneshot};use super::page_task_queue::RendererOwnerWake;use super::runtime::{RendererOwnerCommand, RendererOwnerHandle, RendererOwnerReply};use super::script_vm::inspector_io::RendererInspectorIoOwnerWake;+use super::script_vm::inspector_main::RendererInspectorMainOwnerWake;use super::service_worker_runtime::ServiceWorkerRuntimeOwnerWake;use super::shared_worker_runtime::SharedWorkerRuntimeOwnerWake;@@ -18,9 +19,12 @@ use super::shared_worker_runtime::SharedWorkerRuntimeOwnerWake;// headroom for fresh V8 entry points.const RENDER_RUNTIME_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;-pub(crate) struct RenderRuntimeEnvelope {- pub(crate) command: RendererOwnerCommand,- pub(crate) reply_tx: oneshot::Sender<Result<RendererOwnerReply>>,+pub(crate) enum RenderRuntimeEnvelope {+ Command {+ command: Box<RendererOwnerCommand>,+ reply_tx: oneshot::Sender<Result<RendererOwnerReply>>,+ },+ InspectorMainReceiverWake(RendererInspectorMainOwnerWake),}#[derive(Clone)]@@ -179,18 +183,38 @@ impl RenderRuntimeHandle {error: anyhow!("render runtime command admission has shut down"),});}- if let Err(error) = admission- .tx- .send(RenderRuntimeEnvelope { command, reply_tx })- {+ if let Err(error) = admission.tx.send(RenderRuntimeEnvelope::Command {+ command: Box::new(command),+ reply_tx,+ }) {+ let RenderRuntimeEnvelope::Command { command, .. } = error.0 else {+ unreachable!("command admission must recover the command envelope it sent")+ };return Err(RenderRuntimeEnqueueError {- command: Box::new(error.0.command),+ command,error: anyhow!("render runtime thread has shut down"),});}Ok(reply_rx)}+ pub(crate) fn enqueue_inspector_main_receiver_wake(+ &self,+ wake: RendererInspectorMainOwnerWake,+ ) -> Result<()> {+ let Some(state) = self.state.upgrade() else {+ return Err(anyhow!("render runtime thread has shut down"));+ };+ let admission = state.admission.lock();+ if admission.terminal {+ return Err(anyhow!("render runtime command admission has shut down"));+ }+ admission+ .tx+ .send(RenderRuntimeEnvelope::InspectorMainReceiverWake(wake))+ .map_err(|_| anyhow!("render runtime thread has shut down"))+ }+pub(crate) fn enqueue_owned(&self,command: RendererOwnerCommand,diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex f62518471..6646dd41b 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -406,6 +406,9 @@ pub(crate) use crate::renderer::PageVmInitStage;pub use crate::script_vm::inspector_io::{RendererRuntimeInspectorCommandClaim, RendererRuntimeInspectorCommandRoute,};+pub use crate::script_vm::inspector_main::{+ RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,+};pub(crate) use crate::service_worker_runtime::{MaterializedServiceWorkerFetchResponseHead, ServiceWorkerClientFocus,ServiceWorkerClientFocusError, ServiceWorkerClientFocusResult, ServiceWorkerClientId,diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex b5a2cd14b..259fec947 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -81,7 +81,8 @@ use crate::referrer_policy::response_referrer_policy_from_headers;use crate::render_runtime::{RenderRuntimeEnvelope, RenderRuntimeHandle, RenderRuntimeOwner};use crate::script_vm::{PendingRuntimeEvaluateCall, RendererDocumentIsolateBootstrap, dispatch_inspector_io_owner_wake,- inspector_io::RendererInspectorIoOwnerWake,+ dispatch_inspector_main_owner_wake, inspector_io::RendererInspectorIoOwnerWake,+ inspector_main::RendererInspectorMainOwnerWake,};use crate::service_worker_runtime::{ServiceWorkerRuntimeOwnerWake, service_worker_owner_wake_channel,@@ -293,6 +294,11 @@ pub enum RendererOwnerReply {enum RenderRuntimeDispatchOutcome {Reply(Box<Result<RendererOwnerReply>>),+ InspectorMainCommandClaimed {+ reply_tx: oneshot::Sender<Result<RendererOwnerReply>>,+ turn: Box<RenderRuntimeTurn>,+ command_admission_output_predecessor: Option<RendererOutputFence>,+ },PageCreatedAndContinueNavigation {page: Box<RendererAttachedPage>,continuation: RenderRuntimePageCreationContinuation,@@ -575,6 +581,12 @@ enum RenderRuntimeTurn {RunOwnerMaintenance {task: RendererOwnerMaintenanceTask,},+ /// One task posted by the Main DevTools receiver. The command remains+ /// unclaimed until this turn actually runs, so a nested debugger loop can+ /// pump the same receiver while an earlier Page turn is paused in V8.+ RunInspectorMainReceiver {+ wake: RendererInspectorMainOwnerWake,+ },RunLivePageCommand {token: RendererPageToken,command: RendererPageCommand,@@ -678,6 +690,9 @@ impl RenderRuntimeTurn {) -> Option<PageCommandFirstDispatchIdentity> {match self {Self::RunLivePageCommand { token, command, .. } => {+ if command.uses_main_inspector_ingress_admission() {+ return None;+ }command.inspector_ticket().map(|ticket| {debug_assert_eq!(ticket.route(),@@ -870,6 +885,7 @@ impl RenderRuntimeDispatchOutcome {turn.live_page_command_first_dispatch_identity()}Self::Reply(_)+ | Self::InspectorMainCommandClaimed { .. }| Self::PageCreatedAndContinueNavigation { .. }| Self::BackgroundComplete(_)| Self::PageCreationNavigationFailurePublished { .. } => None,@@ -913,6 +929,7 @@ pub(super) struct RendererOwnerState {pub(super) local_executor: JsLocalExecutor,pub(super) next_page_id: Arc<AtomicU64>,pub(super) page_wake_tx: mpsc::UnboundedSender<RendererOwnerWake>,+ pub(super) render_runtime_admission: std::sync::OnceLock<RenderRuntimeHandle>,pub(super) inspector_io_wake_tx: mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,pub(super) browser_context_runtime: RendererBrowserContextRuntime,pub(super) owner_local_host_id: RendererOwnerLocalHostId,@@ -1714,6 +1731,7 @@ impl RendererOwnerHandle {local_executor,next_page_id,page_wake_tx,+ render_runtime_admission: std::sync::OnceLock::new(),inspector_io_wake_tx,browser_context_runtime,owner_local_host_id,@@ -1736,6 +1754,11 @@ impl RendererOwnerHandle {service_worker_wake_rx,);let render_runtime = render_runtime_owner.handle();+ provisional+ .state+ .render_runtime_admission+ .set(render_runtime.clone())+ .expect("render runtime admission must be initialized exactly once");(Self {render_runtime,@@ -1765,8 +1788,15 @@ impl RendererOwnerHandle {}pub(super) fn owner_local_context(&self) -> Result<RendererOwnerLocalContext> {+ let render_runtime = self+ .state+ .render_runtime_admission+ .get()+ .cloned()+ .ok_or_else(|| anyhow!("render runtime admission is not initialized"))?;Ok(RendererOwnerLocalContext {owner_state: self.state.clone(),+ render_runtime,local_host_id: self.state.owner_local_host_id,#[cfg(debug_assertions)]local_thread_id: self.bind_or_check_local_runtime_thread()?,@@ -2501,6 +2531,18 @@ impl RendererOwnerHandle {}}+ fn enqueue_inspector_main_receiver_wake(+ wake: RendererInspectorMainOwnerWake,+ pending_turns: &mut RenderRuntimePendingTurnQueue,+ ) {+ pending_turns.push_back(RenderRuntimePendingTurn {+ reply_tx: None,+ turn: RenderRuntimeTurn::RunInspectorMainReceiver { wake },+ allow_command_overtake: false,+ command_admission_output_predecessor: None,+ });+ }+pub(crate) async fn run_render_runtime_loop(&self,mut rx: mpsc::UnboundedReceiver<RenderRuntimeEnvelope>,@@ -2540,10 +2582,12 @@ impl RendererOwnerHandle {}}while let Ok(envelope) = rx.try_recv() {- self.release_rejected_command_output_reservation(&envelope.command);- let _ = envelope.reply_tx.send(Err(anyhow!(- "renderer browser context was dropped before command dispatch"- )));+ if let RenderRuntimeEnvelope::Command { command, reply_tx } = envelope {+ self.release_rejected_command_output_reservation(&command);+ let _ = reply_tx.send(Err(anyhow!(+ "renderer browser context was dropped before command dispatch"+ )));+ }}break;}@@ -2706,6 +2750,19 @@ impl RendererOwnerHandle {);}}+ RenderRuntimeDispatchOutcome::InspectorMainCommandClaimed {+ reply_tx,+ turn,+ command_admission_output_predecessor,+ } => {+ debug_assert!(pending_turn.reply_tx.is_none());+ pending_turns.push_front(RenderRuntimePendingTurn {+ reply_tx: Some(reply_tx),+ turn: *turn,+ allow_command_overtake: false,+ command_admission_output_predecessor,+ });+ }RenderRuntimeDispatchOutcome::PageCreatedAndContinueNavigation {mut page,continuation,@@ -2990,18 +3047,25 @@ impl RendererOwnerHandle {pending_turns: &mut RenderRuntimePendingTurnQueue,parked_turns: &mut VecDeque<RenderRuntimeParkedTurn>,) {+ let (command, reply_tx) = match envelope {+ RenderRuntimeEnvelope::Command { command, reply_tx } => (*command, reply_tx),+ RenderRuntimeEnvelope::InspectorMainReceiverWake(wake) => {+ Self::enqueue_inspector_main_receiver_wake(wake, pending_turns);+ return;+ }+ };#[cfg(test)]self.wait_on_command_dispatch_gate_for_testing();if self.context_shutdown_started() {- self.release_rejected_command_output_reservation(&envelope.command);- let _ = envelope.reply_tx.send(Err(anyhow!(+ self.release_rejected_command_output_reservation(&command);+ let _ = reply_tx.send(Err(anyhow!("renderer browser context was dropped before command dispatch")));return;}- if envelope.reply_tx.is_closed()+ if reply_tx.is_closed()&& matches!(- &envelope.command,+ &command,RendererOwnerCommand::RunAsyncPageCommand { command, .. }| RendererOwnerCommand::RunProtocolPageCommand { command, .. }if command.interruptible_by_javascript_dialog()@@ -3009,20 +3073,19 @@ impl RendererOwnerHandle {{return;}- let removed_page_token = match &envelope.command {+ let removed_page_token = match &command {RendererOwnerCommand::RemovePage { token } => Some(*token),_ => None,};let mut command_admission_output_predecessor =- renderer_command_admission_page_token(&envelope.command)+ renderer_command_admission_page_token(&command).and_then(renderer_output_fence_for_tail_on_bound_owner_local_store);- let command_future = Box::pin(- self.dispatch_command_inline_on_owner_local_store(envelope.command, owner_local_store),- );+ let command_future =+ Box::pin(self.dispatch_command_inline_on_owner_local_store(command, owner_local_store));let outcome = command_future.await;if self.context_shutdown_started() {self.cancel_dispatch_outcome_for_context_shutdown(outcome);- let _ = envelope.reply_tx.send(Err(anyhow!(+ let _ = reply_tx.send(Err(anyhow!("renderer browser context was dropped during command dispatch")));return;@@ -3033,7 +3096,20 @@ impl RendererOwnerHandle {*result,command_admission_output_predecessor.take(),);- let _ = envelope.reply_tx.send(result);+ let _ = reply_tx.send(result);+ }+ RenderRuntimeDispatchOutcome::InspectorMainCommandClaimed {+ reply_tx: main_reply_tx,+ turn,+ command_admission_output_predecessor: _,+ } => {+ self.cancel_pending_turn_on_owner_local_store(*turn);+ let _ = main_reply_tx.send(Err(anyhow!(+ "Inspector Main receiver outcome escaped into owner command dispatch"+ )));+ let _ = reply_tx.send(Err(anyhow!(+ "renderer command unexpectedly entered the Inspector Main receiver"+ )));}RenderRuntimeDispatchOutcome::PageCreatedAndContinueNavigation {mut page,@@ -3045,8 +3121,7 @@ impl RendererOwnerHandle {self.state.page_wake_tx.clone(),);}- if envelope- .reply_tx+ if reply_tx.send(Ok(RendererOwnerReply::PageCreated(page))).is_ok(){@@ -3068,22 +3143,22 @@ impl RendererOwnerHandle {"renderer command unexpectedly completed as background work: {error}")),};- let _ = envelope.reply_tx.send(reply);+ let _ = reply_tx.send(reply);}RenderRuntimeDispatchOutcome::PageCreationNavigationFailurePublished {token,failure,} => {- let _ = envelope.reply_tx.send(Err(anyhow!(failure.to_string())));+ let _ = reply_tx.send(Err(anyhow!(failure.to_string())));self.enqueue_parked_turns_for_wake(token, parked_turns, pending_turns);}RenderRuntimeDispatchOutcome::ContinueNextTurn(turn) => {- if envelope.reply_tx.is_closed() {+ if reply_tx.is_closed() {self.detach_navigation_or_cancel_pending_turn(*turn, pending_turns);} else {Self::admit_page_command_first_dispatch(RenderRuntimePendingTurn {- reply_tx: Some(envelope.reply_tx),+ reply_tx: Some(reply_tx),turn: *turn,// This is the command's first owner turn, not a// continuation returning to the queue. Run it before@@ -3104,7 +3179,7 @@ impl RendererOwnerHandle {ready_at,} => {self.park_or_cancel_turn(- Some(envelope.reply_tx),+ Some(reply_tx),*turn,wake_token,Some(ready_at),@@ -3116,7 +3191,7 @@ impl RendererOwnerHandle {}RenderRuntimeDispatchOutcome::ContinueAfterPageWake { turn, wake_token } => {self.park_or_cancel_turn(- Some(envelope.reply_tx),+ Some(reply_tx),*turn,wake_token,None,@@ -3131,7 +3206,7 @@ impl RendererOwnerHandle {wake_token,} => {self.park_or_cancel_turn(- Some(envelope.reply_tx),+ Some(reply_tx),*turn,wake_token,None,@@ -3167,6 +3242,14 @@ impl RendererOwnerHandle {} => {self.cancel_pending_turn_on_owner_local_store(*turn);}+ RenderRuntimeDispatchOutcome::InspectorMainCommandClaimed {+ reply_tx,+ turn,+ command_admission_output_predecessor: _,+ } => {+ drop(reply_tx);+ self.cancel_pending_turn_on_owner_local_store(*turn);+ }RenderRuntimeDispatchOutcome::Reply(_)| RenderRuntimeDispatchOutcome::BackgroundComplete(_)| RenderRuntimeDispatchOutcome::PageCreationNavigationFailurePublished { .. } => {}@@ -4438,6 +4521,7 @@ impl RendererOwnerHandle {| RenderRuntimeTurn::DrainServiceWorkerServiceLane| RenderRuntimeTurn::RunPageTurn { .. }| RenderRuntimeTurn::RunOwnerMaintenance { .. }+ | RenderRuntimeTurn::RunInspectorMainReceiver { .. }| RenderRuntimeTurn::RunLivePageCommand { .. }| RenderRuntimeTurn::ResumeLivePageDocumentLifecycleAfterReply { .. }| RenderRuntimeTurn::WaitLivePageNetworkIdle { .. }@@ -6249,6 +6333,23 @@ impl RendererOwnerHandle {RenderRuntimeTurn::RunOwnerMaintenance { task } => {self.run_one_owner_maintenance_turn(task).await}+ RenderRuntimeTurn::RunInspectorMainReceiver { wake } => {+ let Some(dispatch) = dispatch_inspector_main_owner_wake(wake) else {+ return RenderRuntimeDispatchOutcome::BackgroundComplete(Ok(()));+ };+ let (token, capture_policy, envelope, reply_tx) = dispatch.into_parts();+ let command_admission_output_predecessor =+ renderer_output_fence_for_tail_on_bound_owner_local_store(token);+ RenderRuntimeDispatchOutcome::InspectorMainCommandClaimed {+ reply_tx,+ command_admission_output_predecessor,+ turn: Box::new(RenderRuntimeTurn::RunLivePageCommand {+ token,+ command: RendererPageCommand::from_inspector_envelope(envelope),+ capture_policy,+ }),+ }+ }RenderRuntimeTurn::RunLivePageCommand {token,command,diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex a8dbccaae..2b9d96926 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -22,6 +22,8 @@ pub struct RendererAttachedPage {pub(super) javascript_dialog_broker: RendererJavaScriptDialogBroker,pub(super) inspector_pause_bridge:crate::script_vm::inspector_pause::RendererInspectorPauseBridge,+ pub(super) inspector_main_ingress:+ crate::script_vm::inspector_main::RendererInspectorMainIngress,pub(super) inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,pub(super) page_state: Arc<RendererPageState>,pub(super) creation_diagnostics: RendererPageCreationDiagnostics,@@ -70,6 +72,7 @@ impl RendererAttachedPage {page_context_cancel_tx: self.page_context_cancel_tx,javascript_dialog_broker: self.javascript_dialog_broker,inspector_pause_bridge: self.inspector_pause_bridge,+ inspector_main_ingress: self.inspector_main_ingress,inspector_io_ingress: self.inspector_io_ingress,committed_document_post_response_continuation: self.committed_document_post_response_continuation,@@ -91,6 +94,7 @@ pub struct RendererPageHandle {page_context_cancel_tx: RendererPageContextCancelSender,javascript_dialog_broker: RendererJavaScriptDialogBroker,inspector_pause_bridge: crate::script_vm::inspector_pause::RendererInspectorPauseBridge,+ inspector_main_ingress: crate::script_vm::inspector_main::RendererInspectorMainIngress,inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,committed_document_post_response_continuation:Option<RendererPageCommandPostResponseContinuation>,@@ -98,10 +102,15 @@ pub struct RendererPageHandle {}pub struct RendererPageCommandPending {- reply_rx: oneshot::Receiver<anyhow::Result<RendererOwnerReply>>,+ dispatch: RendererPageCommandPendingDispatch,javascript_dialog_watch: Option<RendererJavaScriptDialogWatch>,}+enum RendererPageCommandPendingDispatch {+ Owner(oneshot::Receiver<anyhow::Result<RendererOwnerReply>>),+ InspectorMain(Box<RendererRuntimeInspectorMainCommandRoute>),+}+#[derive(Clone)]pub struct RendererPageTestingHandle {render_runtime: RenderRuntimeHandle,@@ -174,6 +183,17 @@ impl RendererPageHandle {.enqueue_command(self.devtools_agent_token, envelope)}+ pub fn enqueue_runtime_inspector_main_command(+ &self,+ envelope: RendererInspectorCommandEnvelope,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ self.inspector_main_ingress.enqueue_command(+ self.token(),+ self.devtools_agent_token,+ envelope,+ )+ }+pub fn runtime_inspector_pause_active(&self) -> bool {self.inspector_pause_bridge.is_pause_active()}@@ -229,6 +249,21 @@ impl RendererPageHandle {stage = "page_handle_command_dispatch",);}+ let command = match command {+ RendererPageCommand::Inspector(envelope) => {+ let route = self.inspector_main_ingress.enqueue_owner_command(+ self.token(),+ self.devtools_agent_token,+ envelope,+ capture_policy,+ );+ return Ok(RendererPageCommandPending {+ dispatch: RendererPageCommandPendingDispatch::InspectorMain(Box::new(route)),+ javascript_dialog_watch,+ });+ }+ command => command,+ };let owner_command = match capture_policy {RendererPageStateCapturePolicy::FullReport => {RendererOwnerCommand::RunAsyncPageCommand {@@ -245,7 +280,7 @@ impl RendererPageHandle {};let reply_rx = self.render_runtime.enqueue(owner_command)?;Ok(RendererPageCommandPending {- reply_rx,+ dispatch: RendererPageCommandPendingDispatch::Owner(reply_rx),javascript_dialog_watch,})}@@ -308,6 +343,8 @@ impl RendererPageHandle {return Ok(());};self.inspector_pause_bridge.close_target();+ self.inspector_main_ingress+ .close("Inspector target closed with its Page handle");self.inspector_io_ingress.close("Inspector target closed with its Page handle");self.javascript_dialog_broker.dismiss_pending();@@ -349,15 +386,40 @@ impl RendererPageHandle {impl RendererPageCommandPending {pub async fn wait(self) -> Result<RendererCommandTurnOutput> {let RendererPageCommandPending {- reply_rx,+ dispatch,javascript_dialog_watch,} = self;+ let wait_for_dispatch = async move {+ match dispatch {+ RendererPageCommandPendingDispatch::Owner(reply_rx) => {+ match reply_rx+ .await+ .map_err(|_| anyhow!("render runtime reply channel closed"))??+ {+ RendererOwnerReply::AsyncPageCommandRan(result) => Ok(*result),+ _ => Err(anyhow!(+ "renderer owner returned non-async page-command reply for async page command"+ )),+ }+ }+ RendererPageCommandPendingDispatch::InspectorMain(route) => {+ match route.wait_for_completion().await? {+ RendererRuntimeInspectorMainCommandCompletion::Owner(output) => Ok(*output),+ RendererRuntimeInspectorMainCommandCompletion::Inspector => Err(anyhow!(+ "an owner-only Inspector Main command entered nested dispatch"+ )),+ RendererRuntimeInspectorMainCommandCompletion::Canceled => Err(anyhow!(+ "Inspector Main command was canceled before owner dispatch"+ )),+ }+ }+ }+ };+ tokio::pin!(wait_for_dispatch);let reply = if let Some(javascript_dialog_watch) = javascript_dialog_watch {tokio::select! {biased;- reply = reply_rx => {- reply.map_err(|_| anyhow!("render runtime reply channel closed"))??- }+ reply = &mut wait_for_dispatch => reply?,() = javascript_dialog_watch.wait_until_open() => {return Err(anyhow!("renderer page observation interrupted by an open JavaScript dialog"@@ -365,16 +427,9 @@ impl RendererPageCommandPending {}}} else {- reply_rx- .await- .map_err(|_| anyhow!("render runtime reply channel closed"))??+ wait_for_dispatch.await?};- match reply {- RendererOwnerReply::AsyncPageCommandRan(result) => Ok(*result),- _ => Err(anyhow!(- "renderer owner returned non-async page-command reply for async page command"- )),- }+ Ok(reply)}}@@ -384,6 +439,8 @@ impl Drop for RendererPageHandle {return;};if self.inspector_pause_bridge.detach_page(token.page_id) {+ self.inspector_main_ingress+ .cancel_all_queued("Inspector Page handle was dropped");self.inspector_io_ingress.cancel_all_queued("Inspector Page handle was dropped");}diff --git a/moli-renderer-v8/src/runtime/owner_local_store.rs b/moli-renderer-v8/src/runtime/owner_local_store.rsindex 5ac9f37ea..58ac1b300 100644--- a/moli-renderer-v8/src/runtime/owner_local_store.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store.rs@@ -550,6 +550,7 @@ pub(super) enum LivePagePendingNavigationPhaseOneAdvance {pub(super) struct RendererOwnerLocalContext {pub(super) owner_state: Arc<RendererOwnerState>,+ pub(super) render_runtime: crate::render_runtime::RenderRuntimeHandle,pub(super) local_host_id: RendererOwnerLocalHostId,#[cfg(debug_assertions)]pub(super) local_thread_id: ThreadId,@@ -559,6 +560,7 @@ impl Clone for RendererOwnerLocalContext {fn clone(&self) -> Self {Self {owner_state: self.owner_state.clone(),+ render_runtime: self.render_runtime.clone(),local_host_id: self.local_host_id,#[cfg(debug_assertions)]local_thread_id: self.local_thread_id,@@ -3479,6 +3481,7 @@ impl RendererOwnerLocalStore {}let javascript_dialog_broker = entry.page_vm().javascript_dialog_broker();let inspector_pause_bridge = entry.page_vm().inspector_pause_bridge();+ let inspector_main_ingress = entry.page_vm().inspector_main_ingress();let inspector_io_ingress = entry.page_vm().inspector_io_ingress();let page_state = Self::commit_current_vm_page_state_on_entry(&mut entry)?;let initial_runtime_realms = entry.page_vm_mut().vm_mut().runtime_realm_inventory();@@ -3491,6 +3494,7 @@ impl RendererOwnerLocalStore {Ok((javascript_dialog_broker,inspector_pause_bridge,+ inspector_main_ingress,inspector_io_ingress,page_state,devtools_agent_token,@@ -3519,6 +3523,7 @@ impl RendererOwnerLocalStore {|(javascript_dialog_broker,inspector_pause_bridge,+ inspector_main_ingress,inspector_io_ingress,page_state,devtools_agent_token,@@ -3533,6 +3538,7 @@ impl RendererOwnerLocalStore {page_context_cancel_tx,javascript_dialog_broker,inspector_pause_bridge,+ inspector_main_ingress,inspector_io_ingress,page_state,creation_diagnostics,@@ -3975,6 +3981,10 @@ impl RendererOwnerLocalStore {.expect("an attached Page must own a renderer script environment").output_journal(),);+ attached_entry+ .page_vm()+ .inspector_main_ingress()+ .configure_owner_wake(owner.render_runtime.clone());attached_entry.page_vm().inspector_io_ingress()diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex 9edec6359..9c36cba1b 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -3616,6 +3616,8 @@ pub struct RendererInspectorCommandEnvelope {ticket: RendererInspectorIngressTicket,first_dispatch: RendererInspectorFirstDispatchLifecycle,payload: RendererInspectorCommandPayload,+ main_ingress_first_dispatch:+ Option<crate::script_vm::inspector_main::RendererInspectorMainFirstDispatchGuard>,}enum RendererInspectorCommandPayload {@@ -3641,6 +3643,38 @@ impl RendererInspectorCommandEnvelope {ticket: RendererInspectorIngressTicket::new(None, inspector_session_id, route),first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,payload: RendererInspectorCommandPayload::MainThread(command),+ main_ingress_first_dispatch: None,+ }+ }++ #[doc(hidden)]+ pub fn new_main_protocol(+ ticket: RendererInspectorIngressTicket,+ owner_context_resolution_action: Option<String>,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> Self {+ assert_eq!(+ ticket.route(),+ RendererInspectorCommandRoute::MainThread,+ "a Main Inspector protocol payload must use the MainThread route"+ );+ let command = match owner_context_resolution_action {+ Some(action) => RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {+ action,+ raw_json,+ deferred_response: response,+ },+ None => RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {+ raw_json,+ deferred_response: response,+ },+ };+ Self {+ ticket,+ first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ payload: RendererInspectorCommandPayload::MainThread(command),+ main_ingress_first_dispatch: None,}}@@ -3659,6 +3693,7 @@ impl RendererInspectorCommandEnvelope {ticket,first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,payload: RendererInspectorCommandPayload::Io { raw_json, response },+ main_ingress_first_dispatch: None,}}@@ -3675,14 +3710,32 @@ impl RendererInspectorCommandEnvelope {}pub(crate) fn into_main_thread_parts(- self,+ mut 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);+ }++ pub(crate) fn uses_main_ingress_admission(&self) -> bool {+ self.main_ingress_first_dispatch.is_some()+ }+fn main_thread_payload(&self) -> &RendererInspectorPageCommand {let RendererInspectorCommandPayload::MainThread(command) = &self.payload else {panic!("an Inspector IO envelope cannot enter Page owner dispatch");@@ -3690,6 +3743,72 @@ impl RendererInspectorCommandEnvelope {command}+ pub(crate) fn is_main_protocol_command_with_deferred_response(&self) -> bool {+ matches!(+ self.main_thread_payload(),+ RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {+ ..+ } | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {+ ..+ }+ )+ }++ pub(crate) fn main_protocol_raw_json(&self) -> &str {+ match self.main_thread_payload() {+ RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {+ raw_json,+ ..+ }+ | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {+ raw_json,+ ..+ } => raw_json,+ _ => panic!("only a deferred Main protocol command can enter the nested receiver"),+ }+ }++ pub(crate) fn main_protocol_response(&self) -> &RendererRuntimeInspectorResponseSender {+ match self.main_thread_payload() {+ RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {+ deferred_response,+ ..+ }+ | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {+ deferred_response,+ ..+ } => deferred_response,+ _ => panic!("only a deferred Main protocol command can enter the nested receiver"),+ }+ }++ pub(crate) fn into_main_protocol_parts(+ self,+ ) -> (+ RendererInspectorIngressTicket,+ String,+ RendererRuntimeInspectorResponseSender,+ ) {+ assert!(+ self.main_ingress_first_dispatch.is_none(),+ "a direct nested Main dispatch must keep its first-dispatch guard outside the envelope"+ );+ match self.payload {+ RendererInspectorCommandPayload::MainThread(+ RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {+ raw_json,+ deferred_response,+ }+ | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {+ raw_json,+ deferred_response,+ ..+ },+ ) => (self.ticket, raw_json, deferred_response),+ _ => panic!("only a deferred Main protocol command can enter the nested receiver"),+ }+ }+pub(crate) fn io_raw_json(&self) -> &str {let RendererInspectorCommandPayload::Io { raw_json, .. } = &self.payload else {panic!("a MainThread Inspector envelope cannot enter IO dispatch");@@ -4395,6 +4514,10 @@ 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>,route: RendererInspectorCommandRoute,@@ -4746,6 +4869,10 @@ impl RendererPageCommand {}}+ pub(crate) fn uses_main_inspector_ingress_admission(&self) -> bool {+ matches!(self, Self::Inspector(envelope) if envelope.uses_main_ingress_admission())+ }+pub fn bind_inspector_attachment(&mut self, attachment: RendererAgentAttachmentId) {if let Self::Inspector(envelope) = self {envelope.bind_attachment(attachment);diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rsindex 87b063efb..d6ea52e4e 100644--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs@@ -1838,6 +1838,12 @@ impl PageVm {self.vm().inspector_io_ingress()}+ pub(crate) fn inspector_main_ingress(+ &self,+ ) -> crate::script_vm::inspector_main::RendererInspectorMainIngress {+ self.vm().inspector_main_ingress()+ }+pub(super) fn close_for_context_teardown(&mut self) {let _ = self.document_lifecycle.request_termination(self.document_lifecycle.identity(),diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rsindex 7e2d56c39..1fc987fb2 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs@@ -6031,15 +6031,18 @@ async fn audio_worklet_json_static_import_uses_json_fetch_destination() {.await;}-#[tokio::test]-async fn audio_worklet_static_css_import_rejects_invalid_module_type_without_fetching_dependency() {- run_audio_worklet_static_invalid_module_type_import_test("css", "style.css").await;+#[test]+fn audio_worklet_static_css_import_rejects_invalid_module_type_without_fetching_dependency() {+ run_page_vm_large_stack_async_test("audio-worklet-static-css-invalid-type", || async {+ run_audio_worklet_static_invalid_module_type_import_test("css", "style.css").await;+ });}-#[tokio::test]-async fn audio_worklet_static_text_import_rejects_invalid_module_type_without_fetching_dependency()-{- run_audio_worklet_static_invalid_module_type_import_test("text", "text.txt").await;+#[test]+fn audio_worklet_static_text_import_rejects_invalid_module_type_without_fetching_dependency() {+ run_page_vm_large_stack_async_test("audio-worklet-static-text-invalid-type", || async {+ run_audio_worklet_static_invalid_module_type_import_test("text", "text.txt").await;+ });}#[tokio::test]@@ -6759,10 +6762,8 @@ async fn run_audio_worklet_static_invalid_module_type_import_test(module_type: &'static str,dependency_file: &'static str,) {- run_page_vm_async_test(async move {- let (base_url, dependency_request_rx, server) =- spawn_audio_worklet_static_invalid_module_type_server(module_type, dependency_file)- .await;+ let (base_url, dependency_request_rx, server) =+ spawn_audio_worklet_static_invalid_module_type_server(module_type, dependency_file).await;let document_url = Url::parse(&format!("{base_url}/page.html")).expect("document url");let module_url = format!("{base_url}/worklet/entry.js");let module_url_literal =@@ -6817,12 +6818,10 @@ async fn run_audio_worklet_static_invalid_module_type_import_test()),"unexpected AudioWorklet invalid static module type result: {result}");- assert_eq!(- dependency_request, None,- "AudioWorklet invalid static module type must fail before fetching dependency"- );- })- .await;+ assert_eq!(+ dependency_request, None,+ "AudioWorklet invalid static module type must fail before fetching dependency"+ );}async fn spawn_audio_worklet_static_invalid_module_type_server(diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex c70f3a343..6c81f0cd4 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -693,8 +693,10 @@ mod input_dispatch;mod input_helpers;mod inspector;pub(crate) mod inspector_io;+pub(crate) mod inspector_main;pub(crate) mod inspector_pause;-pub(crate) use inspector::dispatch_inspector_io_owner_wake;+pub(crate) mod inspector_route;+pub(crate) use inspector::{dispatch_inspector_io_owner_wake, dispatch_inspector_main_owner_wake};mod isolated_worlds;mod main_document_lifecycle;mod main_document_lifecycle_body;@@ -1030,6 +1032,10 @@ impl ScriptVm {self.page_inspector.io_ingress()}+ pub(crate) fn inspector_main_ingress(&self) -> inspector_main::RendererInspectorMainIngress {+ self.page_inspector.main_ingress()+ }+pub(super) fn set_root_document_lifecycle(&mut self,lifecycle: crate::runtime::RendererDocumentLifecycleJournalHandle,diff --git a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rsindex e7555b4c2..aae6d3ca9 100644--- a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs+++ b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs@@ -82,7 +82,12 @@ impl RendererDevToolsSessionConnection {InspectorOutbound::for_frontend(self.agent_token,session_key.clone(),- pause_bridge.outbound_route(backend.io_ingress(), self.agent_token, session_key),+ pause_bridge.outbound_route(+ backend.main_ingress(),+ backend.io_ingress(),+ self.agent_token,+ session_key,+ ),self.output_journal.clone(),)}diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex 1a2f38a67..0944d3c42 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -29,6 +29,7 @@ use self::v8_backend::RendererInspectorClientUniqueIdState;pub(in crate::script_vm) use self::v8_backend::RendererInspectorIsolateBackend;pub(crate) use self::v8_backend::{RendererInspectorIsolateBackendHandle, dispatch_inspector_io_owner_wake,+ dispatch_inspector_main_owner_wake,};#[cfg(test)]use crate::runtime::{@@ -55,6 +56,7 @@ pub(crate) struct DocumentInspectorBinding {agent: RendererDevToolsAgent,backend: RefCell<DocumentInspectorBackendState>,pause_bridge: RendererInspectorPauseBridge,+ main_ingress: crate::script_vm::inspector_main::RendererInspectorMainIngress,io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,}@@ -96,12 +98,14 @@ pub(super) struct ReportedExecutionContext {impl DocumentInspectorBinding {pub(crate) fn new(isolate_backend: RendererInspectorIsolateBackendHandle) -> Self {let pause_bridge = isolate_backend.pause_bridge();+ let main_ingress = isolate_backend.main_ingress();let io_ingress = isolate_backend.io_ingress();Self {context_registrations: DocumentInspectorContextRegistrations::default(),agent: RendererDevToolsAgent::new(isolate_backend),backend: RefCell::new(DocumentInspectorBackendState::new()),pause_bridge,+ main_ingress,io_ingress,}}@@ -122,6 +126,12 @@ impl DocumentInspectorBinding {self.io_ingress.clone()}+ pub(crate) fn main_ingress(+ &self,+ ) -> crate::script_vm::inspector_main::RendererInspectorMainIngress {+ self.main_ingress.clone()+ }+pub(crate) fn dom_debugger_pause_scheduler(&self) -> RendererDomDebuggerPauseScheduler {self.agent.dom_debugger_pause_scheduler()}diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rsindex 530902513..3e0835b70 100644--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs@@ -717,10 +717,14 @@ mod tests {pause_bridge.pause_loop_wake(),None,);+ let main_ingress = crate::script_vm::inspector_main::RendererInspectorMainIngress::new(+ crate::script_vm::inspector_route::RendererInspectorSessionExecutorRouteId::new(1),+ pause_bridge.pause_loop_wake(),+ );let outbound = InspectorOutbound::for_frontend(agent_token,session.clone(),- pause_bridge.outbound_route(io_ingress, agent_token, session.clone()),+ pause_bridge.outbound_route(main_ingress, io_ingress, agent_token, session.clone()),Some(journal.clone()),);let recorder = RendererCommandTurnOutputRecorder::default();diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex f03d51d27..f019f014e 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -9,9 +9,14 @@ use crate::{script_vm::{inspector_io::{RendererInspectorInterruptTarget, RendererInspectorIoCommand,- RendererInspectorIoIngress, RendererInspectorIoOwnerWake, RendererInspectorIoRouteId,+ RendererInspectorIoIngress, RendererInspectorIoOwnerWake,+ },+ inspector_main::{+ RendererInspectorMainCommand, RendererInspectorMainIngress,+ RendererInspectorMainOwnerDispatch, RendererInspectorMainOwnerWake,},inspector_pause::RendererInspectorPauseBridge,+ inspector_route::RendererInspectorSessionExecutorRouteId,},};use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};@@ -27,11 +32,11 @@ use std::{};thread_local! {- static INSPECTOR_SESSION_EXECUTORS: RefCell<HashMap<RendererInspectorIoRouteId, Weak<RendererInspectorSessionExecutorLocal>>> =+ static INSPECTOR_SESSION_EXECUTORS: RefCell<HashMap<RendererInspectorSessionExecutorRouteId, Weak<RendererInspectorSessionExecutorLocal>>> =RefCell::new(HashMap::new());}-static NEXT_INTERRUPT_ROUTE_ID: AtomicUsize = AtomicUsize::new(1);+static NEXT_SESSION_EXECUTOR_ROUTE_ID: AtomicUsize = AtomicUsize::new(1);struct RendererInspectorClient {isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,@@ -59,21 +64,27 @@ pub(super) struct RendererInspectorSessionExecutorRegistration {struct RendererInspectorSessionExecutorLocal {isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,bridge: RendererInspectorPauseBridge,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,- interrupt_route_id: Option<RendererInspectorIoRouteId>,+ route_id: RendererInspectorSessionExecutorRouteId,sessions: RefCell<HashMap<(i32, DevToolsSessionKey), RendererInspectorSessionRoute>>,interrupt_sessions: RefCell<HashMap<(RendererDevToolsAgentToken, DevToolsSessionKey), RendererInspectorSessionRoute>,>,}+enum RendererInspectorNestedCommand {+ Main(RendererInspectorMainCommand),+ Io(RendererInspectorIoCommand),+}+impl Drop for RendererInspectorSessionExecutorLocal {fn drop(&mut self) {- if let Some(interrupt_route_id) = self.interrupt_route_id {- let _ = INSPECTOR_SESSION_EXECUTORS.try_with(|executors| {- executors.borrow_mut().remove(&interrupt_route_id);- });- }+ let _ = INSPECTOR_SESSION_EXECUTORS.try_with(|executors| {+ executors.borrow_mut().remove(&self.route_id);+ });+ self.main_ingress+ .close("Inspector session executor was destroyed");self.io_ingress.close("Inspector session executor was destroyed");}@@ -107,28 +118,29 @@ impl RendererInspectorSessionExecutorLocal {fn new(isolate: v8::UnsafeRawIsolatePtr,bridge: RendererInspectorPauseBridge,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,+ route_id: RendererInspectorSessionExecutorRouteId,) -> Rc<Self> {- let interrupt_route_id = io_ingress.route_id();+ debug_assert_eq!(io_ingress.route_id(), Some(route_id));let session_executor = Rc::new(Self {isolate: UnsafeCell::new(isolate),bridge,+ main_ingress,io_ingress,- interrupt_route_id,+ route_id,sessions: RefCell::new(HashMap::new()),interrupt_sessions: RefCell::new(HashMap::new()),});- if let Some(interrupt_route_id) = interrupt_route_id {- let previous = INSPECTOR_SESSION_EXECUTORS.with(|executors| {- executors- .borrow_mut()- .insert(interrupt_route_id, Rc::downgrade(&session_executor))- });- assert!(- previous.is_none(),- "renderer Inspector interrupt route IDs must be unique"- );- }+ let previous = INSPECTOR_SESSION_EXECUTORS.with(|executors| {+ executors+ .borrow_mut()+ .insert(route_id, Rc::downgrade(&session_executor))+ });+ assert!(+ previous.is_none(),+ "renderer Inspector session-executor route IDs must be unique"+ );session_executor}@@ -170,13 +182,56 @@ impl RendererInspectorSessionExecutorLocal {if !self.bridge.enter_pause() {return;}- while let Some(command) = self.io_ingress.wait_and_claim_for_pause(&self.bridge) {- self.dispatch_command(context_group_id, command);+ let mut prefer_main = true;+ while let Some(command) = self.bridge.wait_for_pause_work(|| {+ let command = 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)+ })+ };+ if command.is_some() {+ prefer_main = !prefer_main;+ }+ command+ }) {+ match command {+ RendererInspectorNestedCommand::Main(command) => {+ self.dispatch_main_command(context_group_id, command);+ }+ RendererInspectorNestedCommand::Io(command) => {+ self.dispatch_io_command(context_group_id, command);+ }+ }}self.bridge.leave_pause();}- fn dispatch_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {+ fn dispatch_io_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {+ let session_key = command.ticket().session().clone();+ let session = self+ .sessions+ .borrow()+ .get(&(context_group_id, session_key))+ .filter(|session| session.agent_token == command.agent_token)+ .cloned();+ self.dispatch_io_command_to_session(command, session);+ }++ fn dispatch_main_command(&self, context_group_id: i32, command: RendererInspectorMainCommand) {let session_key = command.ticket().session().clone();let session = self.sessions@@ -184,7 +239,7 @@ impl RendererInspectorSessionExecutorLocal {.get(&(context_group_id, session_key)).filter(|session| session.agent_token == command.agent_token).cloned();- self.dispatch_command_to_session(command, session);+ self.dispatch_main_command_to_session(command, session);}fn dispatch_next_io_command_from_interrupt(&self) {@@ -197,7 +252,7 @@ impl RendererInspectorSessionExecutorLocal {.borrow().get(&(command.agent_token, session_key.clone())).cloned();- self.dispatch_command_to_session(command, session);+ self.dispatch_io_command_to_session(command, session);}fn dispatch_next_io_command_from_owner(&self) {@@ -210,10 +265,48 @@ impl RendererInspectorSessionExecutorLocal {.borrow().get(&(command.agent_token, session_key.clone())).cloned();- self.dispatch_command_to_session(command, session);+ self.dispatch_io_command_to_session(command, session);}- fn dispatch_command_to_session(+ fn claim_next_main_command_from_owner(&self) -> Option<RendererInspectorMainOwnerDispatch> {+ let command = self.main_ingress.claim_for_owner()?;+ Some(self.main_ingress.prepare_owner_dispatch(command))+ }++ fn dispatch_main_command_to_session(+ &self,+ command: RendererInspectorMainCommand,+ session: Option<RendererInspectorSessionRoute>,+ ) {+ let mut first_dispatch = self.main_ingress.first_dispatch_guard(&command);+ let Some(session) = session else {+ let (_, _, response) = command.into_protocol_parts();+ send_inspector_dispatch_error(Some(response), "Inspector session is not available");+ return;+ };+ let Some(v8_session) = session.session.upgrade() else {+ let (_, _, response) = command.into_protocol_parts();+ send_inspector_dispatch_error(Some(response), "Inspector session has been detached");+ return;+ };+ let _command_dispatch = self.bridge.begin_command_dispatch(+ command.command_id(),+ command.ticket(),+ command.raw_json(),+ Some(command.response().call_id()),+ );+ let (_, raw_json, response) = command.into_protocol_parts();+ session.outbound.register_response_callback(response);+ let _post_dispatch_wake = first_dispatch.release_for_dispatch();+ v8_session.dispatch_protocol_message(v8::inspector::StringView::from(raw_json.as_bytes()));+ self.bridge.record_v8_state_update(+ session.agent_token,+ session.session_key,+ V8InspectorSessionState::from_bytes(v8_session.state()),+ );+ }++ fn dispatch_io_command_to_session(&self,mut command: RendererInspectorIoCommand,session: Option<RendererInspectorSessionRoute>,@@ -233,7 +326,12 @@ impl RendererInspectorSessionExecutorLocal {);return;};- let _command_dispatch = self.bridge.begin_command_dispatch(&command);+ let _command_dispatch = self.bridge.begin_command_dispatch(+ command.command_id(),+ command.ticket(),+ command.raw_json(),+ command.response().map(|response| response.call_id()),+ );if let Some(response) = command.take_response() {session.outbound.register_response_callback(response);}@@ -253,12 +351,12 @@ impl RendererInspectorSessionExecutorLocal {}}-fn allocate_interrupt_route_id() -> usize {- NEXT_INTERRUPT_ROUTE_ID+fn allocate_session_executor_route_id() -> usize {+ NEXT_SESSION_EXECUTOR_ROUTE_ID.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |current| {current.checked_add(1)})- .expect("renderer Inspector interrupt route ID exhausted")+ .expect("renderer Inspector session-executor route ID exhausted")}unsafe extern "C" fn dispatch_inspector_interrupt(@@ -309,6 +407,21 @@ pub(crate) fn dispatch_inspector_io_owner_wake(wake: RendererInspectorIoOwnerWak});}+pub(crate) fn dispatch_inspector_main_owner_wake(+ wake: RendererInspectorMainOwnerWake,+) -> Option<RendererInspectorMainOwnerDispatch> {+ INSPECTOR_SESSION_EXECUTORS+ .try_with(|executors| {+ executors+ .borrow()+ .get(&wake.route_id())+ .and_then(Weak::upgrade)+ })+ .ok()+ .flatten()+ .and_then(|session_executor| session_executor.claim_next_main_command_from_owner())+}+fn send_inspector_dispatch_error(response: Option<RendererRuntimeInspectorResponseSender>,message: &str,@@ -450,6 +563,7 @@ struct RendererInspectorIsolateBackendIdentity;pub(crate) struct RendererInspectorIsolateBackendHandle {identity: Rc<RendererInspectorIsolateBackendIdentity>,pause_bridge: RendererInspectorPauseBridge,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,}@@ -467,6 +581,7 @@ pub(in crate::script_vm) struct RendererInspectorIsolateBackend {pub(super) context_registry: DocumentInspectorContextRegistry,unique_id_state: Rc<RendererInspectorClientUniqueIdState>,pause_bridge: RendererInspectorPauseBridge,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,session_executor: Rc<RendererInspectorSessionExecutorLocal>,}@@ -477,18 +592,24 @@ impl RendererInspectorIsolateBackend {let context_registry = DocumentInspectorContextRegistry::default();let unique_id_state = Rc::new(RendererInspectorClientUniqueIdState::new());let pause_bridge = RendererInspectorPauseBridge::default();+ let route_id =+ RendererInspectorSessionExecutorRouteId::new(allocate_session_executor_route_id());+ let main_ingress =+ RendererInspectorMainIngress::new(route_id, pause_bridge.pause_loop_wake());let io_ingress = RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(),Some((isolate.thread_safe_handle(),dispatch_inspector_interrupt,- RendererInspectorIoRouteId::new(allocate_interrupt_route_id()),+ route_id,)),);let session_executor = RendererInspectorSessionExecutorLocal::new(isolate_ptr,pause_bridge.clone(),+ main_ingress.clone(),io_ingress.clone(),+ route_id,);let inspector_client =v8::inspector::V8InspectorClient::new(Box::new(RendererInspectorClient::new(@@ -503,6 +624,7 @@ impl RendererInspectorIsolateBackend {context_registry,unique_id_state,pause_bridge,+ main_ingress,io_ingress,session_executor,}@@ -512,6 +634,7 @@ impl RendererInspectorIsolateBackend {RendererInspectorIsolateBackendHandle {identity: Rc::clone(&self.identity),pause_bridge: self.pause_bridge.clone(),+ main_ingress: self.main_ingress.clone(),io_ingress: self.io_ingress.clone(),}}@@ -524,6 +647,10 @@ impl RendererInspectorIsolateBackend {self.io_ingress.clone()}+ pub(super) fn main_ingress(&self) -> RendererInspectorMainIngress {+ self.main_ingress.clone()+ }+pub(super) fn register_session_executor_route(&self,context_group_id: DocumentInspectorContextGroupId,@@ -642,6 +769,10 @@ impl RendererInspectorIsolateBackendHandle {self.io_ingress.clone()}+ pub(super) fn main_ingress(&self) -> RendererInspectorMainIngress {+ self.main_ingress.clone()+ }+pub(super) fn assert_matches(&self, backend: &RendererInspectorIsolateBackend) {assert!(Rc::ptr_eq(&self.identity, &backend.identity),@@ -652,10 +783,14 @@ impl RendererInspectorIsolateBackendHandle {#[cfg(test)]pub(super) fn new_for_test() -> Self {let pause_bridge = RendererInspectorPauseBridge::default();+ let route_id = RendererInspectorSessionExecutorRouteId::new(1);+ let main_ingress =+ RendererInspectorMainIngress::new(route_id, pause_bridge.pause_loop_wake());let io_ingress = RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(), None);Self {identity: Rc::new(RendererInspectorIsolateBackendIdentity),pause_bridge,+ main_ingress,io_ingress,}}diff --git a/moli-renderer-v8/src/script_vm/inspector_io.rs b/moli-renderer-v8/src/script_vm/inspector_io.rsindex 4f2811d5e..0d92802fa 100644--- a/moli-renderer-v8/src/script_vm/inspector_io.rs+++ b/moli-renderer-v8/src/script_vm/inspector_io.rs@@ -1,7 +1,6 @@use std::{collections::{BTreeMap, VecDeque},ffi::c_void,- num::NonZeroUsize,sync::{Arc,atomic::{AtomicBool, Ordering},@@ -17,27 +16,21 @@ use crate::{RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,RendererInspectorIngressTicket, RendererRuntimeInspectorResponseSender,},- script_vm::inspector_pause::RendererInspectorPauseLoopWake,+ script_vm::{+ inspector_pause::RendererInspectorPauseLoopWake,+ inspector_route::RendererInspectorSessionExecutorRouteId,+ },};type RendererInspectorInterruptCallback =unsafe extern "C" fn(v8::UnsafeRawIsolatePtr, *mut c_void);-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]-pub(crate) struct RendererInspectorIoRouteId(NonZeroUsize);--impl RendererInspectorIoRouteId {- pub(crate) fn new(raw: usize) -> Self {- Self(NonZeroUsize::new(raw).expect("Inspector IO route ID must be non-zero"))- }-}-pub(crate) struct RendererInspectorInterruptTarget {- route_id: RendererInspectorIoRouteId,+ route_id: RendererInspectorSessionExecutorRouteId,}impl RendererInspectorInterruptTarget {- pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {+ pub(crate) fn route_id(&self) -> RendererInspectorSessionExecutorRouteId {self.route_id}}@@ -152,11 +145,11 @@ struct RendererInspectorInterruptRoute {#[derive(Clone)]pub(crate) struct RendererInspectorIoOwnerWake {- route_id: RendererInspectorIoRouteId,+ route_id: RendererInspectorSessionExecutorRouteId,}impl RendererInspectorIoOwnerWake {- pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {+ pub(crate) fn route_id(&self) -> RendererInspectorSessionExecutorRouteId {self.route_id}}@@ -246,7 +239,7 @@ impl RendererInspectorIoIngress {interrupt_route: Option<(v8::IsolateHandle,RendererInspectorInterruptCallback,- RendererInspectorIoRouteId,+ RendererInspectorSessionExecutorRouteId,)>,) -> Self {Self {@@ -271,7 +264,7 @@ impl RendererInspectorIoIngress {}}- pub(crate) fn route_id(&self) -> Option<RendererInspectorIoRouteId> {+ pub(crate) fn route_id(&self) -> Option<RendererInspectorSessionExecutorRouteId> {self.shared.interrupt_route.as_ref()@@ -377,6 +370,7 @@ impl RendererInspectorIoIngress {self.claim_next(RendererInspectorIoCommandConsumer::Pause)}+ #[cfg(test)]pub(crate) fn wait_and_claim_for_pause(&self,pause_bridge: &crate::script_vm::inspector_pause::RendererInspectorPauseBridge,diff --git a/moli-renderer-v8/src/script_vm/inspector_main.rs b/moli-renderer-v8/src/script_vm/inspector_main.rsnew file mode 100644index 000000000..e0e95d5e6--- /dev/null+++ b/moli-renderer-v8/src/script_vm/inspector_main.rs@@ -0,0 +1,850 @@+use std::{+ collections::{BTreeMap, VecDeque},+ sync::{+ Arc,+ atomic::{AtomicBool, Ordering},+ },+};++use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};+use parking_lot::Mutex;+use serde_json::json;++use crate::{+ render_runtime::RenderRuntimeHandle,+ runtime::{+ RendererCommandTurnOutput, RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorIngressTicket, RendererOwnerReply, RendererPageStateCapturePolicy,+ RendererPageToken, RendererRuntimeInspectorResponseSender,+ },+ script_vm::{+ inspector_pause::RendererInspectorPauseLoopWake,+ inspector_route::RendererInspectorSessionExecutorRouteId,+ },+};++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererInspectorMainCommandConsumer {+ Owner,+ Pause,+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+enum RendererInspectorMainCommandClaim {+ Owner,+ Inspector,+ Canceled,+}++pub enum RendererRuntimeInspectorMainCommandCompletion {+ Owner(Box<RendererCommandTurnOutput>),+ Inspector,+ Canceled,+}++pub(crate) struct RendererInspectorMainCommand {+ command_id: u64,+ page_token: RendererPageToken,+ pub(crate) agent_token: RendererDevToolsAgentToken,+ capture_policy: RendererPageStateCapturePolicy,+ pause_dispatch_allowed: bool,+ envelope: RendererInspectorCommandEnvelope,+ claim_tx: Option<tokio::sync::oneshot::Sender<RendererInspectorMainCommandClaim>>,+ owner_reply_tx: Option<tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>>,+ claimed_by: Option<RendererInspectorMainCommandConsumer>,+}++impl RendererInspectorMainCommand {+ pub(crate) fn command_id(&self) -> u64 {+ self.command_id+ }++ pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {+ self.envelope.ticket()+ }++ pub(crate) fn first_dispatch_lifecycle(+ &self,+ ) -> crate::runtime::RendererInspectorFirstDispatchLifecycle {+ self.envelope.first_dispatch_lifecycle()+ }++ pub(crate) fn raw_json(&self) -> &str {+ self.envelope.main_protocol_raw_json()+ }++ pub(crate) fn response(&self) -> &RendererRuntimeInspectorResponseSender {+ self.envelope.main_protocol_response()+ }++ pub(crate) fn into_protocol_parts(+ self,+ ) -> (+ RendererInspectorIngressTicket,+ String,+ RendererRuntimeInspectorResponseSender,+ ) {+ self.envelope.into_main_protocol_parts()+ }++ #[cfg(test)]+ fn claimed_by(&self) -> Option<RendererInspectorMainCommandConsumer> {+ self.claimed_by+ }+}++pub struct RendererRuntimeInspectorMainCommandRoute {+ command_id: u64,+ ticket: RendererInspectorIngressTicket,+ claim_rx: Option<tokio::sync::oneshot::Receiver<RendererInspectorMainCommandClaim>>,+ owner_reply_rx: Option<tokio::sync::oneshot::Receiver<anyhow::Result<RendererOwnerReply>>>,+ ingress: RendererInspectorMainIngress,+}++impl RendererRuntimeInspectorMainCommandRoute {+ pub fn ticket(&self) -> &RendererInspectorIngressTicket {+ &self.ticket+ }++ pub async fn wait_for_completion(+ mut self,+ ) -> anyhow::Result<RendererRuntimeInspectorMainCommandCompletion> {+ let claim = self+ .claim_rx+ .take()+ .expect("runtime inspector Main command claim receiver should only be awaited once")+ .await+ .map_err(|_| anyhow::anyhow!("runtime inspector Main command claim channel closed"))?;+ match claim {+ RendererInspectorMainCommandClaim::Owner => {+ let reply = self+ .owner_reply_rx+ .take()+ .expect("an owner-claimed Main command must retain its owner reply receiver")+ .await+ .map_err(|_| {+ anyhow::anyhow!("runtime inspector Main owner reply channel closed")+ })??;+ match reply {+ RendererOwnerReply::AsyncPageCommandRan(output) => {+ Ok(RendererRuntimeInspectorMainCommandCompletion::Owner(output))+ }+ _ => Err(anyhow::anyhow!(+ "runtime inspector Main owner returned an unexpected renderer reply"+ )),+ }+ }+ RendererInspectorMainCommandClaim::Inspector => {+ Ok(RendererRuntimeInspectorMainCommandCompletion::Inspector)+ }+ RendererInspectorMainCommandClaim::Canceled => {+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)+ }+ }+ }+}++impl Drop for RendererRuntimeInspectorMainCommandRoute {+ fn drop(&mut self) {+ self.ingress.cancel_queued_command(+ self.command_id,+ "Runtime inspector Main route was canceled before dispatch",+ );+ }+}++#[derive(Clone)]+pub(crate) struct RendererInspectorMainIngress {+ shared: Arc<RendererInspectorMainShared>,+}++struct RendererInspectorMainShared {+ state: Mutex<RendererInspectorMainState>,+ owner_wake_armed: AtomicBool,+ route_id: RendererInspectorSessionExecutorRouteId,+ pause_wake: RendererInspectorPauseLoopWake,+}++#[derive(Clone)]+pub(crate) struct RendererInspectorMainOwnerWake {+ route_id: RendererInspectorSessionExecutorRouteId,+}++impl RendererInspectorMainOwnerWake {+ pub(crate) fn route_id(&self) -> RendererInspectorSessionExecutorRouteId {+ self.route_id+ }+}++#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]+struct RendererInspectorMainSessionLaneKey {+ agent_token: RendererDevToolsAgentToken,+ session: DevToolsSessionKey,+}++#[derive(Default)]+struct RendererInspectorMainSessionLane {+ active_command_id: Option<u64>,+ queued: VecDeque<RendererInspectorMainCommand>,+ ready: bool,+ detached: bool,+}++struct RendererInspectorMainState {+ next_command_id: u64,+ sessions: BTreeMap<RendererInspectorMainSessionLaneKey, RendererInspectorMainSessionLane>,+ ready_sessions: VecDeque<RendererInspectorMainSessionLaneKey>,+ owner_runtime: Option<RenderRuntimeHandle>,+ closed: bool,+}++pub(crate) struct RendererInspectorMainFirstDispatchGuard {+ ingress: RendererInspectorMainIngress,+ active: Option<(RendererInspectorMainSessionLaneKey, u64)>,+}++pub(crate) struct RendererInspectorMainPostDispatchWakeGuard {+ ingress: Option<RendererInspectorMainIngress>,+}++pub(crate) struct RendererInspectorMainOwnerDispatch {+ page_token: RendererPageToken,+ capture_policy: RendererPageStateCapturePolicy,+ envelope: RendererInspectorCommandEnvelope,+ reply_tx: tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>,+}++impl RendererInspectorMainOwnerDispatch {+ pub(crate) fn into_parts(+ self,+ ) -> (+ RendererPageToken,+ RendererPageStateCapturePolicy,+ RendererInspectorCommandEnvelope,+ tokio::sync::oneshot::Sender<anyhow::Result<RendererOwnerReply>>,+ ) {+ (+ self.page_token,+ self.capture_policy,+ self.envelope,+ self.reply_tx,+ )+ }+}++impl Drop for RendererInspectorMainFirstDispatchGuard {+ fn drop(&mut self) {+ self.release();+ }+}++impl RendererInspectorMainFirstDispatchGuard {+ pub(crate) fn release(&mut self) {+ if self.release_lane() {+ self.ingress.notify_execution_opportunities();+ }+ }++ pub(crate) fn release_for_dispatch(&mut self) -> RendererInspectorMainPostDispatchWakeGuard {+ let has_ready = self.release_lane();+ RendererInspectorMainPostDispatchWakeGuard {+ ingress: has_ready.then(|| self.ingress.clone()),+ }+ }++ fn release_lane(&mut self) -> bool {+ let Some((lane, command_id)) = self.active.take() else {+ return false;+ };+ self.ingress.finish_first_dispatch(lane, command_id)+ }+}++impl Drop for RendererInspectorMainPostDispatchWakeGuard {+ fn drop(&mut self) {+ if let Some(ingress) = self.ingress.take() {+ ingress.notify_execution_opportunities();+ }+ }+}++impl RendererInspectorMainIngress {+ pub(crate) fn new(+ route_id: RendererInspectorSessionExecutorRouteId,+ pause_wake: RendererInspectorPauseLoopWake,+ ) -> Self {+ Self {+ shared: Arc::new(RendererInspectorMainShared {+ state: Mutex::new(RendererInspectorMainState {+ next_command_id: 1,+ sessions: BTreeMap::new(),+ ready_sessions: VecDeque::new(),+ owner_runtime: None,+ closed: false,+ }),+ owner_wake_armed: AtomicBool::new(false),+ route_id,+ pause_wake,+ }),+ }+ }++ pub(crate) fn configure_owner_wake(&self, owner_runtime: RenderRuntimeHandle) {+ let has_ready = {+ let mut state = self.shared.state.lock();+ state.owner_runtime = Some(owner_runtime);+ !state.ready_sessions.is_empty()+ };+ if has_ready {+ self.notify_execution_opportunities();+ }+ }++ pub(crate) fn enqueue_command(+ &self,+ page_token: RendererPageToken,+ agent_token: RendererDevToolsAgentToken,+ envelope: RendererInspectorCommandEnvelope,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ self.enqueue_with_policy(+ page_token,+ agent_token,+ envelope,+ RendererPageStateCapturePolicy::ProtocolTurn,+ true,+ )+ }++ pub(crate) fn enqueue_owner_command(+ &self,+ page_token: RendererPageToken,+ agent_token: RendererDevToolsAgentToken,+ envelope: RendererInspectorCommandEnvelope,+ capture_policy: RendererPageStateCapturePolicy,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ self.enqueue_with_policy(page_token, agent_token, envelope, capture_policy, false)+ }++ fn enqueue_with_policy(+ &self,+ page_token: RendererPageToken,+ agent_token: RendererDevToolsAgentToken,+ envelope: RendererInspectorCommandEnvelope,+ capture_policy: RendererPageStateCapturePolicy,+ pause_dispatch_allowed: bool,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ assert_eq!(+ envelope.ticket().route(),+ RendererInspectorCommandRoute::MainThread,+ "only MainThread Inspector commands may enter RendererInspectorMainIngress"+ );+ assert!(+ !pause_dispatch_allowed || envelope.is_main_protocol_command_with_deferred_response(),+ "only deferred frontend protocol commands may use nested Main dispatch"+ );+ let ticket = envelope.ticket().clone();+ let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();+ let (owner_reply_tx, owner_reply_rx) = tokio::sync::oneshot::channel();+ let mut state = self.shared.state.lock();+ let command_id = state.next_command_id;+ state.next_command_id = state+ .next_command_id+ .checked_add(1)+ .expect("runtime inspector Main command ID overflow");+ let lane_key = RendererInspectorMainSessionLaneKey {+ agent_token,+ session: ticket.session().clone(),+ };+ let command = RendererInspectorMainCommand {+ command_id,+ page_token,+ agent_token,+ capture_policy,+ pause_dispatch_allowed,+ envelope,+ claim_tx: Some(claim_tx),+ owner_reply_tx: Some(owner_reply_tx),+ claimed_by: None,+ };+ if state.closed {+ drop(state);+ fail_main_command(command, "Inspector Main target is closed");+ return RendererRuntimeInspectorMainCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_rx),+ owner_reply_rx: Some(owner_reply_rx),+ ingress: self.clone(),+ };+ }+ let lane = state.sessions.entry(lane_key.clone()).or_default();+ if lane.detached {+ drop(state);+ fail_main_command(command, "Inspector Main session was detached");+ return RendererRuntimeInspectorMainCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_rx),+ owner_reply_rx: Some(owner_reply_rx),+ ingress: self.clone(),+ };+ }+ lane.queued.push_back(command);+ if lane.active_command_id.is_none() && !lane.ready {+ lane.ready = true;+ state.ready_sessions.push_back(lane_key);+ }+ drop(state);+ self.notify_execution_opportunities();+ RendererRuntimeInspectorMainCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_rx),+ owner_reply_rx: Some(owner_reply_rx),+ ingress: self.clone(),+ }+ }++ pub(crate) fn claim_for_owner(&self) -> Option<RendererInspectorMainCommand> {+ self.shared.owner_wake_armed.store(false, Ordering::Release);+ let command = self.claim_next(RendererInspectorMainCommandConsumer::Owner);+ if command.is_none() && !self.shared.state.lock().ready_sessions.is_empty() {+ self.notify_execution_opportunities();+ }+ command+ }++ pub(crate) fn claim_for_pause(&self) -> Option<RendererInspectorMainCommand> {+ self.claim_next(RendererInspectorMainCommandConsumer::Pause)+ }++ fn claim_next(+ &self,+ consumer: RendererInspectorMainCommandConsumer,+ ) -> Option<RendererInspectorMainCommand> {+ let mut state = self.shared.state.lock();+ if state.closed {+ return None;+ }+ let ready_session_count = state.ready_sessions.len();+ for _ in 0..ready_session_count {+ let lane_key = state+ .ready_sessions+ .pop_front()+ .expect("the snapshotted Main ready-session count must remain available");+ let pause_dispatch_blocked = consumer == RendererInspectorMainCommandConsumer::Pause+ && state+ .sessions+ .get(&lane_key)+ .and_then(|lane| lane.queued.front())+ .is_some_and(|command| !command.pause_dispatch_allowed);+ if pause_dispatch_blocked {+ state.ready_sessions.push_back(lane_key);+ continue;+ }+ let Some(lane) = state.sessions.get_mut(&lane_key) else {+ continue;+ };+ lane.ready = false;+ if lane.active_command_id.is_some() {+ continue;+ }+ let Some(mut command) = lane.queued.pop_front() else {+ continue;+ };+ lane.active_command_id = Some(command.command_id);+ command.claimed_by = Some(consumer);+ if let Some(claim_tx) = command.claim_tx.take() {+ let claim = match consumer {+ RendererInspectorMainCommandConsumer::Owner => {+ RendererInspectorMainCommandClaim::Owner+ }+ RendererInspectorMainCommandConsumer::Pause => {+ RendererInspectorMainCommandClaim::Inspector+ }+ };+ let _ = claim_tx.send(claim);+ }+ if consumer == RendererInspectorMainCommandConsumer::Pause {+ command.owner_reply_tx.take();+ }+ return Some(command);+ }+ None+ }++ pub(crate) fn first_dispatch_guard(+ &self,+ command: &RendererInspectorMainCommand,+ ) -> RendererInspectorMainFirstDispatchGuard {+ let lane_key = RendererInspectorMainSessionLaneKey {+ agent_token: command.agent_token,+ session: command.ticket().session().clone(),+ };+ let state = self.shared.state.lock();+ assert_eq!(+ command.first_dispatch_lifecycle(),+ crate::runtime::RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ );+ assert_eq!(+ state+ .sessions+ .get(&lane_key)+ .and_then(|lane| lane.active_command_id),+ Some(command.command_id),+ "a claimed Inspector Main command must own its session lane"+ );+ drop(state);+ RendererInspectorMainFirstDispatchGuard {+ ingress: self.clone(),+ active: Some((lane_key, command.command_id)),+ }+ }++ pub(crate) fn prepare_owner_dispatch(+ &self,+ command: RendererInspectorMainCommand,+ ) -> RendererInspectorMainOwnerDispatch {+ assert_eq!(+ command.claimed_by,+ Some(RendererInspectorMainCommandConsumer::Owner),+ "only an owner-claimed Main command can enter a Page owner turn"+ );+ let first_dispatch = self.first_dispatch_guard(&command);+ let RendererInspectorMainCommand {+ page_token,+ capture_policy,+ mut envelope,+ owner_reply_tx,+ ..+ } = command;+ envelope.bind_main_ingress_first_dispatch(first_dispatch);+ RendererInspectorMainOwnerDispatch {+ page_token,+ capture_policy,+ envelope,+ reply_tx: owner_reply_tx+ .expect("an owner-claimed Main command must retain its owner reply sender"),+ }+ }++ fn finish_first_dispatch(+ &self,+ lane_key: RendererInspectorMainSessionLaneKey,+ command_id: u64,+ ) -> bool {+ let mut state = self.shared.state.lock();+ let (make_ready, remove_lane) = {+ let lane = state+ .sessions+ .get_mut(&lane_key)+ .expect("an active Inspector Main lane must still exist");+ assert_eq!(+ lane.active_command_id.take(),+ Some(command_id),+ "only the active Inspector Main command may release its lane"+ );+ let make_ready = !lane.detached && !lane.queued.is_empty() && !lane.ready;+ if make_ready {+ lane.ready = true;+ }+ (make_ready, lane.queued.is_empty())+ };+ if make_ready {+ state.ready_sessions.push_back(lane_key.clone());+ }+ if remove_lane {+ state.sessions.remove(&lane_key);+ }+ !state.ready_sessions.is_empty()+ }++ pub(crate) fn cancel_queued_command(&self, command_id: u64, message: &str) {+ let command = {+ let mut state = self.shared.state.lock();+ let lane_key = state.sessions.iter().find_map(|(key, lane)| {+ lane.queued+ .iter()+ .any(|command| command.command_id == command_id)+ .then(|| key.clone())+ });+ let Some(lane_key) = lane_key else {+ return;+ };+ let lane = state+ .sessions+ .get_mut(&lane_key)+ .expect("located Inspector Main lane must remain present");+ let position = lane+ .queued+ .iter()+ .position(|command| command.command_id == command_id)+ .expect("located Inspector Main command must remain queued");+ let command = lane.queued.remove(position);+ if lane.queued.is_empty() && lane.active_command_id.is_none() {+ lane.ready = false;+ state.ready_sessions.retain(|ready| ready != &lane_key);+ state.sessions.remove(&lane_key);+ }+ command+ };+ if let Some(command) = command {+ fail_main_command(command, message);+ }+ }++ pub(crate) fn detach_session(+ &self,+ agent_token: RendererDevToolsAgentToken,+ session: &DevToolsSessionKey,+ ) {+ let commands = {+ let mut state = self.shared.state.lock();+ let lane_key = RendererInspectorMainSessionLaneKey {+ agent_token,+ session: session.clone(),+ };+ state.ready_sessions.retain(|ready| ready != &lane_key);+ let Some(_) = state.sessions.get(&lane_key) else {+ return;+ };+ let (commands, remove_lane) = {+ let lane = state+ .sessions+ .get_mut(&lane_key)+ .expect("located Inspector Main lane must remain present");+ lane.ready = false;+ lane.detached = true;+ (+ lane.queued.drain(..).collect::<Vec<_>>(),+ lane.active_command_id.is_none(),+ )+ };+ if remove_lane {+ state.sessions.remove(&lane_key);+ }+ commands+ };+ for command in commands {+ fail_main_command(command, "Inspector Main session was detached");+ }+ }++ pub(crate) fn close(&self, message: &str) {+ let commands = {+ let mut state = self.shared.state.lock();+ state.closed = true;+ drain_queued_commands(&mut state)+ };+ self.shared.pause_wake.notify_all();+ for command in commands {+ fail_main_command(command, message);+ }+ }++ pub(crate) fn cancel_all_queued(&self, message: &str) {+ let commands = drain_queued_commands(&mut self.shared.state.lock());+ for command in commands {+ fail_main_command(command, message);+ }+ }++ fn notify_execution_opportunities(&self) {+ let owner_runtime = self.shared.state.lock().owner_runtime.clone();+ if let Some(owner_runtime) = owner_runtime+ && self+ .shared+ .owner_wake_armed+ .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)+ .is_ok()+ && owner_runtime+ .enqueue_inspector_main_receiver_wake(RendererInspectorMainOwnerWake {+ route_id: self.shared.route_id,+ })+ .is_err()+ {+ self.shared.owner_wake_armed.store(false, Ordering::Release);+ self.close("Inspector Main owner receiver was closed");+ return;+ }+ self.shared.pause_wake.notify_one();+ }+}++fn drain_queued_commands(+ state: &mut RendererInspectorMainState,+) -> Vec<RendererInspectorMainCommand> {+ state.ready_sessions.clear();+ let commands = state+ .sessions+ .values_mut()+ .flat_map(|lane| lane.queued.drain(..))+ .collect();+ state+ .sessions+ .retain(|_, lane| lane.active_command_id.is_some());+ commands+}++fn fail_main_command(command: RendererInspectorMainCommand, message: &str) {+ let RendererInspectorMainCommand {+ envelope,+ claim_tx,+ owner_reply_tx,+ ..+ } = command;+ if let Some(claim_tx) = claim_tx {+ let _ = claim_tx.send(RendererInspectorMainCommandClaim::Canceled);+ }+ if let Some(owner_reply_tx) = owner_reply_tx {+ let _ = owner_reply_tx.send(Err(anyhow::anyhow!(message.to_owned())));+ }+ if !envelope.is_main_protocol_command_with_deferred_response() {+ return;+ }+ let (_, _, response) = envelope.into_main_protocol_parts();+ let call_id = response.call_id();+ let _ = response.send(json!({+ "id": call_id,+ "error": {+ "code": -32000,+ "message": message,+ },+ }));+}++impl std::fmt::Debug for RendererInspectorMainIngress {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ let state = self.shared.state.lock();+ formatter+ .debug_struct("RendererInspectorMainIngress")+ .field("route_id", &self.shared.route_id)+ .field("session_lanes", &state.sessions.len())+ .field("ready_sessions", &state.ready_sessions.len())+ .field("closed", &state.closed)+ .finish()+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{+ runtime::{RendererInspectorIngressTicket, RendererRuntimeInspectorAsyncCompletion},+ script_vm::inspector_pause::RendererInspectorPauseBridge,+ };++ fn ingress() -> RendererInspectorMainIngress {+ let pause_bridge = RendererInspectorPauseBridge::default();+ RendererInspectorMainIngress::new(+ RendererInspectorSessionExecutorRouteId::new(1),+ pause_bridge.pause_loop_wake(),+ )+ }++ fn enqueue(+ ingress: &RendererInspectorMainIngress,+ agent_token: RendererDevToolsAgentToken,+ session: Option<&str>,+ raw_json: &str,+ ) -> RendererRuntimeInspectorMainCommandRoute {+ let (response_tx, _response_rx) =+ tokio::sync::oneshot::channel::<RendererRuntimeInspectorAsyncCompletion>();+ ingress.enqueue_command(+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(1)),+ agent_token,+ RendererInspectorCommandEnvelope::new_main_protocol(+ RendererInspectorIngressTicket::new(+ None,+ session.map(str::to_owned),+ RendererInspectorCommandRoute::MainThread,+ ),+ None,+ raw_json.to_owned(),+ RendererRuntimeInspectorResponseSender::new(1, response_tx),+ ),+ )+ }++ #[test]+ fn owner_and_pause_can_claim_one_main_command_only_once() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let _route = enqueue(&ingress, agent, Some("session-a"), "first");++ let pause = ingress.claim_for_pause();+ let owner = ingress.claim_for_owner();+ assert_eq!(+ usize::from(pause.is_some()) + usize::from(owner.is_some()),+ 1+ );+ assert_eq!(+ pause.and_then(|command| command.claimed_by()),+ Some(RendererInspectorMainCommandConsumer::Pause)+ );+ }++ #[test]+ fn main_ingress_is_fifo_per_session_and_independent_across_sessions() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let _a1 = enqueue(&ingress, agent, Some("session-a"), "a1");+ let _a2 = enqueue(&ingress, agent, Some("session-a"), "a2");+ let _b1 = enqueue(&ingress, agent, Some("session-b"), "b1");++ let first = ingress.claim_for_owner().expect("first ready Main session");+ assert_eq!(first.raw_json(), "a1");+ let second = ingress+ .claim_for_pause()+ .expect("the other Main session remains independently ready");+ assert_eq!(second.raw_json(), "b1");+ assert!(ingress.claim_for_owner().is_none());++ ingress.first_dispatch_guard(&first).release();+ let third = ingress.claim_for_pause().expect("a2 after a1 dispatch");+ assert_eq!(third.raw_json(), "a2");+ }++ #[test]+ fn owner_only_main_command_blocks_its_session_lane_from_pause_claim() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let crate::runtime::RendererPageCommand::Inspector(envelope) =+ crate::runtime::RendererPageCommand::runtime_enable_events(None)+ else {+ panic!("Runtime.enable events must be a Main Inspector envelope");+ };+ let _route = ingress.enqueue_owner_command(+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(1)),+ agent,+ envelope,+ RendererPageStateCapturePolicy::ProtocolTurn,+ );++ assert!(ingress.claim_for_pause().is_none());+ let owner = ingress+ .claim_for_owner()+ .expect("the ordinary owner receiver must claim owner-only Main work");+ assert_eq!(+ owner.claimed_by(),+ Some(RendererInspectorMainCommandConsumer::Owner)+ );+ }++ #[test]+ #[should_panic(+ expected = "only MainThread Inspector commands may enter RendererInspectorMainIngress"+ )]+ fn io_command_cannot_enter_main_ingress() {+ let ingress = ingress();+ let _route = ingress.enqueue_command(+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(1)),+ RendererDevToolsAgentToken::allocate(),+ RendererInspectorCommandEnvelope::new_io(+ RendererInspectorIngressTicket::new(None, None, RendererInspectorCommandRoute::Io),+ r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),+ None,+ ),+ );+ }+}diff --git a/moli-renderer-v8/src/script_vm/inspector_pause.rs b/moli-renderer-v8/src/script_vm/inspector_pause.rsindex e8c5d7ec4..cd1e8d840 100644--- a/moli-renderer-v8/src/script_vm/inspector_pause.rs+++ b/moli-renderer-v8/src/script_vm/inspector_pause.rs@@ -12,12 +12,13 @@ use serde_json::json;#[cfg(test)]use crate::runtime::RendererRuntimeInspectorResponseSender;use crate::runtime::{- PageId, PendingRendererOutputRecord, RendererOutputResidenceIdentity,- RendererProtocolObservation, RendererRuntimeCommandCausalIdentity,- RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,- RendererTurnOutputJournal,+ PageId, PendingRendererOutputRecord, RendererInspectorIngressTicket,+ RendererOutputResidenceIdentity, RendererProtocolObservation,+ RendererRuntimeCommandCausalIdentity, RendererRuntimeInspectorMessage,+ RendererRuntimeInspectorMessageBatch, RendererTurnOutputJournal,};-use crate::script_vm::inspector_io::{RendererInspectorIoCommand, RendererInspectorIoIngress};+use crate::script_vm::inspector_io::RendererInspectorIoIngress;+use crate::script_vm::inspector_main::RendererInspectorMainIngress;#[derive(Clone)]pub(crate) struct RendererInspectorPauseBridge {@@ -185,6 +186,7 @@ impl Drop for RendererInspectorPausePrefaceGuard {#[derive(Clone)]pub(super) struct RendererInspectorPauseOutboundRoute {bridge: RendererInspectorPauseBridge,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,agent_token: RendererDevToolsAgentToken,session: DevToolsSessionKey,@@ -252,12 +254,14 @@ impl RendererInspectorPauseBridge {pub(super) fn outbound_route(&self,+ main_ingress: RendererInspectorMainIngress,io_ingress: RendererInspectorIoIngress,agent_token: RendererDevToolsAgentToken,session: DevToolsSessionKey,) -> RendererInspectorPauseOutboundRoute {RendererInspectorPauseOutboundRoute {bridge: self.clone(),+ main_ingress,io_ingress,agent_token,session,@@ -278,27 +282,26 @@ impl RendererInspectorPauseBridge {pub(super) fn begin_command_dispatch(&self,- command: &RendererInspectorIoCommand,+ command_id: u64,+ ticket: &RendererInspectorIngressTicket,+ raw_json: &str,+ response_call_id: Option<i32>,) -> RendererInspectorPauseCommandDispatchGuard {- let effect = RendererInspectorPauseCommandEffect::from_raw_json(command.raw_json());+ let effect = RendererInspectorPauseCommandEffect::from_raw_json(raw_json);if effect == RendererInspectorPauseCommandEffect::None {return RendererInspectorPauseCommandDispatchGuard {bridge: self.clone(),command_id: None,};}- let Some(call_id) = command.response().map(|response| response.call_id()) else {+ let Some(call_id) = response_call_id else {return RendererInspectorPauseCommandDispatchGuard {bridge: self.clone(),command_id: None,};};let causal_identity = RendererRuntimeCommandCausalIdentity::new(- command- .ticket()- .session()- .wire_session_id()- .map(str::to_owned),+ ticket.session().wire_session_id().map(str::to_owned),call_id,);let mut state = self.shared.state.lock();@@ -308,7 +311,7 @@ impl RendererInspectorPauseBridge {"Inspector pause commands must dispatch serially in the nested loop");state.active_command_dispatch = Some(RendererInspectorPauseCommandDispatch {- command_id: command.command_id(),+ command_id,transition: RendererInspectorPauseCommandTransition {causal_identity,effect,@@ -319,7 +322,7 @@ impl RendererInspectorPauseBridge {});RendererInspectorPauseCommandDispatchGuard {bridge: self.clone(),- command_id: Some(command.command_id()),+ command_id: Some(command_id),}}@@ -465,8 +468,9 @@ impl RendererInspectorPauseBridge {let mut state = self.shared.state.lock();state.phase = RendererInspectorPausePhase::Running;state.quit_requested = false;- // IO commands that lost the nested-loop race stay in their dedicated- // ingress and retain independent owner/interrupt execution chances.+ // Commands that lost the nested-loop race stay in their route-specific+ // ingress. Main retains its owner task; IO retains owner and interrupt+ // execution chances.}pub(crate) fn detach_page(&self, page_id: PageId) -> bool {@@ -534,7 +538,7 @@ impl RendererInspectorPauseBridge {).resolve().unwrap_or_else(|_| {- panic!("Inspector IO state update must have resolved source identity")+ panic!("Inspector state update must have resolved source identity")}),);}@@ -665,6 +669,8 @@ impl RendererInspectorPauseOutboundRoute {pub(super) fn detach_session(&self) {self.bridge.detach_session(self.agent_token, &self.session);+ self.main_ingress+ .detach_session(self.agent_token, &self.session);self.io_ingress.detach_session(self.agent_token, &self.session);}@@ -705,6 +711,15 @@ mod tests {)}+ fn main_ingress(+ bridge: &RendererInspectorPauseBridge,+ ) -> crate::script_vm::inspector_main::RendererInspectorMainIngress {+ crate::script_vm::inspector_main::RendererInspectorMainIngress::new(+ crate::script_vm::inspector_route::RendererInspectorSessionExecutorRouteId::new(1),+ bridge.pause_loop_wake(),+ )+ }+fn configure_page(bridge: &RendererInspectorPauseBridge, page_id: PageId) {bridge.configure_page_route(RendererTurnOutputJournal::new(crate::runtime::RendererOutputStreamIdentity::new_page(@@ -726,6 +741,7 @@ mod tests {io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,) -> RendererInspectorPauseOutboundRoute {bridge.outbound_route(+ main_ingress(bridge),io_ingress,RendererDevToolsAgentToken::allocate(),DevToolsSessionKey::Primary,@@ -824,7 +840,12 @@ mod tests {.expect("the nested pause loop should claim stepOut");let first_dispatch = io_ingress.first_dispatch_guard(&command);assert_eq!(command.ticket(), command_route.ticket());- let dispatch = bridge.begin_command_dispatch(&command);+ let dispatch = bridge.begin_command_dispatch(+ command.command_id(),+ command.ticket(),+ command.raw_json(),+ command.response().map(|response| response.call_id()),+ );outbound.mark_command_response(41, true);drop(dispatch);drop(first_dispatch);@@ -882,7 +903,12 @@ mod tests {.wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");let first_dispatch = io_ingress.first_dispatch_guard(&command);- let dispatch = bridge.begin_command_dispatch(&command);+ let dispatch = bridge.begin_command_dispatch(+ command.command_id(),+ command.ticket(),+ command.raw_json(),+ command.response().map(|response| response.call_id()),+ );outbound.mark_command_response(43, true);drop(dispatch);drop(first_dispatch);@@ -933,7 +959,12 @@ mod tests {.wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");let first_dispatch = io_ingress.first_dispatch_guard(&command);- let dispatch = bridge.begin_command_dispatch(&command);+ let dispatch = bridge.begin_command_dispatch(+ command.command_id(),+ command.ticket(),+ command.raw_json(),+ command.response().map(|response| response.call_id()),+ );outbound.mark_command_response(42, false);drop(dispatch);drop(first_dispatch);diff --git a/moli-renderer-v8/src/script_vm/inspector_route.rs b/moli-renderer-v8/src/script_vm/inspector_route.rsnew file mode 100644index 000000000..dae978841--- /dev/null+++ b/moli-renderer-v8/src/script_vm/inspector_route.rs@@ -0,0 +1,15 @@+use std::num::NonZeroUsize;++/// Identifies one isolate-local Inspector session executor.+///+/// MainThread owner wakes and IO interrupts deliberately share only this+/// final executor identity. Their queues, admission and wake mechanisms stay+/// physically separate.+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]+pub(crate) struct RendererInspectorSessionExecutorRouteId(NonZeroUsize);++impl RendererInspectorSessionExecutorRouteId {+ pub(crate) fn new(raw: usize) -> Self {+ Self(NonZeroUsize::new(raw).expect("Inspector session executor route ID must be non-zero"))+ }+}