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: split inspector IO dispatch from page owner
ldm0310b886f511d
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex 5baeb00d1..fe8311082 100644--- a/moli-core/src/page/command_dispatch.rs+++ b/moli-core/src/page/command_dispatch.rs@@ -12,8 +12,12 @@ pub struct PendingPageCommand {}pub struct PendingRuntimeInspectorCommandDispatch {- route: RendererRuntimeInspectorCommandRoute,- owner_pending: Option<PendingPageCommand>,+ kind: PendingRuntimeInspectorCommandDispatchKind,+}++enum PendingRuntimeInspectorCommandDispatchKind {+ MainThread(PendingPageCommand),+ Io(RendererRuntimeInspectorCommandRoute),}/// Identifies which execution owner consumed one routable Inspector command.@@ -85,15 +89,24 @@ impl CompletedPageCommand {impl Page {pub(crate) fn start_page_command(&self,- command: RendererPageCommand,+ mut command: RendererPageCommand,) -> Result<PendingPageCommand> {+ if let Some(attachment_id) = self.renderer_agent_attachment_id {+ command.bind_inspector_attachment(attachment_id);+ }Ok(PendingPageCommand {pending: self.handle.enqueue_protocol_command(command)?,renderer_agent_attachment_id: self.renderer_agent_attachment_id,})}- fn start_full_page_command(&self, command: RendererPageCommand) -> Result<PendingPageCommand> {+ fn start_full_page_command(+ &self,+ mut command: RendererPageCommand,+ ) -> Result<PendingPageCommand> {+ if let Some(attachment_id) = self.renderer_agent_attachment_id {+ command.bind_inspector_attachment(attachment_id);+ }Ok(PendingPageCommand {pending: self.handle.enqueue_async_command(command)?,renderer_agent_attachment_id: self.renderer_agent_attachment_id,@@ -108,14 +121,26 @@ impl Page {completion.output}- pub(crate) fn pending_runtime_inspector_command_dispatch(+ fn pending_runtime_inspector_command_dispatch(+ kind: PendingRuntimeInspectorCommandDispatchKind,+ ) -> PendingRuntimeInspectorCommandDispatch {+ PendingRuntimeInspectorCommandDispatch { kind }+ }++ pub(crate) fn pending_main_thread_runtime_inspector_command_dispatch(+ pending: PendingPageCommand,+ ) -> PendingRuntimeInspectorCommandDispatch {+ Self::pending_runtime_inspector_command_dispatch(+ PendingRuntimeInspectorCommandDispatchKind::MainThread(pending),+ )+ }++ pub(crate) fn pending_io_runtime_inspector_command_dispatch(route: RendererRuntimeInspectorCommandRoute,- owner_pending: Option<PendingPageCommand>,) -> PendingRuntimeInspectorCommandDispatch {- PendingRuntimeInspectorCommandDispatch {- route,- owner_pending,- }+ Self::pending_runtime_inspector_command_dispatch(+ PendingRuntimeInspectorCommandDispatchKind::Io(route),+ )}pub(crate) fn finish_page_command(@@ -339,53 +364,14 @@ impl PendingPageCommand {impl PendingRuntimeInspectorCommandDispatch {pub async fn wait(self) -> Result<CompletedRuntimeInspectorCommandDispatch> {- let Self {- route,- owner_pending,- } = self;- let Some(owner_pending) = owner_pending else {- let claim = route.wait_for_claim().await.map_err(anyhow::Error::msg)?;- return match claim {- RendererRuntimeInspectorCommandClaim::Owner => Err(anyhow::anyhow!(- "runtime inspector command was claimed by owner without an owner task"- )),- RendererRuntimeInspectorCommandClaim::Inspector => {- Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)- }- RendererRuntimeInspectorCommandClaim::Canceled => {- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)- }- };- };-- let mut claim = Box::pin(route.wait_for_claim());- let mut owner = Box::pin(owner_pending.wait());- tokio::select! {- biased;- claim = &mut claim => {- let claim = claim.map_err(anyhow::Error::msg)?;- match claim {- RendererRuntimeInspectorCommandClaim::Owner => owner- .await- .map(Box::new)- .map(CompletedRuntimeInspectorCommandDispatch::Owner),- RendererRuntimeInspectorCommandClaim::Inspector => {- Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)- }- RendererRuntimeInspectorCommandClaim::Canceled => {- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)- }- }- }- owner = &mut owner => {- let completion = owner?;- let claim = claim.await.map_err(anyhow::Error::msg)?;- match claim {- RendererRuntimeInspectorCommandClaim::Owner => {- Ok(CompletedRuntimeInspectorCommandDispatch::Owner(Box::new(- completion,- )))- }+ match self.kind {+ PendingRuntimeInspectorCommandDispatchKind::MainThread(pending) => pending+ .wait()+ .await+ .map(Box::new)+ .map(CompletedRuntimeInspectorCommandDispatch::Owner),+ PendingRuntimeInspectorCommandDispatchKind::Io(route) => {+ match route.wait_for_claim().await.map_err(anyhow::Error::msg)? {RendererRuntimeInspectorCommandClaim::Inspector => {Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)}diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex 3f978c5df..0e749fca6 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -16,7 +16,8 @@ use crate::RendererOutputFence;use crate::renderer::{RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListenerBreakpoint,RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint,- RendererInspectorCommandRoute, RendererPageCommand, RendererPageReply,+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorIngressTicket, RendererPageCommand, RendererPageReply,RendererPerformanceMetricSnapshot, RendererRuntimeHeapUsage,RendererRuntimeInspectorResponseSender,};@@ -473,35 +474,10 @@ impl Page {&self,inspector_session_id: Option<String>,raw_json: String,- ) -> Result<PendingPageCommand> {- self.start_runtime_protocol_message_for_inspector_session_with_route(- inspector_session_id,- RendererInspectorCommandRoute::MainThread,- raw_json,- )- }-- pub fn start_runtime_interrupt_protocol_message_for_inspector_session(- &self,- inspector_session_id: Option<String>,- raw_json: String,- ) -> Result<PendingPageCommand> {- self.start_runtime_protocol_message_for_inspector_session_with_route(- inspector_session_id,- RendererInspectorCommandRoute::Io,- raw_json,- )- }-- fn start_runtime_protocol_message_for_inspector_session_with_route(- &self,- inspector_session_id: Option<String>,- route: RendererInspectorCommandRoute,- raw_json: String,) -> Result<PendingPageCommand> {self.start_page_command(RendererPageCommand::dispatch_runtime_protocol_message(inspector_session_id,- route,+ RendererInspectorCommandRoute::MainThread,raw_json,))}@@ -523,26 +499,11 @@ impl Page {inspector_session_id: Option<String>,raw_json: String,deferred_response: RendererRuntimeInspectorResponseSender,- ) -> Result<PendingPageCommand> {- self.start_runtime_protocol_message_for_inspector_session_with_deferred_response_and_route(- inspector_session_id,- RendererInspectorCommandRoute::MainThread,- raw_json,- deferred_response,- )- }-- fn start_runtime_protocol_message_for_inspector_session_with_deferred_response_and_route(- &self,- inspector_session_id: Option<String>,- route: RendererInspectorCommandRoute,- raw_json: String,- deferred_response: RendererRuntimeInspectorResponseSender,) -> Result<PendingPageCommand> {self.start_page_command(RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(inspector_session_id,- route,+ RendererInspectorCommandRoute::MainThread,raw_json,deferred_response,),@@ -557,36 +518,65 @@ impl Page {raw_json: String,deferred_response: RendererRuntimeInspectorResponseSender,) -> Result<PendingRuntimeInspectorCommandDispatch> {- let route = self.handle.enqueue_routable_runtime_inspector_command(- inspector_session_id,- inspector_route,- owner_context_resolution_action,- raw_json,- deferred_response,- );- let owner_pending = if route.requires_owner_fallback() {- let command_id = route.command_id();- let command = RendererPageCommand::dispatch_queued_runtime_inspector_command(- route.metadata().clone(),- command_id,- );- match self.start_page_command(command) {- Ok(pending) => Some(pending),- Err(error) => {- self.handle.cancel_queued_runtime_inspector_command(- command_id,- "Failed to enqueue runtime inspector owner command",- );- return Err(error);+ 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,+ raw_json,+ deferred_response,+ ),+ };+ self.start_page_command(command)+ .map(Self::pending_main_thread_runtime_inspector_command_dispatch)+ }+ RendererInspectorCommandRoute::Io => {+ if owner_context_resolution_action.is_some() {+ return Err(anyhow!(+ "an IO Inspector command cannot require Page owner context resolution"+ ));}+ let route = self.handle.enqueue_runtime_inspector_io_command(+ RendererInspectorCommandEnvelope::new_io(+ RendererInspectorIngressTicket::new(+ self.renderer_agent_attachment_id,+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ raw_json,+ Some(deferred_response),+ ),+ );+ Ok(Self::pending_io_runtime_inspector_command_dispatch(route))}- } else {- None- };- Ok(Self::pending_runtime_inspector_command_dispatch(- route,- owner_pending,- ))+ }+ }++ pub fn start_runtime_inspector_io_message_without_response(+ &self,+ inspector_session_id: Option<String>,+ raw_json: String,+ ) -> Result<PendingRuntimeInspectorCommandDispatch> {+ let route = self.handle.enqueue_runtime_inspector_io_command(+ RendererInspectorCommandEnvelope::new_io(+ RendererInspectorIngressTicket::new(+ self.renderer_agent_attachment_id,+ inspector_session_id,+ RendererInspectorCommandRoute::Io,+ ),+ raw_json,+ None,+ ),+ );+ Ok(Self::pending_io_runtime_inspector_command_dispatch(route))}pub fn runtime_inspector_pause_active(&self) -> bool {diff --git a/moli-core/src/renderer.rs b/moli-core/src/renderer.rsindex ba7685fbe..d23e60d62 100644--- a/moli-core/src/renderer.rs+++ b/moli-core/src/renderer.rs@@ -17,7 +17,8 @@ pub(crate) use moli_renderer_v8::{RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListenerBreakpoint,RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint,RendererDomFocusOutcome, RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload,- RendererInspectorCommandRoute, RendererLayoutMetrics, RendererOwnerCommand,+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorIngressTicket, RendererLayoutMetrics, RendererOwnerCommand,RendererOwnerHandle, RendererOwnerReply, RendererPageCommand, RendererPageCommandPending,RendererPageCookieFacadeSnapshotReply, RendererPageDumpOptions, RendererPageHandle,RendererPageReply, RendererPageState, RendererPendingDownloadActivation,diff --git a/moli-page-types/src/inspector_identity.rs b/moli-page-types/src/inspector_identity.rsindex 5d051e19f..e4c3992ab 100644--- a/moli-page-types/src/inspector_identity.rs+++ b/moli-page-types/src/inspector_identity.rs@@ -29,7 +29,7 @@ impl DevToolsSessionKey {}}-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]pub struct RendererDevToolsAgentToken(NonZeroU64);impl RendererDevToolsAgentToken {diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rsindex a9df91f13..61204bd66 100644--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs@@ -1607,6 +1607,18 @@ async fn websocket_cdp_io_terminate_interrupts_busy_main_thread_and_skips_main_fjson!(42),"the skipped MainThread follower must run normally after termination: {observed:#?}");+ let terminate_response_index = observed+ .iter()+ .position(|message| message["id"] == json!(10_u64))+ .expect("terminateExecution response position");+ let follower_response_index = observed+ .iter()+ .position(|message| message["id"] == json!(9_u64))+ .expect("MainThread follower response position");+ assert!(+ terminate_response_index < follower_response_index,+ "the MainThread follower must not first-dispatch ahead of IO termination: {observed:#?}"+ );let _ = socket.close(None).await;abort_test_cdp_server(protocol_server).await;@@ -5010,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_responds_before_resumed_and_caller_pause() {+async fn websocket_cdp_debugger_step_out_main_thread_waits_for_io_resume() {let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"@@ -5076,64 +5088,50 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_pausjson!("inner"));- let mut stepped = send_cdp_command(+ 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(&mut socket,- 6,- "Debugger.stepOut",+ 7,+ "Debugger.resume",Some(&session_id),json!({}),).await;- if !stepped.iter().any(|message| {- message["method"] == json!("Debugger.paused")- && message["params"]["reason"] == json!("step")- && message["params"]["callFrames"][0]["functionName"] == json!("outer")- }) {- stepped.extend(+ 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(recv_until_match(&mut socket, |message| {- 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")+ saw_evaluate_response |= message["id"] == json!(5_u64);+ saw_step_response |= message["id"] == json!(6_u64);+ saw_evaluate_response && saw_step_response}).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))@@ -5143,13 +5141,33 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_pausjson!(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_allows_auxiliary_main_thread_commands() {+async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_until_resume() {let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;let (mut socket, _) = connect_async(format!("ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"@@ -5234,63 +5252,14 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {!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": 52_u64,+ "id": 7_u64,"method": "Runtime.evaluate","sessionId": auxiliary_session_id,"params": {- "expression": "Promise.resolve(43)",- "awaitPromise": true,+ "expression": "21 * 2","returnByValue": true}})@@ -5298,28 +5267,33 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {.into(),)).await- .expect("send pause-loop awaitPromise Runtime.evaluate");+ .expect("queue auxiliary MainThread Runtime.evaluate while paused");- observed.extend(- send_cdp_command(- &mut socket,- 8,- "Debugger.resume",- Some(&session_id),- json!({}),- )- .await,+ 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:#?}");- 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);+ 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,+ );}let evaluate = observed.iter()@@ -5330,14 +5304,26 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {json!(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!(- 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:#?}"+ resume_position < auxiliary_position,+ "IO resume must overtake the queued auxiliary MainThread command: {observed:#?}");let _ = socket.close(None).await;diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rsindex ac191d809..fa5ee3b36 100644--- a/moli-protocol/src/conn/runtime_eval.rs+++ b/moli-protocol/src/conn/runtime_eval.rs@@ -4246,7 +4246,9 @@ impl CdpConnection {raw_json: String,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {self.start_runtime_protocol_message_for_session_owner_with_access(- session_id, raw_json, false,+ session_id,+ raw_json,+ RendererInspectorCommandRoute::MainThread,)}@@ -4256,7 +4258,9 @@ impl CdpConnection {raw_json: String,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {self.start_runtime_protocol_message_for_session_owner_with_access(- session_id, raw_json, true,+ session_id,+ raw_json,+ RendererInspectorCommandRoute::Io,)}@@ -4264,34 +4268,37 @@ impl CdpConnection {&mut self,session_id: Option<&str>,raw_json: String,- allow_suspended_document_access: bool,+ inspector_route: RendererInspectorCommandRoute,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;let raw_json =self.rewrite_runtime_inspector_command_for_session_owner(session_id, &raw_json, None)?;let inspector_session_id =self.target_renderer_runtime_inspector_session_id_for_session(session_id);- let page = if allow_suspended_document_access {- self.runtime_session_owner_page_mut_for_interruptible_control(session_id)?- } else {- self.runtime_session_owner_page_mut(session_id)?+ let page = match inspector_route {+ RendererInspectorCommandRoute::MainThread => {+ self.runtime_session_owner_page_mut(session_id)?+ }+ RendererInspectorCommandRoute::Io => {+ self.runtime_session_owner_page_mut_for_interruptible_control(session_id)?+ }};- let pending = if allow_suspended_document_access {- page.start_runtime_interrupt_protocol_message_for_inspector_session(- inspector_session_id,- raw_json,- )- } else {- page.start_runtime_protocol_message_for_inspector_session(- inspector_session_id,- raw_json,- )+ let pending = match inspector_route {+ RendererInspectorCommandRoute::MainThread => page+ .start_runtime_protocol_message_for_inspector_session(+ inspector_session_id,+ raw_json,+ )+ .map(PendingRuntimeProtocolMessageDispatchKind::Page),+ RendererInspectorCommandRoute::Io => page+ .start_runtime_inspector_io_message_without_response(inspector_session_id, raw_json)+ .map(PendingRuntimeProtocolMessageDispatchKind::Routable),}.map_err(|error| format!("runtime inspector dispatch failed: {error}"))?;Ok(PendingRuntimeProtocolMessageDispatch {session_id: session_id.map(str::to_owned),route,- pending: PendingRuntimeProtocolMessageDispatchKind::Page(pending),+ pending,deferred_response_rx: None,})}@@ -4303,7 +4310,10 @@ impl CdpConnection {command_id: u64,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {self.start_runtime_protocol_message_for_session_owner_with_deferred_response_and_access(- session_id, descriptor, command_id, false,+ session_id,+ descriptor,+ command_id,+ RendererInspectorCommandRoute::MainThread,)}@@ -4314,7 +4324,10 @@ impl CdpConnection {command_id: u64,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {self.start_runtime_protocol_message_for_session_owner_with_deferred_response_and_access(- session_id, descriptor, command_id, true,+ session_id,+ descriptor,+ command_id,+ RendererInspectorCommandRoute::Io,)}@@ -4323,7 +4336,7 @@ impl CdpConnection {session_id: Option<&str>,descriptor: RendererCommandDescriptor,command_id: u64,- allow_suspended_document_access: bool,+ inspector_route: RendererInspectorCommandRoute,) -> Result<PendingRuntimeProtocolMessageDispatch, String> {let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;let (correlation, raw_json, response_sender, response_receiver) = self@@ -4335,11 +4348,15 @@ impl CdpConnection {)?;let inspector_session_id =self.target_renderer_runtime_inspector_session_id_for_session(session_id);- let page = match if allow_suspended_document_access {- self.runtime_session_owner_page_mut_for_interruptible_control(session_id)- } else {- self.runtime_session_owner_page_mut(session_id)- } {+ let page_result = match inspector_route {+ RendererInspectorCommandRoute::MainThread => {+ self.runtime_session_owner_page_mut(session_id)+ }+ RendererInspectorCommandRoute::Io => {+ self.runtime_session_owner_page_mut_for_interruptible_control(session_id)+ }+ };+ let page = match page_result {Ok(page) => page,Err(error) => {let removed =@@ -4350,11 +4367,7 @@ impl CdpConnection {};let pending = match page.start_routable_runtime_protocol_message_for_inspector_session(inspector_session_id,- if allow_suspended_document_access {- RendererInspectorCommandRoute::Io- } else {- RendererInspectorCommandRoute::MainThread- },+ inspector_route,None,raw_json,response_sender,diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex 79d231411..48048d339 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -248,8 +248,8 @@ pub use runtime::{RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererFrameToken,RendererGeometryQuad, RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,- RendererInspectorCommandMetadata, RendererInspectorCommandRoute,- RendererInspectorFirstDispatchLifecycle, RendererInspectorProtocolConfiguration,+ RendererInspectorCommandRoute, RendererInspectorFirstDispatchLifecycle,+ RendererInspectorIngressTicket, RendererInspectorProtocolConfiguration,RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,RendererJavaScriptDialogCompletion, RendererJavaScriptDialogId, RendererJavaScriptDialogResult,RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererLifecycleDecider,diff --git a/moli-renderer-v8/src/render_runtime.rs b/moli-renderer-v8/src/render_runtime.rsindex 3cb1b1e86..ea051414e 100644--- a/moli-renderer-v8/src/render_runtime.rs+++ b/moli-renderer-v8/src/render_runtime.rs@@ -7,6 +7,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::service_worker_runtime::ServiceWorkerRuntimeOwnerWake;use super::shared_worker_runtime::SharedWorkerRuntimeOwnerWake;@@ -92,6 +93,7 @@ impl RenderRuntimeOwner {pub(crate) fn spawn(owner: RendererOwnerHandle,page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,+ inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,) -> Self {@@ -113,6 +115,7 @@ impl RenderRuntimeOwner {owner,rx,page_wake_rx,+ inspector_io_wake_rx,shared_worker_wake_rx,service_worker_wake_rx,));@@ -232,6 +235,7 @@ async fn render_runtime_main_loop(owner: RendererOwnerHandle,rx: mpsc::UnboundedReceiver<RenderRuntimeEnvelope>,page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,+ inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,) {@@ -239,6 +243,7 @@ async fn render_runtime_main_loop(.run_render_runtime_loop(rx,page_wake_rx,+ inspector_io_wake_rx,shared_worker_wake_rx,service_worker_wake_rx,)diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex ded7813f0..f62518471 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -329,12 +329,12 @@ pub use self::page_surface::{RendererDomSearchRegistration, RendererDomSearchResultNode, RendererDomSearchResultsResolution,RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererGeometryQuad,- RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,- RendererInspectorCommandMetadata, RendererInspectorCommandRoute,- RendererInspectorFirstDispatchLifecycle, RendererInspectorProtocolConfiguration,- RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,- RendererJavaScriptDialogId, RendererJavaScriptDialogSource, RendererLayoutMetrics,- RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,+ RendererInputDispatchOutcome, RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorFirstDispatchLifecycle, RendererInspectorIngressTicket,+ RendererInspectorProtocolConfiguration, RendererInspectorProtocolConfigurationCommand,+ RendererInspectorSessionRestoreSnapshot, RendererJavaScriptDialogId,+ RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererMainDocumentCommit,+ RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics, RendererPageCommand,RendererPageCommandPostResponseContinuation, RendererPageCookieFacadeSnapshotReply,RendererPageCreationDiagnostics, RendererPageDiagnosticsSnapshot, RendererPageDumpFormat,@@ -403,7 +403,7 @@ pub use self::protocol_output::{};pub use self::service_worker_run::RendererServiceWorkerRunIdentity;pub(crate) use crate::renderer::PageVmInitStage;-pub use crate::script_vm::inspector_pause::{+pub use crate::script_vm::inspector_io::{RendererRuntimeInspectorCommandClaim, RendererRuntimeInspectorCommandRoute,};pub(crate) use crate::service_worker_runtime::{diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex f2380d92f..b5a2cd14b 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -79,7 +79,10 @@ use crate::page_task_queue::{};use crate::referrer_policy::response_referrer_policy_from_headers;use crate::render_runtime::{RenderRuntimeEnvelope, RenderRuntimeHandle, RenderRuntimeOwner};-use crate::script_vm::{PendingRuntimeEvaluateCall, RendererDocumentIsolateBootstrap};+use crate::script_vm::{+ PendingRuntimeEvaluateCall, RendererDocumentIsolateBootstrap, dispatch_inspector_io_owner_wake,+ inspector_io::RendererInspectorIoOwnerWake,+};use crate::service_worker_runtime::{ServiceWorkerRuntimeOwnerWake, service_worker_owner_wake_channel,};@@ -380,7 +383,6 @@ struct PageCommandFirstDispatchIdentity {#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]pub(super) struct PageCommandFirstDispatchLane {inspector_session: DevToolsSessionKey,- route: RendererInspectorCommandRoute,}impl RenderRuntimePendingTurn {@@ -676,16 +678,20 @@ impl RenderRuntimeTurn {) -> Option<PageCommandFirstDispatchIdentity> {match self {Self::RunLivePageCommand { token, command, .. } => {- command.inspector_metadata().map(|metadata| {+ command.inspector_ticket().map(|ticket| {+ debug_assert_eq!(+ ticket.route(),+ RendererInspectorCommandRoute::MainThread,+ "IO Inspector commands must bypass owner admission",+ );debug_assert_eq!(- metadata.first_dispatch_lifecycle(),- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ command.inspector_first_dispatch_lifecycle(),+ Some(RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,),);PageCommandFirstDispatchIdentity {token: *token,lane: PageCommandFirstDispatchLane {- inspector_session: metadata.session().clone(),- route: metadata.route(),+ inspector_session: ticket.session().clone(),},}})@@ -907,6 +913,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) inspector_io_wake_tx: mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,pub(super) browser_context_runtime: RendererBrowserContextRuntime,pub(super) owner_local_host_id: RendererOwnerLocalHostId,layout_policy: Mutex<RendererOwnerLayoutPolicyState>,@@ -1693,6 +1700,7 @@ impl RendererOwnerHandle {browser_context_runtime: RendererBrowserContextRuntime,) -> (Self, RenderRuntimeOwner) {let (page_wake_tx, page_wake_rx) = mpsc::unbounded_channel();+ let (inspector_io_wake_tx, inspector_io_wake_rx) = mpsc::unbounded_channel();let (shared_worker_wake_tx, shared_worker_wake_rx) = shared_worker_owner_wake_channel();browser_context_runtime.add_shared_worker_owner_wake_sender(shared_worker_wake_tx);let (service_worker_wake_tx, service_worker_wake_rx) = service_worker_owner_wake_channel();@@ -1706,6 +1714,7 @@ impl RendererOwnerHandle {local_executor,next_page_id,page_wake_tx,+ inspector_io_wake_tx,browser_context_runtime,owner_local_host_id,layout_policy: Mutex::new(RendererOwnerLayoutPolicyState::default()),@@ -1722,6 +1731,7 @@ impl RendererOwnerHandle {let render_runtime_owner = RenderRuntimeOwner::spawn(provisional.clone(),page_wake_rx,+ inspector_io_wake_rx,shared_worker_wake_rx,service_worker_wake_rx,);@@ -2457,10 +2467,10 @@ impl RendererOwnerHandle {}}- /// The stable Page slot owns each Inspector `(session, route)` arrival- /// order. Chromium intentionally separates main-thread and IO ingress,- /// so each route has its own FIFO lane. Only the command that owns that- /// lane enters the owner-wide runnable queue; other routes, sessions and+ /// The stable Page slot owns each MainThread Inspector session's arrival+ /// order. IO commands use their physically separate ingress and never+ /// enter this owner admission structure. Only the command that owns the+ /// session lane enters the owner-wide runnable queue; other sessions and/// non-Inspector Page commands remain independent.fn admit_page_command_first_dispatch(turn: RenderRuntimePendingTurn,@@ -2495,6 +2505,7 @@ impl RendererOwnerHandle {&self,mut rx: mpsc::UnboundedReceiver<RenderRuntimeEnvelope>,mut page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,+ mut inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,mut shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,mut service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,) {@@ -2561,6 +2572,15 @@ impl RendererOwnerHandle {if !pending_turns.has_owner_maintenance_turn() {self.enqueue_one_due_owner_maintenance_turn(&mut pending_turns);}+ // IO Inspector ingress is independent of normal owner command+ // admission. Give at most one command an owner execution+ // chance at each boundary, then continue with the ordinary+ // pending turn so sustained IO cannot starve MainThread work.+ match inspector_io_wake_rx.try_recv() {+ Ok(wake) => dispatch_inspector_io_owner_wake(wake),+ Err(mpsc::error::TryRecvError::Empty) => {}+ Err(mpsc::error::TryRecvError::Disconnected) => {}+ }if let Some(mut pending_turn) = pending_turns.pop_front() {if pending_turn.allow_command_overtake&& pending_turn.turn.page_turn_should_yield_to_ready_command()@@ -2932,6 +2952,12 @@ impl RendererOwnerHandle {&mut pending_turns,);}+ inspector_io_wake_opt = inspector_io_wake_rx.recv() => {+ let Some(wake) = inspector_io_wake_opt else {+ break;+ };+ dispatch_inspector_io_owner_wake(wake);+ }shared_worker_wake_opt = shared_worker_wake_rx.recv() => {let Some(wake) = shared_worker_wake_opt else {break;@@ -7069,16 +7095,14 @@ mod tests {}#[test]- fn first_dispatch_identity_uses_the_exact_inspector_session_and_route() {+ fn first_dispatch_identity_uses_the_exact_main_thread_inspector_session() {let token = RendererPageToken::new_for_testing(PageId::new_for_testing(8));let attached = RenderRuntimeTurn::RunLivePageCommand {token,- command: RendererPageCommand::dispatch_queued_runtime_inspector_command(- RendererInspectorCommandMetadata::new(- Some("SID-aux".to_owned()),- RendererInspectorCommandRoute::MainThread,- ),- 1,+ command: RendererPageCommand::dispatch_runtime_protocol_message(+ Some("SID-aux".to_owned()),+ RendererInspectorCommandRoute::MainThread,+ r#"{"id":1,"method":"Runtime.evaluate","params":{"expression":"1"}}"#.to_owned(),),capture_policy: RendererPageStateCapturePolicy::ProtocolTurn,};@@ -7088,16 +7112,16 @@ mod tests {token,lane: PageCommandFirstDispatchLane {inspector_session: DevToolsSessionKey::Attached("SID-aux".to_owned()),- route: RendererInspectorCommandRoute::MainThread,},}));let primary = RenderRuntimeTurn::RunLivePageCommand {token,- command: RendererPageCommand::dispatch_queued_runtime_inspector_command(- RendererInspectorCommandMetadata::new(None, RendererInspectorCommandRoute::Io),- 2,+ command: RendererPageCommand::dispatch_runtime_protocol_message(+ None,+ RendererInspectorCommandRoute::MainThread,+ r#"{"id":2,"method":"Runtime.evaluate","params":{"expression":"2"}}"#.to_owned(),),capture_policy: RendererPageStateCapturePolicy::ProtocolTurn,};@@ -7107,7 +7131,6 @@ mod tests {token,lane: PageCommandFirstDispatchLane {inspector_session: DevToolsSessionKey::Primary,- route: RendererInspectorCommandRoute::Io,},}));@@ -7140,25 +7163,13 @@ mod tests {RendererInspectorCommandRoute::MainThread,r#"{"id":1,"method":"Runtime.disable"}"#.to_owned(),));- let raw_io = turn_for(RendererPageCommand::dispatch_runtime_protocol_message(- Some("SID-shared-lane".to_owned()),- RendererInspectorCommandRoute::Io,- r#"{"id":2,"method":"Runtime.terminateExecution"}"#.to_owned(),- ));-let enable_identity = enable.live_page_command_first_dispatch_identity().expect("Runtime.enable must enter the Inspector boundary");let main_identity = raw_main.live_page_command_first_dispatch_identity().expect("raw main-thread dispatch must enter the Inspector boundary");- let io_identity = raw_io- .live_page_command_first_dispatch_identity()- .expect("raw IO dispatch must enter the Inspector boundary");-assert_eq!(enable_identity, main_identity);- assert_ne!(enable_identity, io_identity);- assert_eq!(io_identity.lane.route, RendererInspectorCommandRoute::Io);}#[test]diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex 724a92215..a8dbccaae 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -22,6 +22,7 @@ pub struct RendererAttachedPage {pub(super) javascript_dialog_broker: RendererJavaScriptDialogBroker,pub(super) inspector_pause_bridge:crate::script_vm::inspector_pause::RendererInspectorPauseBridge,+ pub(super) inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,pub(super) page_state: Arc<RendererPageState>,pub(super) creation_diagnostics: RendererPageCreationDiagnostics,pub(super) creation_artifacts: RendererPageCreationArtifacts,@@ -69,6 +70,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_io_ingress: self.inspector_io_ingress,committed_document_post_response_continuation: self.committed_document_post_response_continuation,_not_send: PhantomData,@@ -89,6 +91,7 @@ pub struct RendererPageHandle {page_context_cancel_tx: RendererPageContextCancelSender,javascript_dialog_broker: RendererJavaScriptDialogBroker,inspector_pause_bridge: crate::script_vm::inspector_pause::RendererInspectorPauseBridge,+ inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,committed_document_post_response_continuation:Option<RendererPageCommandPostResponseContinuation>,_not_send: PhantomData<Rc<()>>,@@ -163,27 +166,12 @@ impl RendererPageHandle {self.javascript_dialog_broker.take_pending()}- pub fn enqueue_routable_runtime_inspector_command(+ pub fn enqueue_runtime_inspector_io_command(&self,- inspector_session_id: Option<String>,- route: RendererInspectorCommandRoute,- owner_context_resolution_action: Option<String>,- raw_json: String,- response: RendererRuntimeInspectorResponseSender,- ) -> crate::script_vm::inspector_pause::RendererRuntimeInspectorCommandRoute {- self.inspector_pause_bridge.enqueue_command(- self.devtools_agent_token,- inspector_session_id,- route,- owner_context_resolution_action,- raw_json,- response,- )- }-- pub fn cancel_queued_runtime_inspector_command(&self, command_id: u64, message: &str) {- self.inspector_pause_bridge- .cancel_queued_command(command_id, message);+ envelope: RendererInspectorCommandEnvelope,+ ) -> RendererRuntimeInspectorCommandRoute {+ self.inspector_io_ingress+ .enqueue_command(self.devtools_agent_token, envelope)}pub fn runtime_inspector_pause_active(&self) -> bool {@@ -320,6 +308,8 @@ impl RendererPageHandle {return Ok(());};self.inspector_pause_bridge.close_target();+ self.inspector_io_ingress+ .close("Inspector target closed with its Page handle");self.javascript_dialog_broker.dismiss_pending();self.page_context_cancel_tx.cancel(RendererPageContextCancelReason::PageClosed);@@ -393,7 +383,10 @@ impl Drop for RendererPageHandle {let Some(token) = self.token.take() else {return;};- self.inspector_pause_bridge.detach_page(token.page_id);+ if self.inspector_pause_bridge.detach_page(token.page_id) {+ self.inspector_io_ingress+ .cancel_all_queued("Inspector Page handle was dropped");+ }self.javascript_dialog_broker.dismiss_pending();self.page_context_cancel_tx.cancel(RendererPageContextCancelReason::PageClosed);diff --git a/moli-renderer-v8/src/runtime/owner_local_store.rs b/moli-renderer-v8/src/runtime/owner_local_store.rsindex 42ecd262d..5ac9f37ea 100644--- a/moli-renderer-v8/src/runtime/owner_local_store.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store.rs@@ -3479,6 +3479,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_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();let devtools_agent_token = entry.page_vm().devtools_agent_token();@@ -3490,6 +3491,7 @@ impl RendererOwnerLocalStore {Ok((javascript_dialog_broker,inspector_pause_bridge,+ inspector_io_ingress,page_state,devtools_agent_token,creation_diagnostics,@@ -3517,6 +3519,7 @@ impl RendererOwnerLocalStore {|(javascript_dialog_broker,inspector_pause_bridge,+ inspector_io_ingress,page_state,devtools_agent_token,mut creation_diagnostics,@@ -3530,6 +3533,7 @@ impl RendererOwnerLocalStore {page_context_cancel_tx,javascript_dialog_broker,inspector_pause_bridge,+ inspector_io_ingress,page_state,creation_diagnostics,creation_artifacts,@@ -3971,6 +3975,10 @@ impl RendererOwnerLocalStore {.expect("an attached Page must own a renderer script environment").output_journal(),);+ attached_entry+ .page_vm()+ .inspector_io_ingress()+ .configure_owner_wake(owner.owner_state.inspector_io_wake_tx.clone());let _ = attached_entry.page_vm_mut().replay_pending_owner_wakes_after_attach(has_page_task_source);diff --git a/moli-renderer-v8/src/runtime/page_command_residence.rs b/moli-renderer-v8/src/runtime/page_command_residence.rsindex 3804afaf2..699ab33cb 100644--- a/moli-renderer-v8/src/runtime/page_command_residence.rs+++ b/moli-renderer-v8/src/runtime/page_command_residence.rs@@ -80,46 +80,38 @@ impl<Key: Ord, Command> PageCommandFirstDispatchResidence<Key, Command> {#[cfg(test)]mod tests {use super::*;- use crate::runtime::RendererInspectorCommandRoute;- type Lane = (&'static str, RendererInspectorCommandRoute);+ type Lane = &'static str;#[test]- fn each_inspector_session_and_route_owns_an_independent_fifo_dispatch_lane() {+ fn each_main_thread_inspector_session_owns_an_independent_fifo_dispatch_lane() {let mut first_page = PageCommandFirstDispatchResidence::default();let mut other_page = PageCommandFirstDispatchResidence::default();- let session_a_main: Lane = ("session-a", RendererInspectorCommandRoute::MainThread);- let session_a_io: Lane = ("session-a", RendererInspectorCommandRoute::Io);- let session_b_main: Lane = ("session-b", RendererInspectorCommandRoute::MainThread);+ let session_a: Lane = "session-a";+ let session_b: Lane = "session-b";assert_eq!(- first_page.admit(session_a_main, "a-main-first"),+ first_page.admit(session_a, "a-main-first"),Some("a-main-first"));- assert_eq!(first_page.admit(session_a_main, "a-main-second"), None);+ assert_eq!(first_page.admit(session_a, "a-main-second"), None);assert_eq!(- first_page.admit(session_a_io, "a-io-first"),- Some("a-io-first"),- "an IO command must not wait for main-thread work in the same session"- );- assert_eq!(- first_page.admit(session_b_main, "b-first"),+ first_page.admit(session_b, "b-first"),Some("b-first"),"a parked command must not block a different Inspector session");- assert_eq!(first_page.admit(session_b_main, "b-second"), None);+ assert_eq!(first_page.admit(session_b, "b-second"), None);- assert_eq!(other_page.admit(session_a_main, "other"), Some("other"));- assert_eq!(other_page.complete(&session_a_main), None);+ assert_eq!(other_page.admit(session_a, "other"), Some("other"));+ assert_eq!(other_page.complete(&session_a), None);- assert_eq!(first_page.complete(&session_b_main), Some("b-second"));- assert_eq!(first_page.complete(&session_b_main), None);- assert_eq!(first_page.complete(&session_a_io), None);- assert_eq!(first_page.complete(&session_a_main), Some("a-main-second"));- assert_eq!(first_page.complete(&session_a_main), None);+ assert_eq!(first_page.complete(&session_b), Some("b-second"));+ assert_eq!(first_page.complete(&session_b), None);+ assert_eq!(first_page.complete(&session_a), Some("a-main-second"));+ assert_eq!(first_page.complete(&session_a), None);assert_eq!(- first_page.admit(session_a_main, "a-after-idle"),+ first_page.admit(session_a, "a-after-idle"),Some("a-after-idle"));}@@ -127,17 +119,17 @@ mod tests {#[test]fn retiring_a_page_drains_waiters_and_resets_every_lane() {let mut residence = PageCommandFirstDispatchResidence::default();- let main: Lane = ("session-a", RendererInspectorCommandRoute::MainThread);- let io: Lane = ("session-a", RendererInspectorCommandRoute::Io);+ let main: Lane = "session-a";+ let other: Lane = "session-b";assert_eq!(residence.admit(main, "main-active"), Some("main-active"));assert_eq!(residence.admit(main, "main-waiting"), None);- assert_eq!(residence.admit(io, "io-active"), Some("io-active"));- assert_eq!(residence.admit(io, "io-waiting"), None);+ assert_eq!(residence.admit(other, "other-active"), Some("other-active"));+ assert_eq!(residence.admit(other, "other-waiting"), None);let mut drained = residence.drain_waiting();drained.sort_unstable();- assert_eq!(drained, ["io-waiting", "main-waiting"]);+ assert_eq!(drained, ["main-waiting", "other-waiting"]);assert_eq!(residence.admit(main, "main-after-retirement"),Some("main-after-retirement"),diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rsindex 8967ca597..7c7e0ce42 100644--- a/moli-renderer-v8/src/runtime/page_commands.rs+++ b/moli-renderer-v8/src/runtime/page_commands.rs@@ -1120,8 +1120,8 @@ impl PageVm {&mut self,envelope: RendererInspectorCommandEnvelope,) -> Result<RendererPageReply> {- let (metadata, command) = envelope.into_parts();- let inspector_session_id = metadata.session().wire_session_id();+ let (ticket, command) = envelope.into_main_thread_parts();+ let inspector_session_id = ticket.session().wire_session_id();match command {RendererInspectorPageCommand::DispatchRuntimeProtocolMessage { raw_json } => self.dispatch_runtime_protocol_message_for_inspector_session(@@ -1141,12 +1141,6 @@ impl PageVm {).map(RendererRuntimeCommandOutput::from_messages).map(RendererPageReply::RuntimeInspectorProtocolMessages),- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand {- command_id,- } => self- .dispatch_queued_runtime_inspector_command(command_id)- .map(RendererRuntimeCommandOutput::from_messages)- .map(RendererPageReply::RuntimeInspectorProtocolMessages),RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolution {action,raw_json,diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rsindex 547606750..ee5c9c2b0 100644--- a/moli-renderer-v8/src/runtime/page_dom.rs+++ b/moli-renderer-v8/src/runtime/page_dom.rs@@ -743,34 +743,6 @@ impl PageVm {)}- pub(crate) fn dispatch_queued_runtime_inspector_command(- &mut self,- command_id: u64,- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {- let pause_bridge = self.inspector_pause_bridge();- let Some(command) = pause_bridge.claim_command_for_owner(command_id) else {- return Ok(Vec::new());- };- let mut first_dispatch = pause_bridge.first_dispatch_guard(&command);- let inspector_session = command.metadata.session().clone();- let inspector_session_id = inspector_session.wire_session_id();- match command.owner_context_resolution_action.as_deref() {- Some(action) => self.dispatch_queued_runtime_protocol_message_with_context_resolution(- inspector_session_id,- action,- &command.raw_json,- command.response,- &mut first_dispatch,- ),- None => self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(- inspector_session_id,- &command.raw_json,- command.response,- Some(&mut first_dispatch),- ),- }- }-pub(crate) fn dispatch_runtime_protocol_message_for_inspector_session_with_context_resolution(&mut self,inspector_session_id: Option<&str>,@@ -830,65 +802,11 @@ impl PageVm {)}- fn dispatch_queued_runtime_protocol_message_with_context_resolution(- &mut self,- inspector_session_id: Option<&str>,- action: &str,- raw_json: &str,- deferred_response: RendererRuntimeInspectorResponseSender,- first_dispatch: &mut crate::script_vm::inspector_pause::RendererInspectorFirstDispatchGuard,- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {- if action == "evaluate" {- // The child-default fast path dispatches while probing, so expose- // its first-dispatch edge before entering that helper.- first_dispatch.release();- if let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)? {- let call_id = deferred_response.call_id();- if let Some(message) = messages.into_iter().next()- && let Err(message) =- deferred_response.send(message.into_v8_inspector_message())- {- tracing::debug!(- call_id,- message = ?message,- "dropping child-frame runtime response because deferred receiver was closed"- );- }- return Ok(Vec::new());- }- }- let prepared_json =- self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;- self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(- inspector_session_id,- &prepared_json,- deferred_response,- Some(first_dispatch),- )- }-fn dispatch_runtime_protocol_message_with_command_output(- &mut self,- inspector_session_id: Option<&str>,- raw_json: &str,- deferred_response: RendererRuntimeInspectorResponseSender,- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {- self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(- inspector_session_id,- raw_json,- deferred_response,- None,- )- }-- fn dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(&mut self,inspector_session_id: Option<&str>,raw_json: &str,mut deferred_response: RendererRuntimeInspectorResponseSender,- mut first_dispatch: Option<- &mut crate::script_vm::inspector_pause::RendererInspectorFirstDispatchGuard,- >,) -> Result<Vec<RendererRuntimeInspectorMessage>> {ensure!(self.pending_runtime_command_output.is_none(),@@ -925,9 +843,6 @@ impl PageVm {lifecycle_target:PageVmRuntimeCommandLifecycleTarget::AwaitingExplicitDocumentReplacement,});- if let Some(first_dispatch) = first_dispatch.as_mut() {- first_dispatch.release();- }let dispatch_result = self.vm_mut().dispatch_inspector_protocol_message_for_session_with_deferred_response_and_command_output(diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex 97280a3e9..9edec6359 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -22,6 +22,7 @@ use std::{cell::RefCell,collections::{BTreeMap, BTreeSet},rc::Rc,+ sync::atomic::{AtomicU64, Ordering},};use tokio::sync::oneshot;@@ -3547,26 +3548,42 @@ pub enum RendererInspectorFirstDispatchLifecycle {OrderedUntilFirstDispatch,}+static NEXT_RENDERER_INSPECTOR_INGRESS_SEQUENCE: AtomicU64 = AtomicU64::new(1);+#[derive(Clone, Debug, Eq, PartialEq)]-pub struct RendererInspectorCommandMetadata {+pub struct RendererInspectorIngressTicket {+ attachment: Option<RendererAgentAttachmentId>,session: DevToolsSessionKey,route: RendererInspectorCommandRoute,- first_dispatch: RendererInspectorFirstDispatchLifecycle,+ sequence: u64,}-impl RendererInspectorCommandMetadata {- pub fn new(inspector_session_id: Option<String>, route: RendererInspectorCommandRoute) -> Self {+impl RendererInspectorIngressTicket {+ pub fn new(+ attachment: Option<RendererAgentAttachmentId>,+ inspector_session_id: Option<String>,+ route: RendererInspectorCommandRoute,+ ) -> Self {Self {+ attachment,session: DevToolsSessionKey::from_wire_session_id(inspector_session_id.as_deref().filter(|session_id| !session_id.is_empty()),),route,- first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ sequence: NEXT_RENDERER_INSPECTOR_INGRESS_SEQUENCE+ .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |sequence| {+ sequence.checked_add(1)+ })+ .expect("renderer Inspector ingress sequence overflow"),}}+ pub fn attachment(&self) -> Option<RendererAgentAttachmentId> {+ self.attachment+ }+pub fn session(&self) -> &DevToolsSessionKey {&self.session}@@ -3575,8 +3592,19 @@ impl RendererInspectorCommandMetadata {self.route}- pub fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {- self.first_dispatch+ pub fn sequence(&self) -> u64 {+ self.sequence+ }++ fn bind_attachment(&mut self, attachment: RendererAgentAttachmentId) {+ if let Some(bound) = self.attachment {+ assert_eq!(+ bound, attachment,+ "an Inspector ingress ticket cannot be retargeted to another attachment"+ );+ } else {+ self.attachment = Some(attachment);+ }}}@@ -3585,8 +3613,17 @@ impl RendererInspectorCommandMetadata {/// `V8InspectorSession` must obtain its identity and dispatch policy from this/// envelope.pub struct RendererInspectorCommandEnvelope {- metadata: RendererInspectorCommandMetadata,- command: RendererInspectorPageCommand,+ ticket: RendererInspectorIngressTicket,+ first_dispatch: RendererInspectorFirstDispatchLifecycle,+ payload: RendererInspectorCommandPayload,+}++enum RendererInspectorCommandPayload {+ MainThread(RendererInspectorPageCommand),+ Io {+ raw_json: String,+ response: Option<RendererRuntimeInspectorResponseSender>,+ },}impl RendererInspectorCommandEnvelope {@@ -3595,44 +3632,94 @@ impl RendererInspectorCommandEnvelope {route: RendererInspectorCommandRoute,command: RendererInspectorPageCommand,) -> Self {- Self::with_metadata(- RendererInspectorCommandMetadata::new(inspector_session_id, route),- command,- )+ assert_eq!(+ route,+ RendererInspectorCommandRoute::MainThread,+ "a Page-owned Inspector payload must use the MainThread route"+ );+ Self {+ ticket: RendererInspectorIngressTicket::new(None, inspector_session_id, route),+ first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ payload: RendererInspectorCommandPayload::MainThread(command),+ }}- fn with_metadata(- metadata: RendererInspectorCommandMetadata,- command: RendererInspectorPageCommand,+ #[doc(hidden)]+ pub fn new_io(+ ticket: RendererInspectorIngressTicket,+ raw_json: String,+ response: Option<RendererRuntimeInspectorResponseSender>,) -> Self {- Self { metadata, command }+ assert_eq!(+ ticket.route(),+ RendererInspectorCommandRoute::Io,+ "an Inspector IO payload must use the IO route"+ );+ Self {+ ticket,+ first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,+ payload: RendererInspectorCommandPayload::Io { raw_json, response },+ }}- pub fn metadata(&self) -> &RendererInspectorCommandMetadata {- &self.metadata+ pub fn ticket(&self) -> &RendererInspectorIngressTicket {+ &self.ticket}- pub(crate) fn into_parts(+ pub fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {+ self.first_dispatch+ }++ fn bind_attachment(&mut self, attachment: RendererAgentAttachmentId) {+ self.ticket.bind_attachment(attachment);+ }++ pub(crate) fn into_main_thread_parts(self,- ) -> (- RendererInspectorCommandMetadata,- RendererInspectorPageCommand,- ) {- (self.metadata, self.command)+ ) -> (RendererInspectorIngressTicket, RendererInspectorPageCommand) {+ let RendererInspectorCommandPayload::MainThread(command) = self.payload else {+ panic!("an Inspector IO envelope cannot enter Page owner dispatch");+ };+ (self.ticket, command)+ }++ fn main_thread_payload(&self) -> &RendererInspectorPageCommand {+ let RendererInspectorCommandPayload::MainThread(command) = &self.payload else {+ panic!("an Inspector IO envelope cannot enter Page owner dispatch");+ };+ command+ }++ 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");+ };+ raw_json+ }++ pub(crate) fn io_response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {+ let RendererInspectorCommandPayload::Io { response, .. } = &self.payload else {+ panic!("a MainThread Inspector envelope cannot enter IO dispatch");+ };+ response.as_ref()+ }++ pub(crate) fn take_io_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {+ let RendererInspectorCommandPayload::Io { response, .. } = &mut self.payload else {+ panic!("a MainThread Inspector envelope cannot enter IO dispatch");+ };+ response.take()}pub(crate) fn requires_materialized_child_realms(&self) -> bool {matches!(- &self.command,+ self.main_thread_payload(),RendererInspectorPageCommand::RuntimeEnableEvents)}pub(crate) fn cdp_nav_timing_label(&self) -> Option<&'static str> {- match &self.command {- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { .. } => {- Some("DispatchQueuedRuntimeInspectorCommand")- }+ match self.main_thread_payload() {RendererInspectorPageCommand::RuntimeEnableEvents => Some("RuntimeEnableEvents"),RendererInspectorPageCommand::ApplyRuntimeProtocolState { .. } => {Some("ApplyRuntimeProtocolState")@@ -3680,10 +3767,9 @@ impl RendererInspectorCommandEnvelope {pub(crate) fn uses_cpu_throttling(&self) -> bool {matches!(- &self.command,+ self.main_thread_payload(),RendererInspectorPageCommand::DispatchRuntimeProtocolMessage { .. }| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse { .. }- | RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { .. }| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolution { .. }| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse { .. }| RendererInspectorPageCommand::DomDebuggerGetEventListeners { .. }@@ -3700,9 +3786,6 @@ pub(crate) enum RendererInspectorPageCommand {raw_json: String,deferred_response: RendererRuntimeInspectorResponseSender,},- DispatchQueuedRuntimeInspectorCommand {- command_id: u64,- },DispatchRuntimeProtocolMessageWithContextResolution {action: String,raw_json: String,@@ -4317,6 +4400,11 @@ impl RendererPageCommand {route: RendererInspectorCommandRoute,command: RendererInspectorPageCommand,) -> Self {+ assert_eq!(+ route,+ RendererInspectorCommandRoute::MainThread,+ "IO Inspector commands must enter RendererInspectorIoIngress"+ );Self::Inspector(RendererInspectorCommandEnvelope::new(inspector_session_id,route,@@ -4352,16 +4440,6 @@ impl RendererPageCommand {)}- pub fn dispatch_queued_runtime_inspector_command(- metadata: RendererInspectorCommandMetadata,- command_id: u64,- ) -> Self {- Self::Inspector(RendererInspectorCommandEnvelope::with_metadata(- metadata,- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { command_id },- ))- }-pub fn dispatch_runtime_protocol_message_with_context_resolution(inspector_session_id: Option<String>,route: RendererInspectorCommandRoute,@@ -4429,7 +4507,7 @@ impl RendererPageCommand {) -> Self {Self::inspector_command(inspector_session_id,- RendererInspectorCommandRoute::Io,+ RendererInspectorCommandRoute::MainThread,RendererInspectorPageCommand::DetachRuntimeInspectorSession { pause_guard },)}@@ -4652,13 +4730,28 @@ impl RendererPageCommand {/// Metadata is structurally present for every command that can access a/// frontend V8 Inspector session; no command-variant allowlist is involved.- pub fn inspector_metadata(&self) -> Option<&RendererInspectorCommandMetadata> {+ pub fn inspector_ticket(&self) -> Option<&RendererInspectorIngressTicket> {+ match self {+ Self::Inspector(envelope) => Some(envelope.ticket()),+ _ => None,+ }+ }++ pub fn inspector_first_dispatch_lifecycle(+ &self,+ ) -> Option<RendererInspectorFirstDispatchLifecycle> {match self {- Self::Inspector(envelope) => Some(envelope.metadata()),+ Self::Inspector(envelope) => Some(envelope.first_dispatch_lifecycle()),_ => None,}}+ pub fn bind_inspector_attachment(&mut self, attachment: RendererAgentAttachmentId) {+ if let Self::Inspector(envelope) = self {+ envelope.bind_attachment(attachment);+ }+ }+pub(crate) fn interruptible_by_javascript_dialog(&self) -> bool {#[cfg(test)]if matches!(self, Self::TakeDocumentLifecycleEvents) {@@ -4811,19 +4904,20 @@ impl RendererPageCommand {mod renderer_inspector_command_envelope_tests {use super::*;- fn assert_metadata(+ fn assert_ticket(command: &RendererPageCommand,session: DevToolsSessionKey,route: RendererInspectorCommandRoute,) {- let metadata = command- .inspector_metadata()- .expect("every frontend V8 Inspector operation must carry command metadata");- assert_eq!(metadata.session(), &session);- assert_eq!(metadata.route(), route);+ let ticket = command+ .inspector_ticket()+ .expect("every frontend V8 Inspector operation must carry an ingress ticket");+ assert_eq!(ticket.session(), &session);+ assert_eq!(ticket.route(), route);+ assert!(ticket.sequence() > 0);assert_eq!(- metadata.first_dispatch_lifecycle(),- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch+ command.inspector_first_dispatch_lifecycle(),+ Some(RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch));}@@ -4851,41 +4945,74 @@ mod renderer_inspector_command_envelope_tests {),];for command in &main_thread_commands {- assert_metadata(+ assert_ticket(command,DevToolsSessionKey::Attached("SID-envelope".to_owned()),RendererInspectorCommandRoute::MainThread,);}- let io_command = RendererPageCommand::dispatch_runtime_protocol_message(- None,- RendererInspectorCommandRoute::Io,- r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),- );- assert_metadata(- &io_command,- DevToolsSessionKey::Primary,- RendererInspectorCommandRoute::Io,- );-assert!(RendererPageCommand::PageDiagnosticsSnapshot- .inspector_metadata()+ .inspector_ticket().is_none(),"ordinary Page commands must remain outside Inspector lanes");}+ #[test]+ #[should_panic(expected = "IO Inspector commands must enter RendererInspectorIoIngress")]+ fn io_command_cannot_use_the_main_thread_page_envelope() {+ let _ = RendererPageCommand::dispatch_runtime_protocol_message(+ None,+ RendererInspectorCommandRoute::Io,+ r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),+ );+ }+#[test]fn empty_wire_session_id_normalizes_to_the_primary_session() {let command = RendererPageCommand::runtime_enable_events(Some(String::new()));- assert_metadata(+ assert_ticket(&command,DevToolsSessionKey::Primary,RendererInspectorCommandRoute::MainThread,);}++ #[test]+ fn ingress_tickets_bind_one_attachment_and_allocate_monotonic_sequences() {+ let mut first = RendererPageCommand::runtime_enable_events(Some("SID-first".to_owned()));+ let second = RendererPageCommand::runtime_enable_events(Some("SID-second".to_owned()));+ let first_sequence = first+ .inspector_ticket()+ .expect("first Inspector ticket")+ .sequence();+ let second_sequence = second+ .inspector_ticket()+ .expect("second Inspector ticket")+ .sequence();+ assert!(second_sequence > first_sequence);++ let attachment = RendererAgentAttachmentId::allocate();+ first.bind_inspector_attachment(attachment);+ first.bind_inspector_attachment(attachment);+ assert_eq!(+ first+ .inspector_ticket()+ .expect("bound Inspector ticket")+ .attachment(),+ Some(attachment)+ );+ }++ #[test]+ #[should_panic(expected = "cannot be retargeted to another attachment")]+ fn ingress_ticket_cannot_be_retargeted_during_navigation() {+ let mut command = RendererPageCommand::runtime_enable_events(None);+ command.bind_inspector_attachment(RendererAgentAttachmentId::allocate());+ command.bind_inspector_attachment(RendererAgentAttachmentId::allocate());+ }}#[derive(Debug, Clone, PartialEq)]diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rsindex 7db678d57..87b063efb 100644--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs@@ -1832,6 +1832,12 @@ impl PageVm {self.vm().inspector_pause_bridge()}+ pub(crate) fn inspector_io_ingress(+ &self,+ ) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {+ self.vm().inspector_io_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/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex bb82f7448..c70f3a343 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -692,7 +692,9 @@ mod indexed_db_task_body;mod input_dispatch;mod input_helpers;mod inspector;+pub(crate) mod inspector_io;pub(crate) mod inspector_pause;+pub(crate) use inspector::dispatch_inspector_io_owner_wake;mod isolated_worlds;mod main_document_lifecycle;mod main_document_lifecycle_body;@@ -1024,6 +1026,10 @@ impl ScriptVm {self.page_inspector.pause_bridge()}+ pub(crate) fn inspector_io_ingress(&self) -> inspector_io::RendererInspectorIoIngress {+ self.page_inspector.io_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 0c99d7188..e7555b4c2 100644--- a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs+++ b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs@@ -1,11 +1,10 @@use super::{InspectorOutbound,context_registry::DocumentInspectorContextGroupId,- v8_backend::{RendererInspectorIsolateBackend, RendererInspectorPauseSessionRegistration},+ v8_backend::{RendererInspectorIsolateBackend, RendererInspectorSessionExecutorRegistration},};use crate::protocol_types::RuntimeBindingRegistration;use crate::runtime::RendererTurnOutputJournal;-use crate::script_vm::inspector_pause::RendererInspectorPauseBridge;use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};use std::{collections::HashMap, rc::Rc};@@ -76,13 +75,14 @@ impl RendererDevToolsSessionConnection {fn outbound(&self,- pause_bridge: &RendererInspectorPauseBridge,+ backend: &RendererInspectorIsolateBackend,session_key: DevToolsSessionKey,) -> InspectorOutbound {+ let pause_bridge = backend.pause_bridge();InspectorOutbound::for_frontend(self.agent_token,session_key.clone(),- pause_bridge.outbound_route(self.agent_token, session_key),+ pause_bridge.outbound_route(backend.io_ingress(), self.agent_token, session_key),self.output_journal.clone(),)}@@ -124,7 +124,7 @@ impl RendererDevToolsAgentSessions {.cloned().unwrap_or_default();let session = self.frontend.entry(session_key.clone()).or_insert_with(|| {- let outbound = connection.outbound(&backend.pause_bridge(), session_key.clone());+ let outbound = connection.outbound(backend, session_key.clone());RendererDevToolsSession::connect(backend,connection.context_group_id,@@ -184,14 +184,14 @@ impl RendererDevToolsAgentSessions {session,outbound,replayed_runtime_bindings,- _pause_registration,+ _executor_registration,} = previous;drop(session);- drop(_pause_registration);+ drop(_executor_registration);(outbound, replayed_runtime_bindings)}None => (- connection.outbound(&backend.pause_bridge(), session_key.clone()),+ connection.outbound(backend, session_key.clone()),Vec::new(),),};@@ -213,7 +213,7 @@ impl RendererDevToolsAgentSessions {session_key: DevToolsSessionKey,) {self.frontend.entry(session_key.clone()).or_insert_with(|| {- let outbound = connection.outbound(&backend.pause_bridge(), session_key.clone());+ let outbound = connection.outbound(backend, session_key.clone());RendererDevToolsSession::connect(backend,connection.context_group_id,@@ -340,7 +340,7 @@ struct RendererDevToolsSession {session: Rc<v8::inspector::V8InspectorSession>,outbound: InspectorOutbound,replayed_runtime_bindings: Vec<RuntimeBindingRegistration>,- _pause_registration: Option<RendererInspectorPauseSessionRegistration>,+ _executor_registration: Option<RendererInspectorSessionExecutorRegistration>,}impl RendererDevToolsSession {@@ -349,7 +349,7 @@ impl RendererDevToolsSession {context_group_id: DocumentInspectorContextGroupId,outbound: InspectorOutbound,state: Option<&V8InspectorSessionState>,- pause_session: Option<(RendererDevToolsAgentToken, DevToolsSessionKey)>,+ frontend_session_route: Option<(RendererDevToolsAgentToken, DevToolsSessionKey)>,) -> Self {let first_attach_state = b"{}";let state = state.map_or(@@ -364,8 +364,8 @@ impl RendererDevToolsSession {state,);let session = Rc::new(session);- let pause_registration = pause_session.map(|(agent_token, session_key)| {- backend.register_pause_session(+ let executor_registration = frontend_session_route.map(|(agent_token, session_key)| {+ backend.register_session_executor_route(context_group_id,agent_token,session_key,@@ -377,7 +377,7 @@ impl RendererDevToolsSession {session,outbound,replayed_runtime_bindings: Vec::new(),- _pause_registration: pause_registration,+ _executor_registration: executor_registration,}}diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex e85f16569..1a2f38a67 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -27,7 +27,9 @@ pub(super) use self::outbound::ScriptVmInspectorCommandTurnOutputScope;#[cfg(test)]use self::v8_backend::RendererInspectorClientUniqueIdState;pub(in crate::script_vm) use self::v8_backend::RendererInspectorIsolateBackend;-pub(crate) use self::v8_backend::RendererInspectorIsolateBackendHandle;+pub(crate) use self::v8_backend::{+ RendererInspectorIsolateBackendHandle, dispatch_inspector_io_owner_wake,+};#[cfg(test)]use crate::runtime::{RendererRuntimeCommandOutputRecorder, RendererRuntimeInspectorResponseSender,@@ -53,6 +55,7 @@ pub(crate) struct DocumentInspectorBinding {agent: RendererDevToolsAgent,backend: RefCell<DocumentInspectorBackendState>,pause_bridge: RendererInspectorPauseBridge,+ io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,}impl std::fmt::Debug for DocumentInspectorBinding {@@ -93,11 +96,13 @@ pub(super) struct ReportedExecutionContext {impl DocumentInspectorBinding {pub(crate) fn new(isolate_backend: RendererInspectorIsolateBackendHandle) -> Self {let pause_bridge = isolate_backend.pause_bridge();+ let io_ingress = isolate_backend.io_ingress();Self {context_registrations: DocumentInspectorContextRegistrations::default(),agent: RendererDevToolsAgent::new(isolate_backend),backend: RefCell::new(DocumentInspectorBackendState::new()),pause_bridge,+ io_ingress,}}@@ -113,6 +118,10 @@ impl DocumentInspectorBinding {self.pause_bridge.clone()}+ pub(crate) fn io_ingress(&self) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {+ self.io_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 a64a51504..530902513 100644--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs@@ -713,10 +713,14 @@ mod tests {pause_bridge.configure_page_route(journal.clone());let agent_token = RendererDevToolsAgentToken::allocate();let session = DevToolsSessionKey::Primary;+ let io_ingress = crate::script_vm::inspector_io::RendererInspectorIoIngress::new(+ pause_bridge.pause_loop_wake(),+ None,+ );let outbound = InspectorOutbound::for_frontend(agent_token,session.clone(),- pause_bridge.outbound_route(agent_token, session.clone()),+ pause_bridge.outbound_route(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 cd6465b84..f03d51d27 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -6,7 +6,13 @@ use super::context_registry::{use crate::{inspector_microtasks::with_scoped_inspector_microtasks,runtime::RendererRuntimeInspectorResponseSender,- script_vm::inspector_pause::{RendererInspectorPauseBridge, RendererInspectorPauseCommand},+ script_vm::{+ inspector_io::{+ RendererInspectorInterruptTarget, RendererInspectorIoCommand,+ RendererInspectorIoIngress, RendererInspectorIoOwnerWake, RendererInspectorIoRouteId,+ },+ inspector_pause::RendererInspectorPauseBridge,+ },};use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};use serde_json::json;@@ -14,11 +20,14 @@ use std::{cell::{Cell, RefCell, UnsafeCell},collections::HashMap,rc::{Rc, Weak},- sync::atomic::{AtomicI64, AtomicUsize, Ordering},+ sync::{+ Arc,+ atomic::{AtomicI64, AtomicUsize, Ordering},+ },};thread_local! {- static INTERRUPT_LOOPS: RefCell<HashMap<usize, Weak<RendererInspectorPauseLoopLocal>>> =+ static INSPECTOR_SESSION_EXECUTORS: RefCell<HashMap<RendererInspectorIoRouteId, Weak<RendererInspectorSessionExecutorLocal>>> =RefCell::new(HashMap::new());}@@ -28,52 +37,55 @@ struct RendererInspectorClient {isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,context_registry: DocumentInspectorContextRegistry,unique_id_state: Rc<RendererInspectorClientUniqueIdState>,- pause_loop: Rc<RendererInspectorPauseLoopLocal>,+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,}#[derive(Clone)]-struct RendererInspectorPauseSession {+struct RendererInspectorSessionRoute {session: Weak<v8::inspector::V8InspectorSession>,outbound: InspectorOutbound,agent_token: RendererDevToolsAgentToken,session_key: DevToolsSessionKey,}-pub(super) struct RendererInspectorPauseSessionRegistration {- pause_loop: Weak<RendererInspectorPauseLoopLocal>,+pub(super) struct RendererInspectorSessionExecutorRegistration {+ session_executor: Weak<RendererInspectorSessionExecutorLocal>,context_group_id: i32,agent_token: RendererDevToolsAgentToken,session_key: DevToolsSessionKey,session: Weak<v8::inspector::V8InspectorSession>,}-struct RendererInspectorPauseLoopLocal {+struct RendererInspectorSessionExecutorLocal {+ isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,bridge: RendererInspectorPauseBridge,- interrupt_route_id: Option<usize>,- sessions: RefCell<HashMap<(i32, DevToolsSessionKey), RendererInspectorPauseSession>>,+ io_ingress: RendererInspectorIoIngress,+ interrupt_route_id: Option<RendererInspectorIoRouteId>,+ sessions: RefCell<HashMap<(i32, DevToolsSessionKey), RendererInspectorSessionRoute>>,interrupt_sessions: RefCell<- HashMap<(RendererDevToolsAgentToken, DevToolsSessionKey), RendererInspectorPauseSession>,+ HashMap<(RendererDevToolsAgentToken, DevToolsSessionKey), RendererInspectorSessionRoute>,>,}-impl Drop for RendererInspectorPauseLoopLocal {+impl Drop for RendererInspectorSessionExecutorLocal {fn drop(&mut self) {- let Some(interrupt_route_id) = self.interrupt_route_id else {- return;- };- let _ = INTERRUPT_LOOPS.try_with(|loops| {- loops.borrow_mut().remove(&interrupt_route_id);- });+ if let Some(interrupt_route_id) = self.interrupt_route_id {+ let _ = INSPECTOR_SESSION_EXECUTORS.try_with(|executors| {+ executors.borrow_mut().remove(&interrupt_route_id);+ });+ }+ self.io_ingress+ .close("Inspector session executor was destroyed");}}-impl Drop for RendererInspectorPauseSessionRegistration {+impl Drop for RendererInspectorSessionExecutorRegistration {fn drop(&mut self) {- let Some(pause_loop) = self.pause_loop.upgrade() else {+ let Some(session_executor) = self.session_executor.upgrade() else {return;};let key = (self.context_group_id, self.session_key.clone());- let mut sessions = pause_loop.sessions.borrow_mut();+ let mut sessions = session_executor.sessions.borrow_mut();if sessions.get(&key).is_some_and(|entry| Weak::ptr_eq(&entry.session, &self.session))@@ -81,7 +93,7 @@ impl Drop for RendererInspectorPauseSessionRegistration {sessions.remove(&key);}let interrupt_key = (self.agent_token, self.session_key.clone());- let mut interrupt_sessions = pause_loop.interrupt_sessions.borrow_mut();+ let mut interrupt_sessions = session_executor.interrupt_sessions.borrow_mut();if interrupt_sessions.get(&interrupt_key).is_some_and(|entry| Weak::ptr_eq(&entry.session, &self.session))@@ -91,27 +103,33 @@ impl Drop for RendererInspectorPauseSessionRegistration {}}-impl RendererInspectorPauseLoopLocal {- fn new(bridge: RendererInspectorPauseBridge) -> Rc<Self> {- let interrupt_route_id = bridge.interrupt_route_id();- let pause_loop = Rc::new(Self {+impl RendererInspectorSessionExecutorLocal {+ fn new(+ isolate: v8::UnsafeRawIsolatePtr,+ bridge: RendererInspectorPauseBridge,+ io_ingress: RendererInspectorIoIngress,+ ) -> Rc<Self> {+ let interrupt_route_id = io_ingress.route_id();+ let session_executor = Rc::new(Self {+ isolate: UnsafeCell::new(isolate),bridge,+ io_ingress,interrupt_route_id,sessions: RefCell::new(HashMap::new()),interrupt_sessions: RefCell::new(HashMap::new()),});if let Some(interrupt_route_id) = interrupt_route_id {- let previous = INTERRUPT_LOOPS.with(|loops| {- loops+ let previous = INSPECTOR_SESSION_EXECUTORS.with(|executors| {+ executors.borrow_mut()- .insert(interrupt_route_id, Rc::downgrade(&pause_loop))+ .insert(interrupt_route_id, Rc::downgrade(&session_executor))});assert!(previous.is_none(),"renderer Inspector interrupt route IDs must be unique");}- pause_loop+ session_executor}fn register_session(@@ -121,9 +139,9 @@ impl RendererInspectorPauseLoopLocal {session_key: DevToolsSessionKey,session: &Rc<v8::inspector::V8InspectorSession>,outbound: InspectorOutbound,- ) -> RendererInspectorPauseSessionRegistration {+ ) -> RendererInspectorSessionExecutorRegistration {let weak_session = Rc::downgrade(session);- let route = RendererInspectorPauseSession {+ let route = RendererInspectorSessionRoute {session: weak_session.clone(),outbound,agent_token,@@ -139,8 +157,8 @@ impl RendererInspectorPauseLoopLocal {self.interrupt_sessions.borrow_mut().insert((agent_token, session_key.clone()), route);- RendererInspectorPauseSessionRegistration {- pause_loop: Rc::downgrade(self),+ RendererInspectorSessionExecutorRegistration {+ session_executor: Rc::downgrade(self),context_group_id: context_group_id.get(),agent_token,session_key,@@ -152,14 +170,14 @@ impl RendererInspectorPauseLoopLocal {if !self.bridge.enter_pause() {return;}- while let Some(command) = self.bridge.wait_for_command() {+ while let Some(command) = self.io_ingress.wait_and_claim_for_pause(&self.bridge) {self.dispatch_command(context_group_id, command);}self.bridge.leave_pause();}- fn dispatch_command(&self, context_group_id: i32, command: RendererInspectorPauseCommand) {- let session_key = command.metadata.session().clone();+ fn dispatch_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {+ let session_key = command.ticket().session().clone();let session = self.sessions.borrow()@@ -170,10 +188,23 @@ impl RendererInspectorPauseLoopLocal {}fn dispatch_next_io_command_from_interrupt(&self) {- let Some(command) = self.bridge.claim_io_command_for_interrupt() else {+ let Some(command) = self.io_ingress.claim_for_interrupt() else {+ return;+ };+ let session_key = command.ticket().session();+ let session = self+ .interrupt_sessions+ .borrow()+ .get(&(command.agent_token, session_key.clone()))+ .cloned();+ self.dispatch_command_to_session(command, session);+ }++ fn dispatch_next_io_command_from_owner(&self) {+ let Some(command) = self.io_ingress.claim_for_owner() else {return;};- let session_key = command.metadata.session();+ let session_key = command.ticket().session();let session = self.interrupt_sessions.borrow()@@ -184,25 +215,31 @@ impl RendererInspectorPauseLoopLocal {fn dispatch_command_to_session(&self,- command: RendererInspectorPauseCommand,- session: Option<RendererInspectorPauseSession>,+ mut command: RendererInspectorIoCommand,+ session: Option<RendererInspectorSessionRoute>,) {- let mut first_dispatch = self.bridge.first_dispatch_guard(&command);+ let mut first_dispatch = self.io_ingress.first_dispatch_guard(&command);let Some(session) = session else {- send_pause_dispatch_error(command.response, "Inspector session is not available");+ send_inspector_dispatch_error(+ command.take_response(),+ "Inspector session is not available",+ );return;};let Some(v8_session) = session.session.upgrade() else {- send_pause_dispatch_error(command.response, "Inspector session has been detached");+ send_inspector_dispatch_error(+ command.take_response(),+ "Inspector session has been detached",+ );return;};let _command_dispatch = self.bridge.begin_command_dispatch(&command);- session- .outbound- .register_response_callback(command.response);- first_dispatch.release();+ if let Some(response) = command.take_response() {+ session.outbound.register_response_callback(response);+ }+ let _post_dispatch_wake = first_dispatch.release_for_dispatch();v8_session.dispatch_protocol_message(v8::inspector::StringView::from(- command.raw_json.as_bytes(),+ command.raw_json().as_bytes(),));self.bridge.record_v8_state_update(session.agent_token,@@ -228,27 +265,57 @@ unsafe extern "C" fn dispatch_inspector_interrupt(isolate: v8::UnsafeRawIsolatePtr,data: *mut std::ffi::c_void,) {- let interrupt_route_id = data as usize;- let pause_loop = INTERRUPT_LOOPS- .try_with(|loops| {- loops+ // SAFETY: every accepted request passes one `Arc::into_raw` reference to+ // V8, and V8 invokes its interrupt callback at most once for that request.+ // Reconstructing it here consumes exactly that callback-owned reference.+ let callback_target = unsafe { Arc::from_raw(data.cast::<RendererInspectorInterruptTarget>()) };+ let interrupt_route_id = callback_target.route_id();+ let session_executor = INSPECTOR_SESSION_EXECUTORS+ .try_with(|executors| {+ executors.borrow().get(&interrupt_route_id).and_then(Weak::upgrade)}).ok().flatten();- let Some(pause_loop) = pause_loop else {+ let Some(session_executor) = session_executor else {return;};let mut isolate_ptr = isolate;let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(&mut isolate_ptr) };with_scoped_inspector_microtasks(isolate, || {- pause_loop.dispatch_next_io_command_from_interrupt();+ session_executor.dispatch_next_io_command_from_interrupt();});}-fn send_pause_dispatch_error(response: RendererRuntimeInspectorResponseSender, message: &str) {+pub(crate) fn dispatch_inspector_io_owner_wake(wake: RendererInspectorIoOwnerWake) {+ let session_executor = INSPECTOR_SESSION_EXECUTORS+ .try_with(|executors| {+ executors+ .borrow()+ .get(&wake.route_id())+ .and_then(Weak::upgrade)+ })+ .ok()+ .flatten();+ let Some(session_executor) = session_executor else {+ return;+ };+ let isolate = unsafe { &mut *session_executor.isolate.get() };+ let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(isolate) };+ with_scoped_inspector_microtasks(isolate, || {+ session_executor.dispatch_next_io_command_from_owner();+ });+}++fn send_inspector_dispatch_error(+ response: Option<RendererRuntimeInspectorResponseSender>,+ message: &str,+) {+ let Some(response) = response else {+ return;+ };let call_id = response.call_id();let _ = response.send(json!({"id": call_id,@@ -324,13 +391,13 @@ impl RendererInspectorClient {isolate: v8::UnsafeRawIsolatePtr,context_registry: DocumentInspectorContextRegistry,unique_id_state: Rc<RendererInspectorClientUniqueIdState>,- pause_loop: Rc<RendererInspectorPauseLoopLocal>,+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,) -> Self {Self {isolate: UnsafeCell::new(isolate),context_registry,unique_id_state,- pause_loop,+ session_executor,}}}@@ -344,12 +411,13 @@ impl v8::inspector::V8InspectorClientImpl for RendererInspectorClient {let isolate = unsafe { &mut *self.isolate.get() };let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(isolate) };with_scoped_inspector_microtasks(isolate, || {- self.pause_loop.run_message_loop_on_pause(context_group_id);+ self.session_executor+ .run_message_loop_on_pause(context_group_id);});}fn quit_message_loop_on_pause(&self) {- self.pause_loop.quit_message_loop_on_pause();+ self.session_executor.quit_message_loop_on_pause();}fn generate_unique_id(&self) -> i64 {@@ -382,6 +450,7 @@ struct RendererInspectorIsolateBackendIdentity;pub(crate) struct RendererInspectorIsolateBackendHandle {identity: Rc<RendererInspectorIsolateBackendIdentity>,pause_bridge: RendererInspectorPauseBridge,+ io_ingress: RendererInspectorIoIngress,}impl std::fmt::Debug for RendererInspectorIsolateBackendHandle {@@ -398,7 +467,8 @@ pub(in crate::script_vm) struct RendererInspectorIsolateBackend {pub(super) context_registry: DocumentInspectorContextRegistry,unique_id_state: Rc<RendererInspectorClientUniqueIdState>,pause_bridge: RendererInspectorPauseBridge,- pause_loop: Rc<RendererInspectorPauseLoopLocal>,+ io_ingress: RendererInspectorIoIngress,+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,}impl RendererInspectorIsolateBackend {@@ -406,18 +476,26 @@ impl RendererInspectorIsolateBackend {let isolate_ptr = unsafe { isolate.as_raw_isolate_ptr() };let context_registry = DocumentInspectorContextRegistry::default();let unique_id_state = Rc::new(RendererInspectorClientUniqueIdState::new());- let pause_bridge = RendererInspectorPauseBridge::new_interruptible(- isolate.thread_safe_handle(),- dispatch_inspector_interrupt,- allocate_interrupt_route_id(),+ let pause_bridge = RendererInspectorPauseBridge::default();+ let io_ingress = RendererInspectorIoIngress::new(+ pause_bridge.pause_loop_wake(),+ Some((+ isolate.thread_safe_handle(),+ dispatch_inspector_interrupt,+ RendererInspectorIoRouteId::new(allocate_interrupt_route_id()),+ )),+ );+ let session_executor = RendererInspectorSessionExecutorLocal::new(+ isolate_ptr,+ pause_bridge.clone(),+ io_ingress.clone(),);- let pause_loop = RendererInspectorPauseLoopLocal::new(pause_bridge.clone());let inspector_client =v8::inspector::V8InspectorClient::new(Box::new(RendererInspectorClient::new(isolate_ptr,context_registry.clone(),unique_id_state.clone(),- pause_loop.clone(),+ session_executor.clone(),)));Self {identity: Rc::new(RendererInspectorIsolateBackendIdentity),@@ -425,7 +503,8 @@ impl RendererInspectorIsolateBackend {context_registry,unique_id_state,pause_bridge,- pause_loop,+ io_ingress,+ session_executor,}}@@ -433,6 +512,7 @@ impl RendererInspectorIsolateBackend {RendererInspectorIsolateBackendHandle {identity: Rc::clone(&self.identity),pause_bridge: self.pause_bridge.clone(),+ io_ingress: self.io_ingress.clone(),}}@@ -440,15 +520,19 @@ impl RendererInspectorIsolateBackend {self.pause_bridge.clone()}- pub(super) fn register_pause_session(+ pub(super) fn io_ingress(&self) -> RendererInspectorIoIngress {+ self.io_ingress.clone()+ }++ pub(super) fn register_session_executor_route(&self,context_group_id: DocumentInspectorContextGroupId,agent_token: RendererDevToolsAgentToken,session_key: DevToolsSessionKey,session: &Rc<v8::inspector::V8InspectorSession>,outbound: InspectorOutbound,- ) -> RendererInspectorPauseSessionRegistration {- self.pause_loop.register_session(+ ) -> RendererInspectorSessionExecutorRegistration {+ self.session_executor.register_session(context_group_id,agent_token,session_key,@@ -554,6 +638,10 @@ impl RendererInspectorIsolateBackendHandle {self.pause_bridge.clone()}+ pub(super) fn io_ingress(&self) -> RendererInspectorIoIngress {+ self.io_ingress.clone()+ }+pub(super) fn assert_matches(&self, backend: &RendererInspectorIsolateBackend) {assert!(Rc::ptr_eq(&self.identity, &backend.identity),@@ -563,9 +651,12 @@ impl RendererInspectorIsolateBackendHandle {#[cfg(test)]pub(super) fn new_for_test() -> Self {+ let pause_bridge = RendererInspectorPauseBridge::default();+ let io_ingress = RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(), None);Self {identity: Rc::new(RendererInspectorIsolateBackendIdentity),- pause_bridge: RendererInspectorPauseBridge::default(),+ pause_bridge,+ io_ingress,}}diff --git a/moli-renderer-v8/src/script_vm/inspector_io.rs b/moli-renderer-v8/src/script_vm/inspector_io.rsnew file mode 100644index 000000000..4f2811d5e--- /dev/null+++ b/moli-renderer-v8/src/script_vm/inspector_io.rs@@ -0,0 +1,779 @@+use std::{+ collections::{BTreeMap, VecDeque},+ ffi::c_void,+ num::NonZeroUsize,+ sync::{+ Arc,+ atomic::{AtomicBool, Ordering},+ },+};++use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};+use parking_lot::Mutex;+use serde_json::json;++use crate::{+ runtime::{+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,+ RendererInspectorIngressTicket, RendererRuntimeInspectorResponseSender,+ },+ script_vm::inspector_pause::RendererInspectorPauseLoopWake,+};++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,+}++impl RendererInspectorInterruptTarget {+ pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {+ self.route_id+ }+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererInspectorIoCommandConsumer {+ Owner,+ Interrupt,+ Pause,+}++pub(crate) struct RendererInspectorIoCommand {+ command_id: u64,+ pub(crate) agent_token: RendererDevToolsAgentToken,+ envelope: RendererInspectorCommandEnvelope,+ claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorCommandClaim>>,+ claimed_by: Option<RendererInspectorIoCommandConsumer>,+}++impl RendererInspectorIoCommand {+ 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.io_raw_json()+ }++ pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {+ self.envelope.io_response()+ }++ pub(crate) fn take_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {+ self.envelope.take_io_response()+ }++ #[cfg(test)]+ pub(crate) fn claimed_by(&self) -> Option<RendererInspectorIoCommandConsumer> {+ self.claimed_by+ }+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum RendererRuntimeInspectorCommandClaim {+ Inspector,+ Canceled,+}++pub struct RendererRuntimeInspectorCommandRoute {+ command_id: u64,+ ticket: RendererInspectorIngressTicket,+ claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorCommandClaim>>,+ ingress: RendererInspectorIoIngress,+}++impl RendererRuntimeInspectorCommandRoute {+ pub fn command_id(&self) -> u64 {+ self.command_id+ }++ pub fn ticket(&self) -> &RendererInspectorIngressTicket {+ &self.ticket+ }++ pub async fn wait_for_claim(+ mut self,+ ) -> Result<RendererRuntimeInspectorCommandClaim, &'static str> {+ self.claim_rx+ .take()+ .expect("runtime inspector IO command claim receiver should only be awaited once")+ .await+ .map_err(|_| "runtime inspector IO command claim channel closed")+ }+}++impl Drop for RendererRuntimeInspectorCommandRoute {+ fn drop(&mut self) {+ self.ingress.cancel_queued_command(+ self.command_id,+ "Runtime inspector IO route was canceled before dispatch",+ );+ }+}++#[derive(Clone)]+pub(crate) struct RendererInspectorIoIngress {+ shared: Arc<RendererInspectorIoShared>,+}++struct RendererInspectorIoShared {+ state: Mutex<RendererInspectorIoState>,+ interrupt_armed: AtomicBool,+ interrupt_route: Option<RendererInspectorInterruptRoute>,+ pause_wake: RendererInspectorPauseLoopWake,+}++struct RendererInspectorInterruptRoute {+ isolate: v8::IsolateHandle,+ callback: RendererInspectorInterruptCallback,+ target: Arc<RendererInspectorInterruptTarget>,+}++#[derive(Clone)]+pub(crate) struct RendererInspectorIoOwnerWake {+ route_id: RendererInspectorIoRouteId,+}++impl RendererInspectorIoOwnerWake {+ pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {+ self.route_id+ }+}++#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]+struct RendererInspectorIoSessionLaneKey {+ agent_token: RendererDevToolsAgentToken,+ session: DevToolsSessionKey,+}++#[derive(Default)]+struct RendererInspectorIoSessionLane {+ active_command_id: Option<u64>,+ queued: VecDeque<RendererInspectorIoCommand>,+ ready: bool,+ detached: bool,+}++struct RendererInspectorIoState {+ next_command_id: u64,+ sessions: BTreeMap<RendererInspectorIoSessionLaneKey, RendererInspectorIoSessionLane>,+ ready_sessions: VecDeque<RendererInspectorIoSessionLaneKey>,+ owner_wake_tx: Option<tokio::sync::mpsc::UnboundedSender<RendererInspectorIoOwnerWake>>,+ closed: bool,+}++pub(crate) struct RendererInspectorIoFirstDispatchGuard {+ ingress: RendererInspectorIoIngress,+ active: Option<(RendererInspectorIoSessionLaneKey, u64)>,+ consumer: RendererInspectorIoCommandConsumer,+}++pub(crate) struct RendererInspectorIoPostDispatchWakeGuard {+ ingress: Option<RendererInspectorIoIngress>,+}++impl Drop for RendererInspectorIoFirstDispatchGuard {+ fn drop(&mut self) {+ self.release();+ }+}++impl RendererInspectorIoFirstDispatchGuard {+ pub(crate) fn release(&mut self) {+ let has_ready = self.release_lane();+ if has_ready {+ self.ingress.notify_execution_opportunities();+ }+ }++ /// Commits the first-dispatch lifecycle immediately before entering V8,+ /// but defers scheduling another callback until this dispatch returns. A+ /// nested pause entered by this dispatch still sees the advanced lane when+ /// it first polls the IO ingress.+ pub(crate) fn release_for_dispatch(&mut self) -> RendererInspectorIoPostDispatchWakeGuard {+ let has_ready = self.release_lane();+ RendererInspectorIoPostDispatchWakeGuard {+ ingress: has_ready.then(|| self.ingress.clone()),+ }+ }++ fn release_lane(&mut self) -> bool {+ let Some((lane, command_id)) = self.active.take() else {+ return false;+ };+ if self.consumer == RendererInspectorIoCommandConsumer::Interrupt {+ self.ingress+ .shared+ .interrupt_armed+ .store(false, Ordering::Release);+ }+ self.ingress.finish_first_dispatch(lane, command_id)+ }+}++impl Drop for RendererInspectorIoPostDispatchWakeGuard {+ fn drop(&mut self) {+ if let Some(ingress) = self.ingress.take() {+ ingress.notify_execution_opportunities();+ }+ }+}++impl RendererInspectorIoIngress {+ pub(crate) fn new(+ pause_wake: RendererInspectorPauseLoopWake,+ interrupt_route: Option<(+ v8::IsolateHandle,+ RendererInspectorInterruptCallback,+ RendererInspectorIoRouteId,+ )>,+ ) -> Self {+ Self {+ shared: Arc::new(RendererInspectorIoShared {+ state: Mutex::new(RendererInspectorIoState {+ next_command_id: 1,+ sessions: BTreeMap::new(),+ ready_sessions: VecDeque::new(),+ owner_wake_tx: None,+ closed: false,+ }),+ interrupt_armed: AtomicBool::new(false),+ interrupt_route: interrupt_route.map(|(isolate, callback, route_id)| {+ RendererInspectorInterruptRoute {+ isolate,+ callback,+ target: Arc::new(RendererInspectorInterruptTarget { route_id }),+ }+ }),+ pause_wake,+ }),+ }+ }++ pub(crate) fn route_id(&self) -> Option<RendererInspectorIoRouteId> {+ self.shared+ .interrupt_route+ .as_ref()+ .map(|route| route.target.route_id())+ }++ pub(crate) fn configure_owner_wake(+ &self,+ owner_wake_tx: tokio::sync::mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,+ ) {+ let has_ready = {+ let mut state = self.shared.state.lock();+ state.owner_wake_tx = Some(owner_wake_tx);+ !state.ready_sessions.is_empty()+ };+ if has_ready {+ self.notify_execution_opportunities();+ }+ }++ pub(crate) fn enqueue_command(+ &self,+ agent_token: RendererDevToolsAgentToken,+ envelope: RendererInspectorCommandEnvelope,+ ) -> RendererRuntimeInspectorCommandRoute {+ assert_eq!(+ envelope.ticket().route(),+ RendererInspectorCommandRoute::Io,+ "only IO Inspector commands may enter RendererInspectorIoIngress"+ );+ let ticket = envelope.ticket().clone();+ let (claim_tx, claim_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 IO command ID overflow");+ let lane_key = RendererInspectorIoSessionLaneKey {+ agent_token,+ session: ticket.session().clone(),+ };+ let command = RendererInspectorIoCommand {+ command_id,+ agent_token,+ envelope,+ claim_tx: Some(claim_tx),+ claimed_by: None,+ };+ if state.closed {+ drop(state);+ fail_io_command(command, "Inspector IO target is closed");+ return RendererRuntimeInspectorCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_rx),+ ingress: self.clone(),+ };+ }+ let lane = state.sessions.entry(lane_key.clone()).or_default();+ if lane.detached {+ drop(state);+ fail_io_command(command, "Inspector IO session was detached");+ return RendererRuntimeInspectorCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_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();+ RendererRuntimeInspectorCommandRoute {+ command_id,+ ticket,+ claim_rx: Some(claim_rx),+ ingress: self.clone(),+ }+ }++ pub(crate) fn claim_for_owner(&self) -> Option<RendererInspectorIoCommand> {+ self.claim_next(RendererInspectorIoCommandConsumer::Owner)+ }++ pub(crate) fn claim_for_interrupt(&self) -> Option<RendererInspectorIoCommand> {+ let command = self.claim_next(RendererInspectorIoCommandConsumer::Interrupt);+ if command.is_none() {+ self.shared.interrupt_armed.store(false, Ordering::Release);+ let has_ready = !self.shared.state.lock().ready_sessions.is_empty();+ if has_ready {+ self.request_interrupt();+ }+ }+ command+ }++ pub(crate) fn claim_for_pause(&self) -> Option<RendererInspectorIoCommand> {+ self.claim_next(RendererInspectorIoCommandConsumer::Pause)+ }++ pub(crate) fn wait_and_claim_for_pause(+ &self,+ pause_bridge: &crate::script_vm::inspector_pause::RendererInspectorPauseBridge,+ ) -> Option<RendererInspectorIoCommand> {+ pause_bridge.wait_for_pause_work(|| self.claim_for_pause())+ }++ fn claim_next(+ &self,+ consumer: RendererInspectorIoCommandConsumer,+ ) -> Option<RendererInspectorIoCommand> {+ let mut state = self.shared.state.lock();+ if state.closed {+ return None;+ }+ while let Some(lane_key) = state.ready_sessions.pop_front() {+ 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_tx.send(RendererRuntimeInspectorCommandClaim::Inspector);+ }+ return Some(command);+ }+ None+ }++ pub(crate) fn first_dispatch_guard(+ &self,+ command: &RendererInspectorIoCommand,+ ) -> RendererInspectorIoFirstDispatchGuard {+ let lane_key = RendererInspectorIoSessionLaneKey {+ 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 IO command must own its session lane"+ );+ drop(state);+ RendererInspectorIoFirstDispatchGuard {+ ingress: self.clone(),+ active: Some((lane_key, command.command_id)),+ consumer: command+ .claimed_by+ .expect("a first-dispatch guard requires a claimed IO command"),+ }+ }++ fn finish_first_dispatch(+ &self,+ lane_key: RendererInspectorIoSessionLaneKey,+ 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 IO lane must still exist");+ assert_eq!(+ lane.active_command_id.take(),+ Some(command_id),+ "only the active Inspector IO 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 IO lane must remain present");+ let position = lane+ .queued+ .iter()+ .position(|command| command.command_id == command_id)+ .expect("located Inspector IO 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_io_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 = RendererInspectorIoSessionLaneKey {+ 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 IO 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_io_command(command, "Inspector IO 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_io_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_io_command(command, message);+ }+ }++ fn notify_execution_opportunities(&self) {+ let owner_wake = {+ let state = self.shared.state.lock();+ state.owner_wake_tx.clone().zip(self.route_id())+ };+ if let Some((owner_wake_tx, route_id)) = owner_wake {+ let _ = owner_wake_tx.send(RendererInspectorIoOwnerWake { route_id });+ }+ self.request_interrupt();+ self.shared.pause_wake.notify_one();+ }++ fn request_interrupt(&self) {+ let Some(route) = self.shared.interrupt_route.as_ref() else {+ return;+ };+ if self+ .shared+ .interrupt_armed+ .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)+ .is_err()+ {+ return;+ }+ // Match Chromium's InspectorTaskRunner lifetime protocol: every V8+ // interrupt owns one strong callback target until V8 invokes it. A+ // late callback after executor teardown can therefore safely observe+ // that its TLS route disappeared without dereferencing stale state.+ let callback_target = Arc::into_raw(Arc::clone(&route.target));+ let callback_data = callback_target.cast_mut().cast::<c_void>();+ if !route+ .isolate+ .request_interrupt(route.callback, callback_data)+ {+ // SAFETY: `callback_target` came from `Arc::into_raw` immediately+ // above, and V8 rejected the request, so no callback can consume+ // this one strong reference.+ unsafe { drop(Arc::from_raw(callback_target)) };+ self.shared.interrupt_armed.store(false, Ordering::Release);+ }+ }+}++fn drain_queued_commands(state: &mut RendererInspectorIoState) -> Vec<RendererInspectorIoCommand> {+ 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+}++impl std::fmt::Debug for RendererInspectorIoIngress {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ let state = self.shared.state.lock();+ formatter+ .debug_struct("RendererInspectorIoIngress")+ .field("route_id", &self.route_id())+ .field("session_lanes", &state.sessions.len())+ .field("ready_sessions", &state.ready_sessions.len())+ .field(+ "interrupt_armed",+ &self.shared.interrupt_armed.load(Ordering::Acquire),+ )+ .field("closed", &state.closed)+ .finish()+ }+}++fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {+ if let Some(claim_tx) = command.claim_tx.take() {+ let _ = claim_tx.send(RendererRuntimeInspectorCommandClaim::Canceled);+ }+ let Some(response) = command.take_response() else {+ return;+ };+ let call_id = response.call_id();+ let _ = response.send(json!({+ "id": call_id,+ "error": {+ "code": -32000,+ "message": message,+ },+ }));+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{+ runtime::RendererInspectorIngressTicket,+ script_vm::inspector_pause::RendererInspectorPauseBridge,+ };++ fn ingress() -> RendererInspectorIoIngress {+ let pause_bridge = RendererInspectorPauseBridge::default();+ RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(), None)+ }++ fn enqueue(+ ingress: &RendererInspectorIoIngress,+ agent_token: RendererDevToolsAgentToken,+ session: Option<&str>,+ raw_json: &str,+ ) -> RendererRuntimeInspectorCommandRoute {+ ingress.enqueue_command(+ agent_token,+ RendererInspectorCommandEnvelope::new_io(+ RendererInspectorIngressTicket::new(+ None,+ session.map(str::to_owned),+ RendererInspectorCommandRoute::Io,+ ),+ raw_json.to_owned(),+ None,+ ),+ )+ }++ #[test]+ fn owner_interrupt_and_pause_race_can_claim_one_command_only_once() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let _route = enqueue(&ingress, agent, Some("session-a"), "first");++ let owner = ingress.claim_for_owner();+ let interrupt = ingress.claim_for_interrupt();+ let pause = ingress.claim_for_pause();+ assert_eq!(+ usize::from(owner.is_some())+ + usize::from(interrupt.is_some())+ + usize::from(pause.is_some()),+ 1+ );+ assert_eq!(+ owner.and_then(|command| command.claimed_by()),+ Some(RendererInspectorIoCommandConsumer::Owner)+ );+ }++ #[test]+ fn one_session_is_fifo_while_another_session_is_independent() {+ 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 session");+ assert_eq!(first.raw_json(), "a1");+ let second = ingress+ .claim_for_interrupt()+ .expect("other session must remain independently ready");+ assert_eq!(second.raw_json(), "b1");+ assert!(ingress.claim_for_pause().is_none());++ ingress.first_dispatch_guard(&first).release();+ let third = ingress.claim_for_pause().expect("a2 after a1 dispatch");+ assert_eq!(third.raw_json(), "a2");+ }++ #[tokio::test]+ async fn detach_cancels_the_queue_while_an_active_first_dispatch_guard_finishes_safely() {+ let ingress = ingress();+ let agent = RendererDevToolsAgentToken::allocate();+ let first_route = enqueue(&ingress, agent, Some("session-a"), "a1");+ let second_route = enqueue(&ingress, agent, Some("session-a"), "a2");++ let first = ingress+ .claim_for_interrupt()+ .expect("the session head should be claimable");+ let mut first_dispatch = ingress.first_dispatch_guard(&first);+ assert_eq!(+ first_route.wait_for_claim().await,+ Ok(RendererRuntimeInspectorCommandClaim::Inspector)+ );++ ingress.detach_session(agent, &DevToolsSessionKey::Attached("session-a".to_owned()));+ assert_eq!(+ second_route.wait_for_claim().await,+ Ok(RendererRuntimeInspectorCommandClaim::Canceled),+ "detach must cancel commands that have not been claimed"+ );++ first_dispatch.release();+ assert!(+ ingress.shared.state.lock().sessions.is_empty(),+ "the detached lane must retire after its active first dispatch releases"+ );+ }++ #[test]+ #[should_panic(expected = "only IO Inspector commands")]+ fn main_thread_command_cannot_enter_io_ingress() {+ let ingress = ingress();+ let page_command = crate::runtime::RendererPageCommand::dispatch_runtime_protocol_message(+ Some("session-a".to_owned()),+ RendererInspectorCommandRoute::MainThread,+ "main".to_owned(),+ );+ let crate::runtime::RendererPageCommand::Inspector(envelope) = page_command else {+ panic!("runtime protocol message must use an Inspector envelope");+ };+ let _ = ingress.enqueue_command(RendererDevToolsAgentToken::allocate(), envelope);+ }+}diff --git a/moli-renderer-v8/src/script_vm/inspector_pause.rs b/moli-renderer-v8/src/script_vm/inspector_pause.rsindex 06ba9c39e..e8c5d7ec4 100644--- a/moli-renderer-v8/src/script_vm/inspector_pause.rs+++ b/moli-renderer-v8/src/script_vm/inspector_pause.rs@@ -1,114 +1,32 @@use std::{- collections::{HashMap, HashSet, VecDeque},- ffi::c_void,- sync::Arc,+ collections::{HashSet, VecDeque},+ sync::{Arc, Weak},};use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};use parking_lot::{Condvar, Mutex};-use serde_json::{Value, json};+use serde_json::Value;+#[cfg(test)]+use serde_json::json;+#[cfg(test)]+use crate::runtime::RendererRuntimeInspectorResponseSender;use crate::runtime::{- PageId, PendingRendererOutputRecord, RendererInspectorCommandMetadata,- RendererInspectorCommandRoute, RendererOutputResidenceIdentity, RendererProtocolObservation,- RendererRuntimeCommandCausalIdentity, RendererRuntimeInspectorMessage,- RendererRuntimeInspectorMessageBatch, RendererRuntimeInspectorResponseSender,+ PageId, PendingRendererOutputRecord, RendererOutputResidenceIdentity,+ RendererProtocolObservation, RendererRuntimeCommandCausalIdentity,+ RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,RendererTurnOutputJournal,};--pub(crate) struct RendererInspectorPauseCommand {- command_id: u64,- pub(crate) agent_token: RendererDevToolsAgentToken,- pub(crate) metadata: RendererInspectorCommandMetadata,- pub(crate) owner_context_resolution_action: Option<String>,- pub(crate) raw_json: String,- pub(crate) response: RendererRuntimeInspectorResponseSender,- claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorCommandClaim>>,-}--#[derive(Clone, Debug, Eq, Hash, PartialEq)]-struct RendererInspectorFirstDispatchLane {- agent_token: RendererDevToolsAgentToken,- session: DevToolsSessionKey,- route: RendererInspectorCommandRoute,-}--impl RendererInspectorPauseCommand {- fn first_dispatch_lane(&self) -> RendererInspectorFirstDispatchLane {- RendererInspectorFirstDispatchLane {- agent_token: self.agent_token,- session: self.metadata.session().clone(),- route: self.metadata.route(),- }- }-}--#[derive(Clone, Copy, Debug, Eq, PartialEq)]-pub enum RendererRuntimeInspectorCommandClaim {- Owner,- Inspector,- Canceled,-}--pub struct RendererRuntimeInspectorCommandRoute {- command_id: u64,- metadata: RendererInspectorCommandMetadata,- requires_owner_fallback: bool,- claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorCommandClaim>>,- bridge: RendererInspectorPauseBridge,-}--impl RendererRuntimeInspectorCommandRoute {- pub fn command_id(&self) -> u64 {- self.command_id- }-- pub fn metadata(&self) -> &RendererInspectorCommandMetadata {- &self.metadata- }-- pub fn requires_owner_fallback(&self) -> bool {- self.requires_owner_fallback- }-- pub async fn wait_for_claim(- mut self,- ) -> Result<RendererRuntimeInspectorCommandClaim, &'static str> {- self.claim_rx- .take()- .expect("runtime inspector command claim receiver should only be awaited once")- .await- .map_err(|_| "runtime inspector command claim channel closed")- }-}--impl Drop for RendererRuntimeInspectorCommandRoute {- fn drop(&mut self) {- self.bridge.cancel_queued_command(- self.command_id,- "Runtime inspector command route was canceled before dispatch",- );- }-}+use crate::script_vm::inspector_io::{RendererInspectorIoCommand, RendererInspectorIoIngress};#[derive(Clone)]pub(crate) struct RendererInspectorPauseBridge {shared: Arc<RendererInspectorPauseBridgeShared>,}-struct RendererInspectorPauseBridgeShared {+pub(crate) struct RendererInspectorPauseBridgeShared {state: Mutex<RendererInspectorPauseBridgeState>,- command_ready: Condvar,- interrupt_route: Option<RendererInspectorInterruptRoute>,-}--type RendererInspectorInterruptCallback =- unsafe extern "C" fn(v8::UnsafeRawIsolatePtr, *mut c_void);--struct RendererInspectorInterruptRoute {- isolate: v8::IsolateHandle,- callback: RendererInspectorInterruptCallback,- callback_data: usize,+ pause_loop_wake: Condvar,}#[derive(Clone)]@@ -124,14 +42,11 @@ enum RendererInspectorPausePhase {}struct RendererInspectorPauseBridgeState {- next_command_id: u64,next_preface_id: u64,phase: RendererInspectorPausePhase,quit_requested: bool,session_detach_arms: usize,target_closed: bool,- active_first_dispatch_lanes: HashMap<RendererInspectorFirstDispatchLane, u64>,- commands: VecDeque<RendererInspectorPauseCommand>,pending_prefaces: VecDeque<RendererInspectorPausePreface>,paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,// V8 dispatches one nested-loop command synchronously. A successful@@ -239,25 +154,26 @@ pub(super) struct RendererInspectorPausePrefaceGuard {id: u64,}-pub(crate) struct RendererInspectorFirstDispatchGuard {- bridge: RendererInspectorPauseBridge,- active: Option<(RendererInspectorFirstDispatchLane, u64)>,+#[derive(Clone)]+pub(crate) struct RendererInspectorPauseLoopWake {+ shared: Weak<RendererInspectorPauseBridgeShared>,}-impl Drop for RendererInspectorFirstDispatchGuard {- fn drop(&mut self) {- self.release();+impl RendererInspectorPauseLoopWake {+ pub(crate) fn notify_one(&self) {+ let Some(shared) = self.shared.upgrade() else {+ return;+ };+ let _state = shared.state.lock();+ shared.pause_loop_wake.notify_one();}-}-impl RendererInspectorFirstDispatchGuard {- /// Releases the lane at the call boundary into V8 Inspector. The command- /// response and any JavaScript it starts may remain pending after this- /// point; neither is part of the first-dispatch lifetime.- pub(crate) fn release(&mut self) {- if let Some((lane, command_id)) = self.active.take() {- self.bridge.finish_first_dispatch(lane, command_id);- }+ pub(crate) fn notify_all(&self) {+ let Some(shared) = self.shared.upgrade() else {+ return;+ };+ let _state = shared.state.lock();+ shared.pause_loop_wake.notify_all();}}@@ -269,55 +185,35 @@ impl Drop for RendererInspectorPausePrefaceGuard {#[derive(Clone)]pub(super) struct RendererInspectorPauseOutboundRoute {bridge: RendererInspectorPauseBridge,+ io_ingress: RendererInspectorIoIngress,agent_token: RendererDevToolsAgentToken,session: DevToolsSessionKey,}impl Default for RendererInspectorPauseBridge {fn default() -> Self {- Self::new(None)+ Self::new()}}impl RendererInspectorPauseBridge {- pub(super) fn new_interruptible(- isolate: v8::IsolateHandle,- callback: RendererInspectorInterruptCallback,- callback_data: usize,- ) -> Self {- assert_ne!(- callback_data, 0,- "Inspector interrupt route ID must be non-zero"- );- Self::new(Some(RendererInspectorInterruptRoute {- isolate,- callback,- callback_data,- }))- }-- fn new(interrupt_route: Option<RendererInspectorInterruptRoute>) -> Self {- Self {- shared: Arc::new(RendererInspectorPauseBridgeShared {- state: Mutex::new(RendererInspectorPauseBridgeState {- next_command_id: 1,- next_preface_id: 1,- phase: RendererInspectorPausePhase::Running,- quit_requested: false,- session_detach_arms: 0,- target_closed: false,- active_first_dispatch_lanes: HashMap::new(),- commands: VecDeque::new(),- pending_prefaces: VecDeque::new(),- paused_sessions_awaiting_resumed: HashSet::new(),- active_command_dispatch: None,- pending_command_transition: None,- route: None,- }),- command_ready: Condvar::new(),- interrupt_route,+ fn new() -> Self {+ let shared = Arc::new(RendererInspectorPauseBridgeShared {+ state: Mutex::new(RendererInspectorPauseBridgeState {+ next_preface_id: 1,+ phase: RendererInspectorPausePhase::Running,+ quit_requested: false,+ session_detach_arms: 0,+ target_closed: false,+ pending_prefaces: VecDeque::new(),+ paused_sessions_awaiting_resumed: HashSet::new(),+ active_command_dispatch: None,+ pending_command_transition: None,+ route: None,}),- }+ pause_loop_wake: Condvar::new(),+ });+ Self { shared }}}@@ -330,11 +226,6 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {.field("quit_requested", &state.quit_requested).field("session_detach_arms", &state.session_detach_arms).field("target_closed", &state.target_closed)- .field(- "active_first_dispatch_lanes",- &state.active_first_dispatch_lanes,- )- .field("pending_commands", &state.commands.len()).field("pending_prefaces", &state.pending_prefaces.len()).field("paused_sessions_awaiting_resumed",@@ -353,20 +244,21 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {}impl RendererInspectorPauseBridge {- pub(super) fn interrupt_route_id(&self) -> Option<usize> {- self.shared- .interrupt_route- .as_ref()- .map(|route| route.callback_data)+ pub(crate) fn pause_loop_wake(&self) -> RendererInspectorPauseLoopWake {+ RendererInspectorPauseLoopWake {+ shared: Arc::downgrade(&self.shared),+ }}pub(super) fn outbound_route(&self,+ io_ingress: RendererInspectorIoIngress,agent_token: RendererDevToolsAgentToken,session: DevToolsSessionKey,) -> RendererInspectorPauseOutboundRoute {RendererInspectorPauseOutboundRoute {bridge: self.clone(),+ io_ingress,agent_token,session,}@@ -386,19 +278,24 @@ impl RendererInspectorPauseBridge {pub(super) fn begin_command_dispatch(&self,- command: &RendererInspectorPauseCommand,+ command: &RendererInspectorIoCommand,) -> RendererInspectorPauseCommandDispatchGuard {- let effect = RendererInspectorPauseCommandEffect::from_raw_json(&command.raw_json);+ let effect = RendererInspectorPauseCommandEffect::from_raw_json(command.raw_json());if effect == RendererInspectorPauseCommandEffect::None {return RendererInspectorPauseCommandDispatchGuard {bridge: self.clone(),command_id: None,};}- let call_id = command.response.call_id();+ let Some(call_id) = command.response().map(|response| response.call_id()) else {+ return RendererInspectorPauseCommandDispatchGuard {+ bridge: self.clone(),+ command_id: None,+ };+ };let causal_identity = RendererRuntimeCommandCausalIdentity::new(command- .metadata+ .ticket().session().wire_session_id().map(str::to_owned),@@ -411,7 +308,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: command.command_id(),transition: RendererInspectorPauseCommandTransition {causal_identity,effect,@@ -422,7 +319,7 @@ impl RendererInspectorPauseBridge {});RendererInspectorPauseCommandDispatchGuard {bridge: self.clone(),- command_id: Some(command.command_id),+ command_id: Some(command.command_id()),}}@@ -522,7 +419,7 @@ impl RendererInspectorPauseBridge {.checked_add(1).expect("runtime inspector session detach arm count overflow");if state.phase != RendererInspectorPausePhase::Running {- self.shared.command_ready.notify_all();+ self.shared.pause_loop_wake.notify_all();}}@@ -534,130 +431,6 @@ impl RendererInspectorPauseBridge {.expect("runtime inspector session detach arm count underflow");}- pub(crate) fn enqueue_command(- &self,- agent_token: RendererDevToolsAgentToken,- inspector_session_id: Option<String>,- route: RendererInspectorCommandRoute,- owner_context_resolution_action: Option<String>,- raw_json: String,- response: RendererRuntimeInspectorResponseSender,- ) -> RendererRuntimeInspectorCommandRoute {- let (claim_tx, claim_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 pause command ID overflow");- let metadata = RendererInspectorCommandMetadata::new(inspector_session_id, route);- let command = RendererInspectorPauseCommand {- command_id,- agent_token,- metadata: metadata.clone(),- owner_context_resolution_action,- raw_json,- response,- claim_tx: Some(claim_tx),- };- if state.target_closed {- drop(state);- fail_pause_command(command, "Inspector target closed while paused");- return RendererRuntimeInspectorCommandRoute {- command_id,- metadata,- requires_owner_fallback: false,- claim_rx: Some(claim_rx),- bridge: self.clone(),- };- }- let pause_active = state.phase != RendererInspectorPausePhase::Running;- state.commands.push_back(command);- if pause_active {- self.shared.command_ready.notify_one();- }- drop(state);- if route == RendererInspectorCommandRoute::Io {- self.request_io_interrupt();- }- RendererRuntimeInspectorCommandRoute {- command_id,- metadata,- // Every route keeps an owner fallback. IO can win through a V8- // interrupt, while both Chromium transport routes can run in the- // nested debugger loop. If V8 unwinds first, the already-queued- // owner turn can dispatch the still-unclaimed command.- requires_owner_fallback: true,- claim_rx: Some(claim_rx),- bridge: self.clone(),- }- }-- fn request_io_interrupt(&self) {- let Some(route) = self.shared.interrupt_route.as_ref() else {- return;- };- let _ = route- .isolate- .request_interrupt(route.callback, route.callback_data as *mut c_void);- }-- pub(crate) fn claim_command_for_owner(- &self,- command_id: u64,- ) -> Option<RendererInspectorPauseCommand> {- let mut state = self.shared.state.lock();- if state.target_closed || state.phase != RendererInspectorPausePhase::Running {- return None;- }- let position = state- .commands- .iter()- .position(|command| command.command_id == command_id)?;- let lane = state.commands[position].first_dispatch_lane();- if state.active_first_dispatch_lanes.contains_key(&lane)- || state- .commands- .iter()- .take(position)- .any(|command| command.first_dispatch_lane() == lane)- {- return None;- }- let command = state- .commands- .remove(position)- .expect("queued runtime inspector command position should remain valid");- assert!(- state- .active_first_dispatch_lanes- .insert(lane, command.command_id)- .is_none(),- "a first-dispatch lane must have at most one active command"- );- Some(claim_pause_command(- command,- RendererRuntimeInspectorCommandClaim::Owner,- ))- }-- pub(crate) fn cancel_queued_command(&self, command_id: u64, message: &str) {- let command = {- let mut state = self.shared.state.lock();- let Some(position) = state- .commands- .iter()- .position(|command| command.command_id == command_id)- else {- return;- };- state.commands.remove(position)- };- if let Some(command) = command {- fail_pause_command(command, message);- }- }-pub(super) fn enter_pause(&self) -> bool {let mut state = self.shared.state.lock();if state.target_closed || state.phase != RendererInspectorPausePhase::Entering {@@ -667,101 +440,16 @@ impl RendererInspectorPauseBridge {true}- pub(super) fn wait_for_command(&self) -> Option<RendererInspectorPauseCommand> {+ pub(crate) fn wait_for_pause_work<T>(&self, mut claim: impl FnMut() -> Option<T>) -> Option<T> {let mut state = self.shared.state.lock();loop {if state.target_closed || state.quit_requested || state.session_detach_arms != 0 {return None;}- if let Some(position) = state.commands.iter().position(|command| {- !state- .active_first_dispatch_lanes- .contains_key(&command.first_dispatch_lane())- }) {- let command = state- .commands- .remove(position)- .expect("queued Inspector command position must remain valid");- let lane = command.first_dispatch_lane();- assert!(- state- .active_first_dispatch_lanes- .insert(lane, command.command_id)- .is_none(),- "a first-dispatch lane must have at most one active command"- );- return Some(claim_pause_command(- command,- RendererRuntimeInspectorCommandClaim::Inspector,- ));+ if let Some(work) = claim() {+ return Some(work);}- self.shared.command_ready.wait(&mut state);- }- }-- pub(super) fn claim_io_command_for_interrupt(&self) -> Option<RendererInspectorPauseCommand> {- let mut state = self.shared.state.lock();- if state.target_closed {- return None;- }- let position = state.commands.iter().position(|command| {- command.metadata.route() == RendererInspectorCommandRoute::Io- && !state- .active_first_dispatch_lanes- .contains_key(&command.first_dispatch_lane())- })?;- let command = state- .commands- .remove(position)- .expect("queued IO Inspector command position must remain valid");- let lane = command.first_dispatch_lane();- assert!(- state- .active_first_dispatch_lanes- .insert(lane, command.command_id)- .is_none(),- "a first-dispatch lane must have at most one active command"- );- Some(claim_pause_command(- command,- RendererRuntimeInspectorCommandClaim::Inspector,- ))- }-- pub(crate) fn first_dispatch_guard(- &self,- command: &RendererInspectorPauseCommand,- ) -> RendererInspectorFirstDispatchGuard {- let lane = command.first_dispatch_lane();- let state = self.shared.state.lock();- assert_eq!(- state.active_first_dispatch_lanes.get(&lane),- Some(&command.command_id),- "a claimed Inspector command must own its first-dispatch lane"- );- drop(state);- RendererInspectorFirstDispatchGuard {- bridge: self.clone(),- active: Some((lane, command.command_id)),- }- }-- fn finish_first_dispatch(&self, lane: RendererInspectorFirstDispatchLane, command_id: u64) {- let has_waiting_io = {- let mut state = self.shared.state.lock();- assert_eq!(- state.active_first_dispatch_lanes.remove(&lane),- Some(command_id),- "only the active Inspector command may release its first-dispatch lane"- );- self.shared.command_ready.notify_all();- state- .commands- .iter()- .any(|command| command.metadata.route() == RendererInspectorCommandRoute::Io)- };- if has_waiting_io {- self.request_io_interrupt();+ self.shared.pause_loop_wake.wait(&mut state);}}@@ -769,7 +457,7 @@ impl RendererInspectorPauseBridge {let mut state = self.shared.state.lock();if state.phase != RendererInspectorPausePhase::Running {state.quit_requested = true;- self.shared.command_ready.notify_all();+ self.shared.pause_loop_wake.notify_all();}}@@ -777,61 +465,48 @@ impl RendererInspectorPauseBridge {let mut state = self.shared.state.lock();state.phase = RendererInspectorPausePhase::Running;state.quit_requested = false;- // Commands that lost the nested-loop race to Debugger.resume stay- // queued. Every live route has an owner fallback queued before it is- // exposed to the caller, so owner dispatch claims them after V8- // unwinds instead of reporting a synthetic cancellation.+ // IO commands that lost the nested-loop race stay in their dedicated+ // ingress and retain independent owner/interrupt execution chances.}- pub(crate) fn detach_page(&self, page_id: PageId) {- let commands = {- let mut state = self.shared.state.lock();- let route_page_id = state.route.as_ref().and_then(|route| {- match route.output_journal.stream().residence() {- RendererOutputResidenceIdentity::Page { page_id, .. } => Some(page_id),- RendererOutputResidenceIdentity::SharedWorker { .. }- | RendererOutputResidenceIdentity::ServiceWorker { .. } => None,- }- });- if route_page_id != Some(page_id) {- return;+ pub(crate) fn detach_page(&self, page_id: PageId) -> bool {+ let mut state = self.shared.state.lock();+ let route_page_id = state.route.as_ref().and_then(|route| {+ match route.output_journal.stream().residence() {+ RendererOutputResidenceIdentity::Page { page_id, .. } => Some(page_id),+ RendererOutputResidenceIdentity::SharedWorker { .. }+ | RendererOutputResidenceIdentity::ServiceWorker { .. } => None,}- state.route = None;- state.pending_prefaces.clear();- state.paused_sessions_awaiting_resumed.clear();- state.pending_command_transition = None;- match state.phase {- RendererInspectorPausePhase::Running => {}- RendererInspectorPausePhase::Entering => {- state.phase = RendererInspectorPausePhase::Running;- state.quit_requested = false;- }- RendererInspectorPausePhase::Paused => {- state.quit_requested = true;- self.shared.command_ready.notify_all();- }+ });+ if route_page_id != Some(page_id) {+ return false;+ }+ state.route = None;+ state.pending_prefaces.clear();+ state.paused_sessions_awaiting_resumed.clear();+ state.pending_command_transition = None;+ match state.phase {+ RendererInspectorPausePhase::Running => {}+ RendererInspectorPausePhase::Entering => {+ state.phase = RendererInspectorPausePhase::Running;+ state.quit_requested = false;+ }+ RendererInspectorPausePhase::Paused => {+ state.quit_requested = true;+ self.shared.pause_loop_wake.notify_all();}- state.commands.drain(..).collect::<Vec<_>>()- };- for command in commands {- fail_pause_command(command, "Inspector page closed while paused");}+ true}pub(crate) fn close_target(&self) {- let commands = {- let mut state = self.shared.state.lock();- state.target_closed = true;- state.quit_requested = true;- state.pending_prefaces.clear();- state.paused_sessions_awaiting_resumed.clear();- state.pending_command_transition = None;- self.shared.command_ready.notify_all();- state.commands.drain(..).collect::<Vec<_>>()- };- for command in commands {- fail_pause_command(command, "Inspector target closed while paused");- }+ let mut state = self.shared.state.lock();+ state.target_closed = true;+ state.quit_requested = true;+ state.pending_prefaces.clear();+ state.paused_sessions_awaiting_resumed.clear();+ state.pending_command_transition = None;+ self.shared.pause_loop_wake.notify_all();}pub(super) fn record_v8_state_update(@@ -990,6 +665,8 @@ impl RendererInspectorPauseOutboundRoute {pub(super) fn detach_session(&self) {self.bridge.detach_session(self.agent_token, &self.session);+ self.io_ingress+ .detach_session(self.agent_token, &self.session);}pub(super) fn stage_pause_preface(@@ -1001,18 +678,6 @@ impl RendererInspectorPauseOutboundRoute {}}-fn fail_pause_command(command: RendererInspectorPauseCommand, message: &str) {- let command = claim_pause_command(command, RendererRuntimeInspectorCommandClaim::Canceled);- let call_id = command.response.call_id();- let _ = command.response.send(json!({- "id": call_id,- "error": {- "code": -32000,- "message": message,- },- }));-}-pub(super) struct RendererInspectorPauseCommandDispatchGuard {bridge: RendererInspectorPauseBridge,command_id: Option<u64>,@@ -1026,19 +691,19 @@ impl Drop for RendererInspectorPauseCommandDispatchGuard {}}-fn claim_pause_command(- mut command: RendererInspectorPauseCommand,- claim: RendererRuntimeInspectorCommandClaim,-) -> RendererInspectorPauseCommand {- if let Some(claim_tx) = command.claim_tx.take() {- let _ = claim_tx.send(claim);- }- command-}-#[cfg(test)]mod tests {use super::*;+ use crate::runtime::RendererInspectorCommandRoute;++ fn io_ingress(+ bridge: &RendererInspectorPauseBridge,+ ) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {+ crate::script_vm::inspector_io::RendererInspectorIoIngress::new(+ bridge.pause_loop_wake(),+ None,+ )+ }fn configure_page(bridge: &RendererInspectorPauseBridge, page_id: PageId) {bridge.configure_page_route(RendererTurnOutputJournal::new(@@ -1052,13 +717,42 @@ mod tests {fn outbound_route(bridge: &RendererInspectorPauseBridge,+ ) -> RendererInspectorPauseOutboundRoute {+ outbound_route_with_io(bridge, io_ingress(bridge))+ }++ fn outbound_route_with_io(+ bridge: &RendererInspectorPauseBridge,+ io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,) -> RendererInspectorPauseOutboundRoute {bridge.outbound_route(+ io_ingress,RendererDevToolsAgentToken::allocate(),DevToolsSessionKey::Primary,)}+ fn enqueue_command(+ ingress: &crate::script_vm::inspector_io::RendererInspectorIoIngress,+ agent_token: RendererDevToolsAgentToken,+ inspector_session_id: Option<String>,+ raw_json: String,+ response: RendererRuntimeInspectorResponseSender,+ ) -> crate::script_vm::inspector_io::RendererRuntimeInspectorCommandRoute {+ ingress.enqueue_command(+ agent_token,+ crate::runtime::RendererInspectorCommandEnvelope::new_io(+ crate::runtime::RendererInspectorIngressTicket::new(+ None,+ inspector_session_id,+ crate::runtime::RendererInspectorCommandRoute::Io,+ ),+ raw_json,+ Some(response),+ ),+ )+ }+fn route_paused(bridge: &RendererInspectorPauseBridge,) -> RendererInspectorPauseNotificationRoute {@@ -1101,8 +795,9 @@ mod tests {#[test]fn step_transition_keeps_the_exact_command_cause_through_repause() {let bridge = RendererInspectorPauseBridge::default();+ let io_ingress = io_ingress(&bridge);configure_page(&bridge, PageId::new_for_testing(1));- let outbound = outbound_route(&bridge);+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());assert!(expect_immediate_preface(outbound.route_notification(&json!({"method": "Debugger.paused",@@ -1113,23 +808,22 @@ mod tests {assert!(bridge.enter_pause());let (response, _response_rx) = response_sender(41);- let command_route = bridge.enqueue_command(+ let command_route = enqueue_command(+ &io_ingress,RendererDevToolsAgentToken::allocate(),None,- RendererInspectorCommandRoute::MainThread,- None,r#"{"id":41,"method":"Debugger.stepOut","params":{}}"#.to_owned(),response,);assert_eq!(- command_route.metadata().route(),- RendererInspectorCommandRoute::MainThread+ command_route.ticket().route(),+ RendererInspectorCommandRoute::Io);- let command = bridge- .wait_for_command()+ let command = io_ingress+ .wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = bridge.first_dispatch_guard(&command);- assert_eq!(command.metadata, command_route.metadata().clone());+ let first_dispatch = io_ingress.first_dispatch_guard(&command);+ assert_eq!(command.ticket(), command_route.ticket());let dispatch = bridge.begin_command_dispatch(&command);outbound.mark_command_response(41, true);drop(dispatch);@@ -1164,8 +858,9 @@ mod tests {#[test]fn step_cause_ends_with_the_owner_turn_when_no_repause_occurs() {let bridge = RendererInspectorPauseBridge::default();+ let io_ingress = io_ingress(&bridge);configure_page(&bridge, PageId::new_for_testing(1));- let outbound = outbound_route(&bridge);+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());assert!(expect_immediate_preface(outbound.route_notification(&json!({"method": "Debugger.paused",@@ -1176,18 +871,17 @@ mod tests {assert!(bridge.enter_pause());let (response, _response_rx) = response_sender(43);- let command_route = bridge.enqueue_command(+ let command_route = enqueue_command(+ &io_ingress,RendererDevToolsAgentToken::allocate(),None,- RendererInspectorCommandRoute::MainThread,- None,r#"{"id":43,"method":"Debugger.stepOut","params":{}}"#.to_owned(),response,);- let command = bridge- .wait_for_command()+ let command = io_ingress+ .wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = bridge.first_dispatch_guard(&command);+ let first_dispatch = io_ingress.first_dispatch_guard(&command);let dispatch = bridge.begin_command_dispatch(&command);outbound.mark_command_response(43, true);drop(dispatch);@@ -1215,8 +909,9 @@ mod tests {#[test]fn failed_step_command_does_not_own_a_later_resume_transition() {let bridge = RendererInspectorPauseBridge::default();+ let io_ingress = io_ingress(&bridge);configure_page(&bridge, PageId::new_for_testing(1));- let outbound = outbound_route(&bridge);+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());assert!(expect_immediate_preface(outbound.route_notification(&json!({"method": "Debugger.paused",@@ -1227,18 +922,17 @@ mod tests {assert!(bridge.enter_pause());let (response, _response_rx) = response_sender(42);- let command_route = bridge.enqueue_command(+ let command_route = enqueue_command(+ &io_ingress,RendererDevToolsAgentToken::allocate(),None,- RendererInspectorCommandRoute::MainThread,- None,r#"{"id":42,"method":"Debugger.stepOut","params":{}}"#.to_owned(),response,);- let command = bridge- .wait_for_command()+ let command = io_ingress+ .wait_and_claim_for_pause(&bridge).expect("the nested pause loop should claim stepOut");- let first_dispatch = bridge.first_dispatch_guard(&command);+ let first_dispatch = io_ingress.first_dispatch_guard(&command);let dispatch = bridge.begin_command_dispatch(&command);outbound.mark_command_response(42, false);drop(dispatch);@@ -1307,300 +1001,6 @@ mod tests {assert!(bridge.shared.state.lock().pending_prefaces.is_empty());}- #[tokio::test]- async fn pause_loop_accepts_main_while_io_can_overtake_on_its_own_lane() {- let bridge = RendererInspectorPauseBridge::default();- configure_page(&bridge, PageId::new_for_testing(1));- let agent_token = RendererDevToolsAgentToken::allocate();- let (main_response, main_response_rx) = response_sender(7);- let main_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::MainThread,- Some("evaluate".to_owned()),- r#"{"id":7,"method":"Runtime.evaluate","params":{"expression":"42"}}"#.to_owned(),- main_response,- );- let (io_response, io_response_rx) = response_sender(8);- let io_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":8,"method":"Runtime.terminateExecution"}"#.to_owned(),- io_response,- );-- assert_eq!(- main_route.metadata().session(),- &DevToolsSessionKey::Primary- );- assert_eq!(- main_route.metadata().route(),- RendererInspectorCommandRoute::MainThread- );- assert!(- main_route.requires_owner_fallback(),- "the command should initially schedule an owner fallback"- );-- assert!(expect_immediate_preface(route_paused(&bridge)).is_empty());- assert!(bridge.enter_pause());- let io_command = bridge- .claim_io_command_for_interrupt()- .expect("the IO callback may overtake an earlier independent Main command");- let io_first_dispatch = bridge.first_dispatch_guard(&io_command);- assert_eq!(io_command.metadata, io_route.metadata().clone());- assert_eq!(- io_route.wait_for_claim().await,- Ok(RendererRuntimeInspectorCommandClaim::Inspector)- );- io_command- .response- .send(json!({"id": 8, "result": {}}))- .expect("IO response receiver should remain open");- assert_eq!(io_response_rx.await.expect("IO response").call_id, 8);- drop(io_first_dispatch);-- // A normal debugger pause pumps Chromium's main-thread DevTools- // receiver too. Main does not interrupt running JavaScript, but it is- // eligible once V8 has entered the nested message loop.- let main_command = bridge- .wait_for_command()- .expect("the nested pause loop should claim Main work");- let main_first_dispatch = bridge.first_dispatch_guard(&main_command);- assert_eq!(main_command.metadata, main_route.metadata().clone());- assert_eq!(- main_command.owner_context_resolution_action.as_deref(),- Some("evaluate"),- "owner context-resolution metadata must stay attached"- );- assert_eq!(- main_route.wait_for_claim().await,- Ok(RendererRuntimeInspectorCommandClaim::Inspector)- );- main_command- .response- .send(json!({"id": 7, "result": {"result": {"value": 42}}}))- .expect("Main response receiver should remain open");- assert_eq!(main_response_rx.await.expect("Main response").call_id, 7);- drop(main_first_dispatch);-- bridge.request_quit();- assert!(bridge.wait_for_command().is_none());- bridge.leave_pause();- }-- #[test]- fn active_owner_io_dispatch_cannot_be_overtaken_by_its_io_successor() {- let bridge = RendererInspectorPauseBridge::default();- let agent_token = RendererDevToolsAgentToken::allocate();- let (first_response, _first_response_rx) = response_sender(11);- let first_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":11,"method":"Debugger.pause"}"#.to_owned(),- first_response,- );- let (second_response, _second_response_rx) = response_sender(12);- let second_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":12,"method":"Runtime.terminateExecution"}"#.to_owned(),- second_response,- );-- let first = bridge- .claim_command_for_owner(first_route.command_id())- .expect("the first IO command should be owner-claimable while V8 is idle");- let first_dispatch = bridge.first_dispatch_guard(&first);- assert!(- bridge.claim_io_command_for_interrupt().is_none(),- "an interrupt callback must not overtake an owner-claimed IO predecessor"- );-- drop(first_dispatch);- let second = bridge- .claim_io_command_for_interrupt()- .expect("the IO successor should become claimable after first dispatch");- assert_eq!(second.command_id, second_route.command_id());- let second_dispatch = bridge.first_dispatch_guard(&second);- drop(second_dispatch);- }-- #[test]- fn first_dispatch_fifo_is_scoped_to_the_exact_agent_session_and_route() {- let bridge = RendererInspectorPauseBridge::default();- let agent_token = RendererDevToolsAgentToken::allocate();- let (first_response, _first_response_rx) = response_sender(21);- let first_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":21,"method":"Debugger.pause"}"#.to_owned(),- first_response,- );- let (second_response, _second_response_rx) = response_sender(22);- let second_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":22,"method":"Runtime.terminateExecution"}"#.to_owned(),- second_response,- );- let (other_response, _other_response_rx) = response_sender(23);- let other_route = bridge.enqueue_command(- agent_token,- Some("SID-other".to_owned()),- RendererInspectorCommandRoute::Io,- None,- r#"{"id":23,"method":"Debugger.pause"}"#.to_owned(),- other_response,- );-- let first = bridge- .claim_io_command_for_interrupt()- .expect("the first primary-session IO command should be claimable");- assert_eq!(first.command_id, first_route.command_id());- let first_dispatch = bridge.first_dispatch_guard(&first);-- let other = bridge- .claim_io_command_for_interrupt()- .expect("a different session lane must remain independent");- assert_eq!(other.command_id, other_route.command_id());- let other_dispatch = bridge.first_dispatch_guard(&other);- assert!(- bridge.claim_io_command_for_interrupt().is_none(),- "the primary-session successor must not overtake its active predecessor"- );- drop(other_dispatch);- assert!(- bridge.claim_io_command_for_interrupt().is_none(),- "releasing another session must not release the primary lane"- );-- drop(first_dispatch);- let second = bridge- .claim_io_command_for_interrupt()- .expect("the exact-lane successor should become claimable once");- assert_eq!(second.command_id, second_route.command_id());- let second_dispatch = bridge.first_dispatch_guard(&second);- drop(second_dispatch);- assert!(bridge.claim_io_command_for_interrupt().is_none());- }-- #[tokio::test]- async fn page_teardown_cancels_waiters_while_an_io_dispatch_is_in_flight() {- let bridge = RendererInspectorPauseBridge::default();- let page_id = PageId::new_for_testing(1);- configure_page(&bridge, page_id);- let agent_token = RendererDevToolsAgentToken::allocate();- let (active_response, _active_response_rx) = response_sender(31);- let active_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":31,"method":"Debugger.pause"}"#.to_owned(),- active_response,- );- let (waiting_response, waiting_response_rx) = response_sender(32);- let waiting_route = bridge.enqueue_command(- agent_token,- None,- RendererInspectorCommandRoute::Io,- None,- r#"{"id":32,"method":"Runtime.terminateExecution"}"#.to_owned(),- waiting_response,- );-- let active = bridge- .claim_io_command_for_interrupt()- .expect("the first IO command should enter dispatch");- assert_eq!(active.command_id, active_route.command_id());- let active_dispatch = bridge.first_dispatch_guard(&active);- bridge.detach_page(page_id);-- let canceled = waiting_response_rx- .await- .expect("teardown must settle the queued IO response");- let response = canceled- .output- .protocol_response(32)- .expect("teardown cancellation response");- assert_eq!(- response["error"]["message"],- json!("Inspector page closed while paused")- );- assert_eq!(waiting_route.command_id(), 2);-- drop(active_dispatch);- assert!(- bridge- .shared- .state- .lock()- .active_first_dispatch_lanes- .is_empty(),- "an in-flight callback must release its lane safely after teardown"- );- }-- #[tokio::test]- async fn main_thread_command_is_handed_to_owner_after_resume() {- let bridge = RendererInspectorPauseBridge::default();- configure_page(&bridge, PageId::new_for_testing(1));- assert!(- expect_immediate_preface(outbound_route(&bridge).route_notification(&json!({- "method": "Debugger.paused",- "params": {"callFrames": []},- })))- .is_empty()- );- assert!(bridge.enter_pause());-- let (response, response_rx) = response_sender(9);- let route = bridge.enqueue_command(- RendererDevToolsAgentToken::allocate(),- None,- RendererInspectorCommandRoute::MainThread,- Some("evaluate".to_owned()),- r#"{"id":9,"method":"Runtime.evaluate","params":{"expression":"42"}}"#.to_owned(),- response,- );- assert!(- route.requires_owner_fallback(),- "paused commands need an owner fallback in case resume wins the claim race"- );- let command_id = route.command_id();-- bridge.request_quit();- assert!(- bridge.wait_for_command().is_none(),- "the resume request should win before the queued command is claimed"- );- bridge.leave_pause();-- let command = bridge- .claim_command_for_owner(command_id)- .expect("owner dispatch should claim the command after pause exit");- assert_eq!(- route.wait_for_claim().await,- Ok(RendererRuntimeInspectorCommandClaim::Owner)- );- command- .response- .send(json!({"id": 9, "result": {"result": {"value": 42}}}))- .expect("test response receiver should remain open");- assert_eq!(response_rx.await.expect("test response").call_id, 9);- }-#[test]fn resumed_after_pause_loop_exit_stays_on_pause_bridge() {let bridge = RendererInspectorPauseBridge::default();@@ -1646,24 +1046,23 @@ mod tests {}#[tokio::test]- async fn dropping_command_route_cancels_the_unclaimed_owner_fallback() {+ async fn dropping_io_route_cancels_the_unclaimed_command() {let bridge = RendererInspectorPauseBridge::default();+ let io_ingress = io_ingress(&bridge);configure_page(&bridge, PageId::new_for_testing(1));let (response, response_rx) = response_sender(8);- let route = bridge.enqueue_command(+ let route = enqueue_command(+ &io_ingress,RendererDevToolsAgentToken::allocate(),None,- RendererInspectorCommandRoute::MainThread,- None,r#"{"id":8,"method":"Runtime.getIsolateId"}"#.to_owned(),response,);- let command_id = route.command_id();drop(route);assert!(- bridge.claim_command_for_owner(command_id).is_none(),- "a canceled frontend route must remove its delayed owner command"+ io_ingress.claim_for_owner().is_none(),+ "a canceled frontend route must remove its queued IO command");let completion = response_rx.await@@ -1674,7 +1073,7 @@ mod tests {.expect("route cancellation response");assert_eq!(response["error"]["message"],- json!("Runtime inspector command route was canceled before dispatch")+ json!("Runtime inspector IO route was canceled before dispatch"));}@@ -1686,7 +1085,7 @@ mod tests {configure_page(&bridge, first_page_id);assert!(expect_immediate_preface(route_paused(&bridge)).is_empty());- bridge.detach_page(first_page_id);+ assert!(bridge.detach_page(first_page_id));{let state = bridge.shared.state.lock();assert_eq!(state.phase, RendererInspectorPausePhase::Running);@@ -1695,7 +1094,7 @@ mod tests {}configure_page(&bridge, second_page_id);- bridge.detach_page(first_page_id);+ assert!(!bridge.detach_page(first_page_id));{let state = bridge.shared.state.lock();assert_eq!(@@ -1724,7 +1123,8 @@ mod tests {bridge.request_quit();assert!(bridge.enter_pause());- assert!(bridge.wait_for_command().is_none());+ let io_ingress = io_ingress(&bridge);+ assert!(io_ingress.wait_and_claim_for_pause(&bridge).is_none());bridge.leave_pause();assert_eq!(bridge.shared.state.lock().phase,