Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor: add nested main inspector receiver

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