Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(devtools): unify synchronous Page IO responses

ldm0a74431d2262c
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py b/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py
index 8795d6209..68a26966e 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py
@@ -57,6 +57,12 @@ async def run_inspector_routing_group(
client, page, fixture, results
),
),
+ (
+ "raw_cdp_mixed_io_agent_response_order",
+ lambda client, page: _mixed_io_agent_response_order(
+ client, page, results
+ ),
+ ),
(
"raw_cdp_performance_io_during_active_javascript",
lambda client, page: _performance_io_during_active_javascript(
@@ -1480,6 +1486,133 @@ async def _performance_io_during_active_javascript(
)
+async def _mixed_io_agent_response_order(
+ client: RawCdpClient,
+ page: InspectorRoutingPage,
+ results: list[dict[str, Any]],
+) -> None:
+ source = "globalThis.__mixedIoAgentResponseOrder = 42;"
+ compile_id = await client.send(
+ "Runtime.compileScript",
+ {
+ "expression": source,
+ "sourceURL": "inspector-routing-mixed-io.js",
+ "persistScript": True,
+ },
+ session_id=page.auxiliary_session_id,
+ )
+ compile_response, _ = await client.recv_until_id(compile_id, timeout=5)
+ script_id = compile_response.get("result", {}).get("scriptId")
+ if not isinstance(script_id, str) or not script_id:
+ raise SmokeError(
+ f"Runtime.compileScript returned no mixed-IO scriptId: {compile_response}"
+ )
+
+ performance_enable_id = await client.send(
+ "Performance.enable",
+ session_id=page.auxiliary_session_id,
+ )
+ await client.recv_until_id(performance_enable_id, timeout=5)
+
+ commands: list[tuple[int, str]] = []
+ for _ in range(64):
+ commands.append(
+ (
+ await client.send(
+ "Performance.getMetrics",
+ session_id=page.auxiliary_session_id,
+ ),
+ "Performance.getMetrics",
+ )
+ )
+ commands.append(
+ (
+ await client.send(
+ "Debugger.getScriptSource",
+ {"scriptId": script_id},
+ session_id=page.auxiliary_session_id,
+ ),
+ "Debugger.getScriptSource",
+ )
+ )
+ commands.append(
+ (
+ await client.send(
+ "Emulation.setScriptExecutionDisabled",
+ {"value": False},
+ session_id=page.auxiliary_session_id,
+ ),
+ "Emulation.setScriptExecutionDisabled",
+ )
+ )
+ commands.append(
+ (
+ await client.send(
+ "Debugger.getScriptSource",
+ {"scriptId": script_id},
+ session_id=page.auxiliary_session_id,
+ ),
+ "Debugger.getScriptSource",
+ )
+ )
+
+ expected_order = [message_id for message_id, _method in commands]
+ responses, seen = await _recv_responses(client, set(expected_order), timeout=10)
+ response_order = [
+ message["id"] for message in seen if message.get("id") in responses
+ ]
+ assert_equal(
+ response_order,
+ expected_order,
+ "same-session synchronous mixed Page IO agent response order",
+ )
+ for message_id, method in commands:
+ response = responses[message_id]
+ if "error" in response:
+ raise SmokeError(f"{method} failed in mixed Page IO burst: {response}")
+ if method == "Debugger.getScriptSource":
+ assert_equal(
+ response.get("result", {}).get("scriptSource"),
+ source,
+ f"mixed Page IO script source for id {message_id}",
+ )
+ elif method == "Performance.getMetrics":
+ metrics = response.get("result", {}).get("metrics")
+ if not isinstance(metrics, list) or not metrics:
+ raise SmokeError(
+ f"Performance.getMetrics returned no metrics in mixed burst: {response}"
+ )
+ else:
+ assert_equal(
+ response.get("result"),
+ {},
+ f"mixed Page IO Emulation result for id {message_id}",
+ )
+
+ performance_disable_id = await client.send(
+ "Performance.disable",
+ session_id=page.auxiliary_session_id,
+ )
+ await client.recv_until_id(performance_disable_id, timeout=5)
+ record_contract(
+ results,
+ "raw_cdp_mixed_io_agent_response_order",
+ contract=(
+ "Synchronous V8 Debugger and non-V8 Performance/Emulation commands share one "
+ "Page IO ingress and one session output path, so their responses remain in "
+ "producer order without serializing genuinely asynchronous Inspector replies."
+ ),
+ source="Chromium DevToolsSession mixed V8/non-V8 IO executable probe",
+ commands=[
+ "Performance.getMetrics",
+ "Debugger.getScriptSource",
+ "Emulation.setScriptExecutionDisabled",
+ "Debugger.getScriptSource",
+ ],
+ observed={"iterations": 64, "responseCount": len(response_order)},
+ )
+
+
async def _script_execution_disabled_io_during_active_javascript(
client: RawCdpClient,
page: InspectorRoutingPage,
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index 23639b962..584b2f351 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -856,6 +856,28 @@ impl Page {
)
}
+ /// Publishes the terminal `Performance.getMetrics` response through the
+ /// concrete renderer DevTools session that owns this Page attachment.
+ pub fn start_performance_get_metrics_from_io_with_response(
+ &self,
+ inspector_session_id: Option<String>,
+ result: Value,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<PendingDevToolsIoCommandDispatch> {
+ let attachment = self
+ .renderer_agent_attachment_id
+ .ok_or_else(|| anyhow!("Performance IO response requires a renderer attachment"))?;
+ let route = self
+ .handle
+ .enqueue_performance_get_metrics_io_command_with_response(
+ attachment,
+ inspector_session_id,
+ result,
+ response,
+ );
+ Ok(Self::pending_devtools_io_command_dispatch(route))
+ }
+
pub fn cached_performance_metric_snapshot(&self) -> RendererPerformanceMetricSnapshot {
self.page_state.performance_metric_snapshot().clone()
}
diff --git a/moli-core/src/page/settings_support.rs b/moli-core/src/page/settings_support.rs
index 4ef54e4e8..55df1010f 100644
--- a/moli-core/src/page/settings_support.rs
+++ b/moli-core/src/page/settings_support.rs
@@ -10,6 +10,7 @@ use super::protocol_support::{
use super::{CompletedPageCommand, Page, PendingDevToolsIoCommandDispatch, PendingPageCommand};
use crate::renderer::{
RendererPageCommand, RendererPageCookieFacadeSnapshotReply, RendererPageReply,
+ RendererRuntimeInspectorResponseSender,
};
use moli_renderer_v8::network::BrowserResourceRuntime;
@@ -251,6 +252,28 @@ impl Page {
Self::pending_devtools_io_command_dispatch(route)
}
+ /// Publishes the terminal Emulation response through the concrete
+ /// renderer DevTools session that owns this Page attachment.
+ pub fn start_set_script_execution_disabled_from_io_with_response(
+ &self,
+ inspector_session_id: Option<String>,
+ disabled: bool,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<PendingDevToolsIoCommandDispatch> {
+ let attachment = self.renderer_agent_attachment_id.ok_or_else(|| {
+ anyhow::anyhow!("Emulation IO response requires a renderer attachment")
+ })?;
+ let route = self
+ .handle
+ .enqueue_set_script_execution_disabled_io_command_with_response(
+ attachment,
+ inspector_session_id,
+ disabled,
+ response,
+ );
+ Ok(Self::pending_devtools_io_command_dispatch(route))
+ }
+
pub async fn set_bypass_content_security_policy_async(&mut self, bypass: bool) -> Result<()> {
self.dispatch_unit_page_command_async(
RendererPageCommand::SetBypassContentSecurityPolicy(bypass),
diff --git a/moli-protocol-cdp/src/wire.rs b/moli-protocol-cdp/src/wire.rs
index 75155a422..e22e23e06 100644
--- a/moli-protocol-cdp/src/wire.rs
+++ b/moli-protocol-cdp/src/wire.rs
@@ -1,4 +1,3 @@
-use moli_page_types::RendererInspectorResponseDelivery;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use std::{error::Error, fmt};
@@ -232,7 +231,6 @@ pub struct CdpRendererCommandPolicy {
inspector_task_mode: CdpInspectorTaskMode,
renderer_replacement: CdpRendererCommandReplacement,
renderer_replay_dispatch: CdpRendererCommandReplayDispatch,
- response_delivery: RendererInspectorResponseDelivery,
executes_page_javascript: bool,
}
@@ -253,10 +251,6 @@ impl CdpRendererCommandPolicy {
self.renderer_replay_dispatch
}
- pub const fn response_delivery(self) -> RendererInspectorResponseDelivery {
- self.response_delivery
- }
-
pub const fn executes_page_javascript(self) -> bool {
self.executes_page_javascript
}
@@ -578,7 +572,6 @@ impl CdpRendererCommandPolicy {
inspector_task_mode: CdpInspectorTaskMode::for_method(method),
renderer_replacement: CdpRendererCommandReplacement::Replay,
renderer_replay_dispatch: CdpRendererCommandReplayDispatch::Direct,
- response_delivery: RendererInspectorResponseDelivery::CommandReply,
executes_page_javascript: false,
};
};
@@ -654,21 +647,6 @@ impl CdpRendererCommandPolicy {
} else {
CdpRendererCommandReplayDispatch::Direct
},
- response_delivery: if domain == CdpMethodDomain::Debugger
- && matches!(
- action,
- "getPossibleBreakpoints"
- | "getScriptSource"
- | "getStackTrace"
- | "removeBreakpoint"
- | "setBreakpoint"
- | "setBreakpointByUrl"
- | "setBreakpointsActive"
- ) {
- RendererInspectorResponseDelivery::DevToolsSession
- } else {
- RendererInspectorResponseDelivery::CommandReply
- },
executes_page_javascript: runtime_action
.is_some_and(RuntimeWireAction::executes_page_javascript)
|| debugger_action.is_some_and(DebuggerWireAction::executes_page_javascript),
@@ -828,41 +806,6 @@ mod tests {
);
}
- #[test]
- fn synchronous_interruptible_frontend_v8_responses_use_session_output_as_one_family() {
- for method in [
- "Debugger.getPossibleBreakpoints",
- "Debugger.getScriptSource",
- "Debugger.getStackTrace",
- "Debugger.removeBreakpoint",
- "Debugger.setBreakpoint",
- "Debugger.setBreakpointByUrl",
- "Debugger.setBreakpointsActive",
- ] {
- assert_eq!(
- parse(format!(r#"{{"id":18,"method":"{method}"}}"#))
- .renderer_policy()
- .response_delivery(),
- RendererInspectorResponseDelivery::DevToolsSession,
- "{method} must share the same session output path as adjacent synchronous V8 IO commands"
- );
- }
- for method in [
- "Debugger.enable",
- "Debugger.pause",
- "Debugger.resume",
- "Runtime.getIsolateId",
- ] {
- assert_eq!(
- parse(format!(r#"{{"id":19,"method":"{method}"}}"#))
- .renderer_policy()
- .response_delivery(),
- RendererInspectorResponseDelivery::CommandReply,
- "{method} still requires the command-reply completion path"
- );
- }
- }
-
#[test]
fn renderer_replacement_traits_are_computed_at_the_wire_boundary() {
for method in [
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 06a928d04..deb2113bc 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -537,7 +537,7 @@ pub(crate) use state::{
ParkedTargetOwnerState, PendingBidiChannelListener, PendingInspectorAwait,
PendingRendererCommandKey, PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction,
ProfilerInspectorCommand, RendererCommandCorrelation, RendererCommandDescriptor,
- RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
+ RendererCommandReplay, RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
RendererMainDocumentCommitSeed, RendererPageResidenceIdentity,
ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,
SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index d03a90e49..faed0bfc2 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -911,6 +911,19 @@ impl CdpConnection {
.flatten()
}
+ pub(crate) fn take_renderer_call_if_correlation_matches_for_session_owner(
+ &mut self,
+ session_id: Option<&str>,
+ correlation: RendererCommandCorrelation,
+ ) -> bool {
+ self.take_renderer_call_for_frontend_if_matches_for_session_owner(
+ session_id,
+ correlation.frontend_command_id().get(),
+ correlation.renderer_call_id(),
+ correlation.dispatched_attachment_id(),
+ ) == Some(correlation)
+ }
+
fn take_frontend_command_for_renderer_if_attachment_matches_for_session_owner(
&mut self,
session_id: Option<&str>,
@@ -4619,17 +4632,12 @@ impl CdpConnection {
let frontend_session_id = replay.frontend_session_id().map(str::to_owned);
let renderer_inspector_session_id =
replay.renderer_inspector_session_id().map(str::to_owned);
- let (correlation, dispatch, response_delivery, frontend_payload, response_sender) =
+ let (correlation, replay, response_delivery, frontend_payload, response_sender) =
replay.into_replay().into_parts();
- let raw_json = match self.rewrite_runtime_inspector_command_for_session_owner(
+ let route = match self.runtime_protocol_message_page_route_for_session_owner(
frontend_session_id.as_deref(),
- &frontend_payload,
- Some((
- correlation.frontend_command_id(),
- correlation.renderer_call_id(),
- )),
) {
- Ok(raw_json) => raw_json,
+ Ok(route) => route,
Err(error) => {
self.settle_renderer_replay_error(
&mut events,
@@ -4642,10 +4650,122 @@ impl CdpConnection {
continue;
}
};
- let route = match self.runtime_protocol_message_page_route_for_session_owner(
+ if route.renderer_agent_attachment_id != new_attachment_id {
+ self.settle_renderer_replay_error(
+ &mut events,
+ frontend_session_id.as_deref(),
+ response_delivery,
+ &response_sender,
+ correlation,
+ "renderer replay attachment is no longer current",
+ );
+ continue;
+ }
+ let dispatch = match replay {
+ RendererCommandReplay::Inspector(dispatch) => dispatch,
+ RendererCommandReplay::PerformanceGetMetrics => {
+ debug_assert_eq!(
+ response_delivery,
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+ let pending = self
+ .runtime_session_owner_page_mut(frontend_session_id.as_deref())
+ .map_err(|error| error.to_string())
+ .and_then(|page| {
+ let result = crate::domains::performance::performance_metrics_result(
+ &page.cached_performance_metric_snapshot(),
+ );
+ page.start_performance_get_metrics_from_io_with_response(
+ renderer_inspector_session_id.clone(),
+ result,
+ response_sender.clone(),
+ )
+ .map_err(|error| error.to_string())
+ });
+ let completion = match pending {
+ Ok(pending) => pending.wait().await.map_err(|error| error.to_string()),
+ Err(error) => Err(error),
+ };
+ match completion {
+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}
+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Canceled) => {
+ self.settle_renderer_replay_error(
+ &mut events,
+ frontend_session_id.as_deref(),
+ response_delivery,
+ &response_sender,
+ correlation,
+ "Inspected target navigated or closed",
+ );
+ }
+ Err(error) => {
+ self.settle_renderer_replay_error(
+ &mut events,
+ frontend_session_id.as_deref(),
+ response_delivery,
+ &response_sender,
+ correlation,
+ &format!("Performance replay dispatch failed: {error}"),
+ );
+ }
+ }
+ continue;
+ }
+ RendererCommandReplay::SetScriptExecutionDisabled { disabled } => {
+ debug_assert_eq!(
+ response_delivery,
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+ let pending = self
+ .runtime_session_owner_page_mut(frontend_session_id.as_deref())
+ .map_err(|error| error.to_string())
+ .and_then(|page| {
+ page.start_set_script_execution_disabled_from_io_with_response(
+ renderer_inspector_session_id.clone(),
+ disabled,
+ response_sender.clone(),
+ )
+ .map_err(|error| error.to_string())
+ });
+ let completion = match pending {
+ Ok(pending) => pending.wait().await.map_err(|error| error.to_string()),
+ Err(error) => Err(error),
+ };
+ match completion {
+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}
+ Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Canceled) => {
+ self.settle_renderer_replay_error(
+ &mut events,
+ frontend_session_id.as_deref(),
+ response_delivery,
+ &response_sender,
+ correlation,
+ "Inspected target navigated or closed",
+ );
+ }
+ Err(error) => {
+ self.settle_renderer_replay_error(
+ &mut events,
+ frontend_session_id.as_deref(),
+ response_delivery,
+ &response_sender,
+ correlation,
+ &format!("Emulation replay dispatch failed: {error}"),
+ );
+ }
+ }
+ continue;
+ }
+ };
+ let raw_json = match self.rewrite_runtime_inspector_command_for_session_owner(
frontend_session_id.as_deref(),
+ &frontend_payload,
+ Some((
+ correlation.frontend_command_id(),
+ correlation.renderer_call_id(),
+ )),
) {
- Ok(route) => route,
+ Ok(raw_json) => raw_json,
Err(error) => {
self.settle_renderer_replay_error(
&mut events,
@@ -4658,17 +4778,6 @@ impl CdpConnection {
continue;
}
};
- if route.renderer_agent_attachment_id != new_attachment_id {
- self.settle_renderer_replay_error(
- &mut events,
- frontend_session_id.as_deref(),
- response_delivery,
- &response_sender,
- correlation,
- "renderer replay attachment is no longer current",
- );
- continue;
- }
let pending = {
let page = match self.runtime_session_owner_page_mut(frontend_session_id.as_deref())
{
@@ -6034,6 +6143,7 @@ mod tests {
RendererCommandDescriptor::from_frontend_policy(
frontend.json().to_owned(),
frontend.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
),
)
.expect("frontend response correlation should register");
diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rs
index 2711f21b5..66e655b1b 100644
--- a/moli-protocol/src/conn/state/mod.rs
+++ b/moli-protocol/src/conn/state/mod.rs
@@ -87,7 +87,7 @@ pub(crate) use javascript_dialog::{
pub(crate) use pending_renderer_command::{
DuplicatePendingRendererCommand, PendingRendererCommandKey, PreparedRendererCallDispatch,
PreparedRendererCallTermination, RegisterRendererCallError, RendererCommandCorrelation,
- RendererCommandDescriptor,
+ RendererCommandDescriptor, RendererCommandReplay,
};
pub(crate) use profiler::{ProfilerAction, ProfilerInspectorCommand};
pub(crate) use service_worker_lifetime::{
diff --git a/moli-protocol/src/conn/state/pending_renderer_command.rs b/moli-protocol/src/conn/state/pending_renderer_command.rs
index 9b51cd780..cab42bd28 100644
--- a/moli-protocol/src/conn/state/pending_renderer_command.rs
+++ b/moli-protocol/src/conn/state/pending_renderer_command.rs
@@ -22,22 +22,55 @@ use serde_json::Value;
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct RendererCommandDescriptor {
replacement: CdpRendererCommandReplacement,
- replay_dispatch: CdpRendererCommandReplayDispatch,
+ replay: RendererCommandReplay,
response_delivery: RendererInspectorResponseDelivery,
frontend_payload: String,
}
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum RendererCommandReplay {
+ Inspector(CdpRendererCommandReplayDispatch),
+ PerformanceGetMetrics,
+ SetScriptExecutionDisabled { disabled: bool },
+}
+
impl RendererCommandDescriptor {
/// Builds a replay descriptor from the policy already derived at typed CDP
/// ingress. Production frontend commands must use this constructor.
pub(crate) fn from_frontend_policy(
frontend_payload: String,
policy: CdpRendererCommandPolicy,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Self {
Self {
replacement: policy.replacement(),
- replay_dispatch: policy.replay_dispatch(),
- response_delivery: policy.response_delivery(),
+ replay: RendererCommandReplay::Inspector(policy.replay_dispatch()),
+ response_delivery,
+ frontend_payload,
+ }
+ }
+
+ pub(crate) fn performance_get_metrics(
+ frontend_payload: String,
+ policy: CdpRendererCommandPolicy,
+ ) -> Self {
+ Self {
+ replacement: policy.replacement(),
+ replay: RendererCommandReplay::PerformanceGetMetrics,
+ response_delivery: RendererInspectorResponseDelivery::DevToolsSession,
+ frontend_payload,
+ }
+ }
+
+ pub(crate) fn set_script_execution_disabled(
+ frontend_payload: String,
+ policy: CdpRendererCommandPolicy,
+ disabled: bool,
+ ) -> Self {
+ Self {
+ replacement: policy.replacement(),
+ replay: RendererCommandReplay::SetScriptExecutionDisabled { disabled },
+ response_delivery: RendererInspectorResponseDelivery::DevToolsSession,
frontend_payload,
}
}
@@ -53,7 +86,7 @@ impl RendererCommandDescriptor {
let policy = command.renderer_policy();
Ok(Self {
replacement: policy.replacement(),
- replay_dispatch: policy.replay_dispatch(),
+ replay: RendererCommandReplay::Inspector(policy.replay_dispatch()),
// Internal Classic/BiDi adapters own their reply channel. A
// method being eligible for frontend session output must never
// redirect a synthesized adapter command implicitly.
@@ -66,8 +99,8 @@ impl RendererCommandDescriptor {
self.replacement
}
- pub(crate) const fn replay_dispatch(&self) -> CdpRendererCommandReplayDispatch {
- self.replay_dispatch
+ pub(crate) fn replay(&self) -> &RendererCommandReplay {
+ &self.replay
}
pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {
@@ -193,7 +226,7 @@ impl PreparedRendererCallDispatch {
#[derive(Debug)]
pub(crate) struct PreparedRendererCallReplay {
correlation: RendererCommandCorrelation,
- dispatch: CdpRendererCommandReplayDispatch,
+ replay: RendererCommandReplay,
response_delivery: RendererInspectorResponseDelivery,
frontend_payload: String,
response_sender: RendererRuntimeInspectorResponseSender,
@@ -240,14 +273,14 @@ impl PreparedRendererCallReplay {
self,
) -> (
RendererCommandCorrelation,
- CdpRendererCommandReplayDispatch,
+ RendererCommandReplay,
RendererInspectorResponseDelivery,
String,
RendererRuntimeInspectorResponseSender,
) {
(
self.correlation,
- self.dispatch,
+ self.replay,
self.response_delivery,
self.frontend_payload,
self.response_sender,
@@ -398,7 +431,7 @@ impl<T> PendingRendererCommandRegistry<T> {
renderer_call_id,
dispatched_attachment_id: Some(new_attachment_id),
},
- dispatch: call.descriptor.replay_dispatch(),
+ replay: call.descriptor.replay().clone(),
response_delivery: call.descriptor.response_delivery(),
frontend_payload: call.descriptor.frontend_payload().to_owned(),
response_sender,
@@ -817,15 +850,17 @@ mod tests {
CdpRendererCommandReplacement::Replay
);
assert_eq!(
- registered.replay_dispatch(),
- CdpRendererCommandReplayDispatch::Direct
+ registered.replay(),
+ &RendererCommandReplay::Inspector(CdpRendererCommandReplayDispatch::Direct)
);
assert_eq!(registered.frontend_payload(), expected_payload);
let add_binding = descriptor(32, "Runtime.addBinding");
assert_eq!(
- add_binding.replay_dispatch(),
- CdpRendererCommandReplayDispatch::ResolveRuntimeContext
+ add_binding.replay(),
+ &RendererCommandReplay::Inspector(
+ CdpRendererCommandReplayDispatch::ResolveRuntimeContext
+ )
);
}
@@ -841,34 +876,48 @@ mod tests {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
normalized_payload.clone(),
ingress.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
);
assert_eq!(descriptor.frontend_payload(), normalized_payload);
assert_eq!(
- descriptor.replay_dispatch(),
- CdpRendererCommandReplayDispatch::ResolveRuntimeContext,
+ descriptor.replay(),
+ &RendererCommandReplay::Inspector(
+ CdpRendererCommandReplayDispatch::ResolveRuntimeContext
+ ),
"descriptor construction must consume the ingress policy instead of deriving it from the normalized payload"
);
}
#[test]
- fn synthesized_adapter_command_keeps_its_explicit_reply_sink() {
+ fn concrete_target_capability_selects_the_response_sink() {
let frontend = ParsedCdpCommand::parse_str(
r#"{"id":33,"method":"Debugger.getScriptSource","params":{"scriptId":"1"}}"#,
)
.expect("frontend command must parse at ingress");
- let frontend_descriptor = RendererCommandDescriptor::from_frontend_policy(
+ let page_descriptor = RendererCommandDescriptor::from_frontend_policy(
+ frontend.json().to_owned(),
+ frontend.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ let worker_descriptor = RendererCommandDescriptor::from_frontend_policy(
frontend.json().to_owned(),
frontend.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
);
let adapter_descriptor =
RendererCommandDescriptor::from_synthesized_payload(frontend.json().to_owned())
.expect("adapter payload must be valid Inspector JSON");
assert_eq!(
- frontend_descriptor.response_delivery(),
+ page_descriptor.response_delivery(),
RendererInspectorResponseDelivery::DevToolsSession
);
+ assert_eq!(
+ worker_descriptor.response_delivery(),
+ RendererInspectorResponseDelivery::CommandReply,
+ "the method catalog must not choose a Page-only output capability for Workers"
+ );
assert_eq!(
adapter_descriptor.response_delivery(),
RendererInspectorResponseDelivery::CommandReply,
@@ -876,6 +925,44 @@ mod tests {
);
}
+ #[test]
+ fn non_v8_page_io_descriptors_keep_typed_replay_operations() {
+ let performance = ParsedCdpCommand::parse_str(
+ r#"{"id":34,"method":"Performance.getMetrics","params":{}}"#,
+ )
+ .expect("Performance command must parse at ingress");
+ let performance_descriptor = RendererCommandDescriptor::performance_get_metrics(
+ performance.json().to_owned(),
+ performance.renderer_policy(),
+ );
+ assert_eq!(
+ performance_descriptor.replay(),
+ &RendererCommandReplay::PerformanceGetMetrics
+ );
+ assert_eq!(
+ performance_descriptor.response_delivery(),
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+
+ let emulation = ParsedCdpCommand::parse_str(
+ r#"{"id":35,"method":"Emulation.setScriptExecutionDisabled","params":{"value":true}}"#,
+ )
+ .expect("Emulation command must parse at ingress");
+ let emulation_descriptor = RendererCommandDescriptor::set_script_execution_disabled(
+ emulation.json().to_owned(),
+ emulation.renderer_policy(),
+ true,
+ );
+ assert_eq!(
+ emulation_descriptor.replay(),
+ &RendererCommandReplay::SetScriptExecutionDisabled { disabled: true }
+ );
+ assert_eq!(
+ emulation_descriptor.response_delivery(),
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+ }
+
#[tokio::test]
async fn replay_rotates_renderer_id_attachment_and_response_lease() {
let frontend_id = FrontendCommandId::new(41);
@@ -898,6 +985,7 @@ mod tests {
RendererCommandDescriptor::from_frontend_policy(
frontend.json().to_owned(),
frontend.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
),
)
.unwrap();
diff --git a/moli-protocol/src/domains/debugger.rs b/moli-protocol/src/domains/debugger.rs
index b18dc3adc..f601da785 100644
--- a/moli-protocol/src/domains/debugger.rs
+++ b/moli-protocol/src/domains/debugger.rs
@@ -249,9 +249,11 @@ mod tests {
.await;
assert_eq!(timer["result"]["result"]["value"], json!(true));
+ let response_start = ctx.sent.len();
let scheduler_events = ctx
.process_command_only_async(json!({"id": 22, "method": "Debugger.pause"}))
.await;
+ ctx.wait_for_test_command_response(22, response_start).await;
let pause_position = ctx
.sent
.iter()
diff --git a/moli-protocol/src/domains/dom_debugger.rs b/moli-protocol/src/domains/dom_debugger.rs
index 067821ecf..bc8abdc61 100644
--- a/moli-protocol/src/domains/dom_debugger.rs
+++ b/moli-protocol/src/domains/dom_debugger.rs
@@ -427,6 +427,9 @@ mod tests {
let mut messages = Vec::new();
for resume in resumes {
+ let resume_id = resume["id"]
+ .as_u64()
+ .expect("Debugger.resume test command must have a numeric id");
let resume_session_id = resume.get("sessionId").cloned();
let paused = ctx
.wait_for_scheduler_message("pause preceding Debugger.resume", |message| {
@@ -439,6 +442,7 @@ mod tests {
.await;
messages.push(paused);
+ let response_start = ctx.sent.len();
let resume_step = ctx.conn.start_command_dispatch(&resume.to_string());
let (mut resume_messages, scheduler_events) = tokio::time::timeout(
DOM_DEBUGGER_COMMAND_TIMEOUT,
@@ -447,6 +451,14 @@ mod tests {
.await
.expect("Debugger.resume should complete after its matching pause");
assert!(scheduler_events.is_empty(), "{scheduler_events:?}");
+ if !resume_messages
+ .iter()
+ .any(|message| message["id"] == json!(resume_id))
+ {
+ ctx.wait_for_test_command_response(resume_id, response_start)
+ .await;
+ resume_messages.push(ctx.take_response_by_id(resume_id));
+ }
messages.append(&mut resume_messages);
}
diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rs
index 78cf7c3fa..a98615dd3 100644
--- a/moli-protocol/src/domains/emulation.rs
+++ b/moli-protocol/src/domains/emulation.rs
@@ -1,7 +1,7 @@
use crate::conn::{
BrowserContext, CdpConnection, CdpSessionRoute, Cmd, CommandOwnerScope, EmulatedDeviceMetrics,
- EmulatedGeolocationOverrideState, EmulatedViewportSurface,
- RuntimeInspectorAsyncCompletionReceiver, TargetWindowSurfaceState,
+ EmulatedGeolocationOverrideState, EmulatedViewportSurface, RendererCommandCorrelation,
+ RendererCommandDescriptor, RuntimeInspectorAsyncCompletionReceiver, TargetWindowSurfaceState,
};
use crate::devtools_runtime::{
DevToolsCommand, DevToolsCommandResult, DevToolsDevicePixelRatioSetting, DevToolsError,
@@ -45,12 +45,20 @@ pub(crate) struct CompletedEmulationCommandDispatch {
enum PendingEmulationRendererDispatch {
Pages(Vec<PendingEmulationPageCommand>),
- Io(PendingDevToolsIoCommandDispatch),
+ IoCommandReply(PendingDevToolsIoCommandDispatch),
+ IoSessionOutput {
+ pending: PendingDevToolsIoCommandDispatch,
+ correlation: RendererCommandCorrelation,
+ },
}
enum CompletedEmulationRendererDispatch {
Pages(Vec<CompletedEmulationPageCommand>),
- Io(Result<CompletedDevToolsIoCommandDispatch, String>),
+ IoCommandReply(Result<CompletedDevToolsIoCommandDispatch, String>),
+ IoSessionOutput {
+ completed: Result<CompletedDevToolsIoCommandDispatch, String>,
+ correlation: RendererCommandCorrelation,
+ },
}
struct PendingEmulationPageCommand {
@@ -125,11 +133,18 @@ impl PendingEmulationCommandDispatch {
}
CompletedEmulationRendererDispatch::Pages(completed)
}
- PendingEmulationRendererDispatch::Io(pending) => {
- CompletedEmulationRendererDispatch::Io(
+ PendingEmulationRendererDispatch::IoCommandReply(pending) => {
+ CompletedEmulationRendererDispatch::IoCommandReply(
pending.wait().await.map_err(|error| error.to_string()),
)
}
+ PendingEmulationRendererDispatch::IoSessionOutput {
+ pending,
+ correlation,
+ } => CompletedEmulationRendererDispatch::IoSessionOutput {
+ completed: pending.wait().await.map_err(|error| error.to_string()),
+ correlation,
+ },
};
CompletedEmulationCommandDispatch {
command_id: self.command_id,
@@ -345,14 +360,70 @@ fn start_script_execution_disabled_command(
"BrowserContextNotLoaded",
));
}
- let Some(page) = loaded_page_mut_for_session(conn, cmd.session_id) else {
+ let Some(attachment_id) = loaded_page_mut_for_session(conn, cmd.session_id)
+ .and_then(|page| page.renderer_agent_attachment_id())
+ else {
return EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})));
};
- let pending = page.start_set_script_execution_disabled_from_io(params.value);
+ let renderer_inspector_session_id =
+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
+ let Some(command_id) = cmd.id else {
+ let page = loaded_page_mut_for_session(conn, cmd.session_id)
+ .expect("the captured Emulation Page must remain loaded synchronously");
+ let pending = page.start_set_script_execution_disabled_from_io(params.value);
+ return EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
+ command_id: cmd.id,
+ session_id: cmd.session_id.map(str::to_owned),
+ pending: PendingEmulationRendererDispatch::IoCommandReply(pending),
+ });
+ };
+ let descriptor = RendererCommandDescriptor::set_script_execution_disabled(
+ cmd.json.to_owned(),
+ cmd.renderer_policy(),
+ params.value,
+ );
+ let prepared = match conn.try_register_renderer_call_for_session_owner(
+ cmd.session_id,
+ command_id,
+ Some(attachment_id),
+ descriptor,
+ ) {
+ Ok(prepared) => prepared,
+ Err(error) => {
+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error));
+ }
+ };
+ let (correlation, response, response_rx) = prepared.into_parts();
+ drop(response_rx);
+ let pending = loaded_page_mut_for_session(conn, cmd.session_id)
+ .filter(|page| page.renderer_agent_attachment_id() == Some(attachment_id))
+ .ok_or_else(|| "Emulation renderer attachment changed before IO dispatch".to_owned())
+ .and_then(|page| {
+ page.start_set_script_execution_disabled_from_io_with_response(
+ renderer_inspector_session_id,
+ params.value,
+ response,
+ )
+ .map_err(|error| error.to_string())
+ });
+ let pending = match pending {
+ Ok(pending) => pending,
+ Err(error) => {
+ let removed = conn.take_renderer_call_if_correlation_matches_for_session_owner(
+ cmd.session_id,
+ correlation,
+ );
+ debug_assert!(removed);
+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error));
+ }
+ };
EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: cmd.session_id.map(str::to_owned),
- pending: PendingEmulationRendererDispatch::Io(pending),
+ pending: PendingEmulationRendererDispatch::IoSessionOutput {
+ pending,
+ correlation,
+ },
})
}
@@ -2368,9 +2439,10 @@ pub(crate) fn complete_pending_emulation_command(
conn: &mut CdpConnection,
completed: CompletedEmulationCommandDispatch,
) -> CommandOutputPlan {
+ let session_id = completed.session_id.clone();
let completed_pages = match completed.completed {
CompletedEmulationRendererDispatch::Pages(completed_pages) => completed_pages,
- CompletedEmulationRendererDispatch::Io(completed) => {
+ CompletedEmulationRendererDispatch::IoCommandReply(completed) => {
return match completed {
Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {
CommandOutputPlan::result(json!({}))
@@ -2381,6 +2453,28 @@ pub(crate) fn complete_pending_emulation_command(
Err(error) => CommandOutputPlan::error(-32000, error),
};
}
+ CompletedEmulationRendererDispatch::IoSessionOutput {
+ completed: Ok(CompletedDevToolsIoCommandDispatch::Dispatched),
+ ..
+ } => return CommandOutputPlan::default(),
+ CompletedEmulationRendererDispatch::IoSessionOutput {
+ completed,
+ correlation,
+ } => {
+ if !conn.take_renderer_call_if_correlation_matches_for_session_owner(
+ session_id.as_deref(),
+ correlation,
+ ) {
+ return CommandOutputPlan::default();
+ }
+ return match completed {
+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
+ CommandOutputPlan::error(-32000, "Emulation IO command was canceled")
+ }
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => unreachable!(),
+ Err(error) => CommandOutputPlan::error(-32000, error),
+ };
+ }
};
for completed_page in completed_pages {
let completion = match completed_page.completed {
diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rs
index 473cbb6da..59171b8c2 100644
--- a/moli-protocol/src/domains/emulation/tests.rs
+++ b/moli-protocol/src/domains/emulation/tests.rs
@@ -194,11 +194,17 @@ async fn script_execution_disabled_completes_through_io_pending_dispatch() {
"params": { "value": true }
})
.to_string();
+ let response_start = ctx.sent.len();
let pending = ctx
.conn
.try_start_pending_command_dispatch(&raw)
.expect("the script execution override should use IO pending dispatch");
- let messages = complete_pending_command_task_for_test(&mut ctx, pending).await;
+ let mut messages = complete_pending_command_task_for_test(&mut ctx, pending).await;
+ if !messages.iter().any(|message| message["id"] == json!(9101)) {
+ ctx.wait_for_test_command_response(9101, response_start)
+ .await;
+ messages.push(ctx.take_response_by_id(9101));
+ }
assert!(messages.iter().any(|message| {
message["id"] == json!(9101)
@@ -214,6 +220,40 @@ async fn script_execution_disabled_completes_through_io_pending_dispatch() {
);
}
+#[tokio::test(flavor = "multi_thread")]
+async fn auxiliary_session_first_io_emulation_response_uses_its_session_host() {
+ let mut ctx = TestContext::new();
+ load_session_page_for_pending_emulation_test(&mut ctx).await;
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_mut()
+ .expect("browser context")
+ .assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned())
+ );
+ ctx.conn
+ .apply_runtime_binding_state_for_session_owner_async(Some("SID-aux"))
+ .await
+ .expect("target attachment should establish the auxiliary renderer session");
+
+ ctx.process_async(json!({
+ "id": 9_111,
+ "sessionId": "SID-aux",
+ "method": "Emulation.setScriptExecutionDisabled",
+ "params": { "value": true }
+ }))
+ .await;
+
+ ctx.expect_result(9_111, json!({}), Some("SID-aux"));
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_ref()
+ .expect("browser context")
+ .script_execution_disabled
+ );
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn timezone_override_can_complete_through_pending_command_dispatch() {
let mut ctx = TestContext::new();
diff --git a/moli-protocol/src/domains/performance.rs b/moli-protocol/src/domains/performance.rs
index e01f2c978..d4cc960c4 100644
--- a/moli-protocol/src/domains/performance.rs
+++ b/moli-protocol/src/domains/performance.rs
@@ -1,6 +1,6 @@
use crate::conn::{
CdpConnection, CdpRendererCommandAccess, Cmd, CommandOwnerScope, PerformanceTimeDomain,
- monotonic_timestamp_seconds,
+ RendererCommandCorrelation, RendererCommandDescriptor, monotonic_timestamp_seconds,
};
use crate::domains::actions::PerformanceAction;
use crate::domains::command_output::CommandOutputPlan;
@@ -41,15 +41,23 @@ pub(crate) struct CompletedPerformanceCommandDispatch {
enum PendingPerformanceRendererCommand {
Main(PendingPageCommand),
- Io {
+ IoCommandReply {
pending: PendingDevToolsIoCommandDispatch,
snapshot: RendererPerformanceMetricSnapshot,
},
+ IoSessionOutput {
+ pending: PendingDevToolsIoCommandDispatch,
+ correlation: RendererCommandCorrelation,
+ },
}
enum CompletedPerformanceRendererCommand {
Main(CompletedPageCommand),
- Io(RendererPerformanceMetricSnapshot),
+ IoCommandReply(RendererPerformanceMetricSnapshot),
+ IoSessionOutput {
+ completed: Result<CompletedDevToolsIoCommandDispatch, String>,
+ correlation: RendererCommandCorrelation,
+ },
}
pub(crate) enum PerformanceCommandTaskStep {
@@ -68,17 +76,24 @@ impl PendingPerformanceCommandDispatch {
.wait()
.await
.map(CompletedPerformanceRendererCommand::Main),
- PendingPerformanceRendererCommand::Io { pending, snapshot } => {
+ PendingPerformanceRendererCommand::IoCommandReply { pending, snapshot } => {
match pending.wait().await {
- Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {
- Ok(CompletedPerformanceRendererCommand::Io(snapshot))
- }
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => Ok(
+ CompletedPerformanceRendererCommand::IoCommandReply(snapshot),
+ ),
Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
Err(anyhow::anyhow!("Performance IO command was canceled"))
}
Err(error) => Err(error),
}
}
+ PendingPerformanceRendererCommand::IoSessionOutput {
+ pending,
+ correlation,
+ } => Ok(CompletedPerformanceRendererCommand::IoSessionOutput {
+ completed: pending.wait().await.map_err(|error| error.to_string()),
+ correlation,
+ }),
};
CompletedPerformanceCommandDispatch {
command_id: self.command_id,
@@ -222,23 +237,108 @@ pub(crate) fn try_start_performance_command_dispatch(
return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());
}
let owner_scope = CommandOwnerScope::capture(conn, cmd.session_id);
- let page = match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {
- Ok(page) => page,
- Err(_) => {
- return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());
- }
- };
if renderer_access == CdpRendererCommandAccess::Io {
- let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);
- let (pending, snapshot) = page.start_performance_metric_snapshot_from_io();
+ let (renderer_page, attachment_id, snapshot) = {
+ let page =
+ match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {
+ Ok(page) => page,
+ Err(_) => {
+ return PerformanceCommandTaskStep::Complete(
+ default_metrics_command_output_plan(),
+ );
+ }
+ };
+ (
+ crate::conn::RendererPageResidenceIdentity::from_page(page),
+ page.renderer_agent_attachment_id(),
+ page.cached_performance_metric_snapshot(),
+ )
+ };
+ let Some(command_id) = cmd.id else {
+ let page = loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access)
+ .expect("the captured Performance Page must remain loaded synchronously");
+ let (pending, snapshot) = page.start_performance_metric_snapshot_from_io();
+ return PerformanceCommandTaskStep::Pending(PendingPerformanceCommandDispatch {
+ command_id: cmd.id,
+ owner_scope,
+ renderer_access,
+ renderer_page,
+ pending: Box::new(PendingPerformanceRendererCommand::IoCommandReply {
+ pending,
+ snapshot,
+ }),
+ });
+ };
+ let Some(attachment_id) = attachment_id else {
+ return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());
+ };
+ let renderer_inspector_session_id =
+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
+ let result = performance_metrics_result(&snapshot);
+ let descriptor = RendererCommandDescriptor::performance_get_metrics(
+ cmd.json.to_owned(),
+ cmd.renderer_policy(),
+ );
+ let prepared = match conn.try_register_renderer_call_for_session_owner(
+ cmd.session_id,
+ command_id,
+ Some(attachment_id),
+ descriptor,
+ ) {
+ Ok(prepared) => prepared,
+ Err(error) => {
+ return PerformanceCommandTaskStep::Complete(CommandOutputPlan::error(
+ -32000, error,
+ ));
+ }
+ };
+ let (correlation, response, response_rx) = prepared.into_parts();
+ drop(response_rx);
+ let pending = loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access)
+ .ok()
+ .filter(|page| {
+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page
+ && page.renderer_agent_attachment_id() == Some(attachment_id)
+ })
+ .ok_or_else(|| "Performance renderer attachment changed before IO dispatch".to_owned())
+ .and_then(|page| {
+ page.start_performance_get_metrics_from_io_with_response(
+ renderer_inspector_session_id,
+ result,
+ response,
+ )
+ .map_err(|error| error.to_string())
+ });
+ let pending = match pending {
+ Ok(pending) => pending,
+ Err(error) => {
+ let removed = conn.take_renderer_call_if_correlation_matches_for_session_owner(
+ cmd.session_id,
+ correlation,
+ );
+ debug_assert!(removed);
+ return PerformanceCommandTaskStep::Complete(CommandOutputPlan::error(
+ -32000, error,
+ ));
+ }
+ };
return PerformanceCommandTaskStep::Pending(PendingPerformanceCommandDispatch {
command_id: cmd.id,
owner_scope,
renderer_access,
renderer_page,
- pending: Box::new(PendingPerformanceRendererCommand::Io { pending, snapshot }),
+ pending: Box::new(PendingPerformanceRendererCommand::IoSessionOutput {
+ pending,
+ correlation,
+ }),
});
}
+ let page = match loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access) {
+ Ok(page) => page,
+ Err(_) => {
+ return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());
+ }
+ };
let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);
let pending = match page.start_performance_metric_snapshot() {
Ok(pending) => pending,
@@ -266,7 +366,11 @@ fn default_metrics_command_output_plan() -> CommandOutputPlan {
fn performance_metrics_command_output_plan(
snapshot: &RendererPerformanceMetricSnapshot,
) -> CommandOutputPlan {
- CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(snapshot) }))
+ CommandOutputPlan::result(performance_metrics_result(snapshot))
+}
+
+pub(crate) fn performance_metrics_result(snapshot: &RendererPerformanceMetricSnapshot) -> Value {
+ json!({ "metrics": build_performance_metrics(snapshot) })
}
pub(crate) async fn complete_pending_performance_command(
@@ -296,7 +400,7 @@ pub(crate) async fn complete_pending_performance_command(
.and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok())
.unwrap_or_default()
}
- Ok(CompletedPerformanceRendererCommand::Io(snapshot)) => {
+ Ok(CompletedPerformanceRendererCommand::IoCommandReply(snapshot)) => {
let remains_current = loaded_page_mut_for_renderer_access(
owner_scope.conn_mut(),
session_id.as_deref(),
@@ -312,6 +416,27 @@ pub(crate) async fn complete_pending_performance_command(
RendererPerformanceMetricSnapshot::default()
}
}
+ Ok(CompletedPerformanceRendererCommand::IoSessionOutput {
+ completed,
+ correlation,
+ }) => {
+ if matches!(
+ completed,
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched)
+ ) {
+ return CommandOutputPlan::default();
+ }
+ if !owner_scope
+ .conn_mut()
+ .take_renderer_call_if_correlation_matches_for_session_owner(
+ session_id.as_deref(),
+ correlation,
+ )
+ {
+ return CommandOutputPlan::default();
+ }
+ RendererPerformanceMetricSnapshot::default()
+ }
Err(_) => RendererPerformanceMetricSnapshot::default(),
};
CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(&snapshot) }))
@@ -393,7 +518,7 @@ fn build_performance_metrics(snapshot: &RendererPerformanceMetricSnapshot) -> Ve
#[cfg(test)]
mod tests {
use super::*;
- use crate::conn::{BackgroundTarget, BrowserContext, CdpCommandTaskStep};
+ use crate::conn::{BrowserContext, CdpCommandTaskStep};
use crate::testing::TestContext;
use serde_json::json;
use std::collections::HashMap;
@@ -553,16 +678,12 @@ mod tests {
bc.set_target_url("data:text/html,performance-test".to_owned());
bc.set_active_target_id("TID-1".to_owned());
bc.attach_active_session("SID-1".to_owned());
- let page = ctx
- .conn
- .load_page_via_runtime_async(&format!("data:text/html,{html}"))
- .await
- .expect("test page should load");
- let _ = bc
- .active_target
- .runtime_slot
- .replace_loaded_page(Some(page));
ctx.conn.browser_context = Some(bc);
+ ctx.install_navigation_fixture_for_session_owner(
+ &format!("data:text/html,{html}"),
+ Some("SID-1"),
+ )
+ .await;
}
fn metric_map(response: &Value) -> HashMap<String, f64> {
@@ -582,7 +703,9 @@ mod tests {
async fn complete_command_task_step_for_test(
ctx: &mut TestContext,
step: CdpCommandTaskStep,
+ command_id: u64,
) -> Vec<Value> {
+ let response_start = ctx.sent.len();
let mut step = step;
loop {
match step {
@@ -590,7 +713,18 @@ mod tests {
let completed = pending.wait().await;
step = ctx.conn.complete_pending_command_dispatch(completed).await;
}
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,
+ CdpCommandTaskStep::Complete(outcome) => {
+ let mut messages = outcome.into_parts().0;
+ if !messages
+ .iter()
+ .any(|message| message["id"] == json!(command_id))
+ {
+ ctx.wait_for_test_command_response(command_id, response_start)
+ .await;
+ messages.push(ctx.take_response_by_id(command_id));
+ }
+ return messages;
+ }
}
}
}
@@ -695,6 +829,10 @@ mod tests {
.expect("browser context")
.assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned())
);
+ ctx.conn
+ .apply_runtime_binding_state_for_session_owner_async(Some("SID-aux"))
+ .await
+ .expect("target attachment should establish the auxiliary renderer session");
ctx.process_async(json!({
"id": 4_100,
@@ -777,7 +915,7 @@ mod tests {
})
.to_string();
let step = ctx.conn.start_command_dispatch(&raw);
- let mut messages = complete_command_task_step_for_test(&mut ctx, step).await;
+ let mut messages = complete_command_task_step_for_test(&mut ctx, step, 4_001).await;
let response = messages
.iter()
@@ -814,7 +952,7 @@ mod tests {
})
.to_string();
let step = ctx.conn.start_command_dispatch(&raw);
- let old_messages = complete_command_task_step_for_test(&mut ctx, step).await;
+ let old_messages = complete_command_task_step_for_test(&mut ctx, step, 4_011).await;
let old_response = old_messages
.iter()
.find(|message| message["id"] == json!(4_011))
@@ -823,22 +961,11 @@ mod tests {
assert!(old_metrics["Documents"] >= 1.0);
assert!(old_metrics["Nodes"] >= 6.0);
- let replacement = ctx
- .conn
- .load_page_via_runtime_async(
- "data:text/html,<!doctype html><body><article>replacement</article></body>",
- )
- .await
- .expect("replacement performance page should load");
- let previous = ctx
- .conn
- .browser_context
- .as_mut()
- .expect("browser context")
- .active_target
- .runtime_slot
- .replace_loaded_page(Some(replacement));
- drop(previous);
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<!doctype html><body><article>replacement</article></body>",
+ Some("SID-1"),
+ )
+ .await;
let replacement_raw = json!({
"id": 4_012,
@@ -847,7 +974,7 @@ mod tests {
})
.to_string();
let step = ctx.conn.start_command_dispatch(&replacement_raw);
- let replacement_messages = complete_command_task_step_for_test(&mut ctx, step).await;
+ let replacement_messages = complete_command_task_step_for_test(&mut ctx, step, 4_012).await;
let replacement_response = replacement_messages
.iter()
.find(|message| message["id"] == json!(4_012))
@@ -860,26 +987,21 @@ mod tests {
#[tokio::test(flavor = "multi_thread")]
async fn performance_get_metrics_targets_loaded_background_owner_without_promotion() {
let mut ctx = TestContext::new();
- let page = ctx
- .conn
- .load_page_via_runtime_async(
- "data:text/html,<!doctype html><body><main><section></section><section></section></main></body>",
- )
- .await
- .expect("background performance page should load");
- let mut background = BackgroundTarget::with_url(
- "TID-background".to_owned(),
- Some("SID-background".to_owned()),
- page.final_url().as_str().to_owned(),
- );
- background.replace_loaded_page(Some(page));
-
+ let background_url = "data:text/html,<!doctype html><body><main><section></section><section></section></main></body>";
let mut bc = BrowserContext::new("BID-1".into());
bc.set_active_target_id("TID-active".to_owned());
bc.attach_active_session("SID-active".to_owned());
bc.set_target_url("data:text/html,<body>active</body>".to_owned());
- bc.background_targets.push(background);
+ bc.stage_background_target(
+ "TID-background".to_owned(),
+ Some("SID-background".to_owned()),
+ background_url.to_owned(),
+ None,
+ None,
+ );
ctx.conn.browser_context = Some(bc);
+ ctx.install_navigation_fixture_for_session_owner(background_url, Some("SID-background"))
+ .await;
ctx.process_async(json!({
"id": 5,
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index 2933c10a9..36d439720 100644
--- a/moli-protocol/src/domains/runtime/dispatcher.rs
+++ b/moli-protocol/src/domains/runtime/dispatcher.rs
@@ -1871,8 +1871,11 @@ fn start_pending_runtime_io_inspector_dispatch(
inspector_json: String,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
- let descriptor =
- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());
+ let descriptor = RendererCommandDescriptor::from_frontend_policy(
+ inspector_json,
+ cmd.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ );
conn.start_runtime_io_protocol_message_for_session_owner_with_deferred_response(
cmd.session_id,
descriptor,
@@ -1890,8 +1893,11 @@ fn start_pending_runtime_context_resolved_inspector_dispatch(
inspector_json: String,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
- let descriptor =
- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());
+ let descriptor = RendererCommandDescriptor::from_frontend_policy(
+ inspector_json,
+ cmd.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
+ );
conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response(
cmd.session_id,
action,
@@ -1913,8 +1919,11 @@ fn start_pending_runtime_inspector_dispatch(
inspector_json: String,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
- let descriptor =
- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());
+ let descriptor = RendererCommandDescriptor::from_frontend_policy(
+ inspector_json,
+ cmd.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
+ );
conn.start_runtime_protocol_message_for_session_owner_with_deferred_response(
cmd.session_id,
descriptor,
@@ -1931,8 +1940,11 @@ fn start_shared_worker_frontend_inspector_dispatch(
inspector_json: String,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
- let descriptor =
- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());
+ let descriptor = RendererCommandDescriptor::from_frontend_policy(
+ inspector_json,
+ cmd.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
+ );
conn.start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(
cmd.session_id,
descriptor,
@@ -1952,8 +1964,11 @@ fn start_service_worker_frontend_inspector_dispatch(
inspector_json: String,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
- let descriptor =
- RendererCommandDescriptor::from_frontend_policy(inspector_json, cmd.renderer_policy());
+ let descriptor = RendererCommandDescriptor::from_frontend_policy(
+ inspector_json,
+ cmd.renderer_policy(),
+ RendererInspectorResponseDelivery::CommandReply,
+ );
conn.start_service_worker_runtime_protocol_message_for_session_with_deferred_response(
cmd.session_id,
descriptor,
@@ -7615,6 +7630,7 @@ fn start_pending_runtime_binding_inspector_phase(
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
task.renderer_policy,
+ RendererInspectorResponseDelivery::CommandReply,
);
conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response(
completed.session_id(),
@@ -7635,6 +7651,7 @@ fn start_pending_runtime_binding_inspector_phase(
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
task.renderer_policy,
+ RendererInspectorResponseDelivery::CommandReply,
);
conn.start_runtime_protocol_message_for_session_owner_with_deferred_response(
completed.session_id(),
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index a1b4a8a5d..0424b1d2b 100644
--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs
+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs
@@ -673,13 +673,23 @@ async fn loaded_page_terminate_execution_dispatches_through_v8_runtime_agent() {
"method": "Runtime.terminateExecution"
})
.to_string();
+ let response_start = ctx.sent.len();
let step = ctx.conn.start_command_dispatch(&raw);
assert!(
matches!(&step, CdpCommandTaskStep::Pending(_)),
"Runtime.terminateExecution should dispatch to V8 Runtime agent instead of failing as UnknownMethod"
);
- let (messages, scheduler_events) = complete_command_task_step_for_test(&mut ctx, step).await;
+ let (mut messages, scheduler_events) =
+ complete_command_task_step_for_test(&mut ctx, step).await;
+ if !messages
+ .iter()
+ .any(|message| message["id"] == json!(11_009))
+ {
+ ctx.wait_for_test_command_response(11_009, response_start)
+ .await;
+ messages.push(ctx.take_response_by_id(11_009));
+ }
assert!(
scheduler_events.is_empty(),
"Runtime.terminateExecution should not enqueue scheduler work: {scheduler_events:?}"
diff --git a/moli-protocol/src/domains/target/tests/tests_background_staging.rs b/moli-protocol/src/domains/target/tests/tests_background_staging.rs
index 38fbbc345..3acc82a9c 100644
--- a/moli-protocol/src/domains/target/tests/tests_background_staging.rs
+++ b/moli-protocol/src/domains/target/tests/tests_background_staging.rs
@@ -4104,11 +4104,15 @@ async fn same_context_background_session_can_reenable_its_own_script_execution_b
.as_ref()
.expect("active browser context");
assert!(!active.script_execution_disabled);
+ // A completed renderer call may retain its monotonic correlation
+ // allocator in the parked session; only the effective setting must
+ // collapse back to the default.
assert!(
active
.parked_page_session_state(&second_target_id)
- .is_none(),
- "script execution re-enable should collapse staged parked state back to default"
+ .is_none_or(|state| !state.script_execution_disabled),
+ "script execution re-enable should clear the staged parked setting: {:#?}",
+ active.parked_page_session_state(&second_target_id)
);
}
diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rs
index 7461645d3..11cc17fb6 100644
--- a/moli-protocol/src/testing.rs
+++ b/moli-protocol/src/testing.rs
@@ -23,7 +23,6 @@ use moli_core::{
RendererOutputStreamIdentity, RendererOutputTransportMessage, runtime::NavigationRuntimeConfig,
};
use moli_fetch::FetchConfig;
-use moli_page_types::RendererInspectorResponseDelivery;
#[cfg(test)]
use std::net::SocketAddr;
#[cfg(test)]
@@ -382,7 +381,22 @@ impl TestContext {
pub async fn process_async(&mut self, msg: impl serde::Serialize) {
let command = ParsedCdpCommand::from_serializable(msg)
.expect("test message must be a valid serialisable CDP command");
+ let command_id = command.request().id();
+ let session_id = command.request().session_id().map(str::to_owned);
+ let response_start = self.sent.len();
Box::pin(self.process_parsed_command_like_scheduler(&command, true)).await;
+ Box::pin(self.route_ready_test_command_response(command_id, response_start)).await;
+ if self
+ .conn
+ .renderer_runtime_command_cause_for_frontend(session_id.as_deref(), command_id)
+ .is_some()
+ && !self
+ .pending_runtime_deferred_replies
+ .iter()
+ .any(|pending| pending.command_id() == Some(command_id))
+ {
+ Box::pin(self.wait_for_test_command_response(command_id, response_start)).await;
+ }
}
/// Dispatch one command and keep running the real scheduler inputs until
@@ -393,15 +407,8 @@ impl TestContext {
.expect("test message must be a valid serialisable CDP command");
let command_id = command.request().id();
let response_start = self.sent.len();
- let response_uses_renderer_publication = command.renderer_policy().response_delivery()
- == RendererInspectorResponseDelivery::DevToolsSession;
Box::pin(self.process_parsed_command_like_scheduler(&command, true)).await;
- Box::pin(self.wait_for_test_command_response(
- command_id,
- response_start,
- response_uses_renderer_publication,
- ))
- .await;
+ Box::pin(self.wait_for_test_command_response(command_id, response_start)).await;
}
#[cfg(test)]
@@ -1224,39 +1231,50 @@ impl TestContext {
TestSchedulerTurnOutcome::Processed(input_kind)
}
- async fn wait_for_test_command_response(
+ pub(crate) async fn wait_for_test_command_response(
&mut self,
command_id: u64,
response_start: usize,
- response_uses_renderer_publication: bool,
) {
- loop {
- if self
- .sent
- .get(response_start..)
- .unwrap_or_default()
- .iter()
- .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))
- {
- return;
+ let response = tokio::time::timeout(TEST_SCHEDULER_INPUT_TIMEOUT, async {
+ loop {
+ if self
+ .sent
+ .get(response_start..)
+ .unwrap_or_default()
+ .iter()
+ .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))
+ {
+ return;
+ }
+ assert!(
+ matches!(
+ Box::pin(self.wait_for_one_test_scheduler_turn()).await,
+ TestSchedulerTurnOutcome::Processed(_)
+ ),
+ "CDP command `{command_id}` lost all scheduler input before its response"
+ );
}
- assert!(
- self.background_navigation_scheduler_enabled
- || response_uses_renderer_publication
- || self
- .pending_runtime_deferred_replies
- .iter()
- .any(|pending| pending.command_id() == Some(command_id)),
- "CDP command `{command_id}` completed without producing a response or a typed pending reply"
- );
- assert!(
- matches!(
- Box::pin(self.wait_for_one_test_scheduler_turn()).await,
- TestSchedulerTurnOutcome::Processed(_)
- ),
- "CDP command `{command_id}` lost all scheduler input before its response"
- );
- }
+ })
+ .await;
+ assert!(
+ response.is_ok(),
+ "timed out waiting for CDP command `{command_id}` response"
+ );
+ }
+
+ async fn route_ready_test_command_response(&mut self, command_id: u64, response_start: usize) {
+ while !self
+ .sent
+ .get(response_start..)
+ .unwrap_or_default()
+ .iter()
+ .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))
+ && matches!(
+ Box::pin(self.run_one_ready_test_scheduler_turn()).await,
+ TestSchedulerTurnOutcome::Processed(_)
+ )
+ {}
}
async fn wait_for_one_test_scheduler_turn(&mut self) -> TestSchedulerTurnOutcome {
diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs
index 1dff3b5c9..9db4b4ef8 100644
--- a/moli-renderer-v8/src/devtools/command.rs
+++ b/moli-renderer-v8/src/devtools/command.rs
@@ -149,10 +149,14 @@ pub struct RendererDevToolsIoCommandEnvelope {
pub(crate) enum RendererDevToolsIoCommandPayload {
Inspector(RendererInspectorCommandEnvelope),
- PerformanceGetMetrics,
+ PerformanceGetMetrics {
+ result: Value,
+ response: Option<RendererRuntimeInspectorResponseSender>,
+ },
SetScriptExecutionDisabled {
control: RendererScriptExecutionControl,
disabled: bool,
+ response: Option<RendererRuntimeInspectorResponseSender>,
},
}
@@ -179,7 +183,24 @@ impl RendererDevToolsIoCommandEnvelope {
pub(crate) fn performance_get_metrics(ticket: RendererInspectorIngressTicket) -> Self {
Self::new_agent_command(
ticket,
- RendererDevToolsIoCommandPayload::PerformanceGetMetrics,
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics {
+ result: Value::Null,
+ response: None,
+ },
+ )
+ }
+
+ pub(crate) fn performance_get_metrics_with_response(
+ ticket: RendererInspectorIngressTicket,
+ result: Value,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Self {
+ Self::new_agent_command(
+ ticket,
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics {
+ result,
+ response: Some(response),
+ },
)
}
@@ -190,7 +211,27 @@ impl RendererDevToolsIoCommandEnvelope {
) -> Self {
Self::new_agent_command(
ticket,
- RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { control, disabled },
+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
+ control,
+ disabled,
+ response: None,
+ },
+ )
+ }
+
+ pub(crate) fn set_script_execution_disabled_with_response(
+ ticket: RendererInspectorIngressTicket,
+ control: RendererScriptExecutionControl,
+ disabled: bool,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Self {
+ Self::new_agent_command(
+ ticket,
+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
+ control,
+ disabled,
+ response: Some(response),
+ },
)
}
@@ -219,7 +260,7 @@ impl RendererDevToolsIoCommandEnvelope {
RendererDevToolsIoCommandPayload::Inspector(_) => {
RendererDevToolsIoCommandKind::Inspector
}
- RendererDevToolsIoCommandPayload::PerformanceGetMetrics => {
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics { .. } => {
RendererDevToolsIoCommandKind::Performance
}
RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { .. } => {
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index d5eea0960..59f784ca6 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -204,6 +204,33 @@ impl RendererPageHandle {
)
}
+ #[doc(hidden)]
+ pub fn enqueue_performance_get_metrics_io_command_with_response(
+ &self,
+ attachment: RendererAgentAttachmentId,
+ inspector_session_id: Option<String>,
+ result: serde_json::Value,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> RendererRuntimeInspectorIoCommandRoute {
+ debug_assert_eq!(
+ response.renderer_agent_attachment_id(),
+ Some(attachment),
+ "Performance response must belong to the command attachment"
+ );
+ self.devtools_target.io_ref().enqueue_command(
+ self.devtools_agent_token,
+ RendererDevToolsIoCommandEnvelope::performance_get_metrics_with_response(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ result,
+ response,
+ ),
+ )
+ }
+
pub fn enqueue_runtime_inspector_main_command(
&self,
envelope: RendererInspectorCommandEnvelope,
@@ -242,6 +269,34 @@ impl RendererPageHandle {
)
}
+ #[doc(hidden)]
+ pub fn enqueue_set_script_execution_disabled_io_command_with_response(
+ &self,
+ attachment: RendererAgentAttachmentId,
+ inspector_session_id: Option<String>,
+ disabled: bool,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> RendererRuntimeInspectorIoCommandRoute {
+ debug_assert_eq!(
+ response.renderer_agent_attachment_id(),
+ Some(attachment),
+ "Emulation response must belong to the command attachment"
+ );
+ self.devtools_target.io_ref().enqueue_command(
+ self.devtools_agent_token,
+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled_with_response(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ self.script_execution_control.clone(),
+ disabled,
+ response,
+ ),
+ )
+ }
+
pub fn arm_runtime_inspector_session_detach(
&self,
) -> RendererRuntimeInspectorSessionDetachGuard {
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index ee5c9c2b0..779deb775 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -3838,6 +3838,13 @@ impl PageVm {
stored_runtime_bindings: &[crate::protocol_types::RuntimeBindingRegistration],
session_runtime_bindings: &[crate::protocol_types::RuntimeBindingRegistration],
) {
+ // Target attachment applies binding state before exposing the session
+ // to frontend commands. Even an empty state must establish the
+ // concrete renderer DevTools session/output capability: otherwise an
+ // auxiliary session whose first command is a non-V8 IO agent has no
+ // session host through which to publish its terminal response.
+ self.vm_mut()
+ .ensure_runtime_inspector_session(inspector_session_id);
self.set_stored_runtime_bindings(stored_runtime_bindings);
self.set_inspector_session_runtime_bindings(inspector_session_id, session_runtime_bindings);
}
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 35062633d..62d9172ee 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -6900,6 +6900,14 @@ impl ScriptVm {
});
}
+ pub(super) fn ensure_runtime_inspector_session(&mut self, inspector_session_id: Option<&str>) {
+ let renderer_document_isolate = self.renderer_document_isolate.clone();
+ let page_inspector = &self.page_inspector;
+ renderer_document_isolate.with_renderer_document_isolate_and_inspector_mut(|_, backend| {
+ page_inspector.ensure_frontend_session(backend, inspector_session_id);
+ });
+ }
+
pub(super) fn page_diagnostics_snapshot(&mut self) -> Result<RendererPageDiagnosticsSnapshot> {
self.sync_runtime_observable_source_events()?;
let runtime_observable_source = self
diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rs
index 6f81bdf7a..c9975e14a 100644
--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs
@@ -171,6 +171,15 @@ impl DocumentInspectorBinding {
}
}
+ pub(super) fn ensure_frontend_session(
+ &self,
+ backend: &mut RendererInspectorIsolateBackend,
+ inspector_session_id: Option<&str>,
+ ) {
+ self.agent
+ .ensure_frontend(backend, inspector_session_key(inspector_session_id));
+ }
+
pub(super) fn end_runtime_command_output_for_session(
&self,
inspector_session_id: Option<&str>,
diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
index 6669ac91e..112b0aeb6 100644
--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
@@ -418,7 +418,28 @@ impl InspectorOutbound {
callback: RendererRuntimeInspectorResponseSender,
delivery: RendererInspectorResponseDelivery,
) {
- let callback = match delivery {
+ let callback = self.route_frontend_response(callback, delivery);
+ self.register_response_callback(callback);
+ }
+
+ /// Publishes a synchronous non-V8 agent response through this concrete
+ /// frontend session's attachment-scoped output capability.
+ pub(in crate::script_vm) fn publish_devtools_session_response(
+ &self,
+ callback: RendererRuntimeInspectorResponseSender,
+ message: Value,
+ ) {
+ let callback = self
+ .route_frontend_response(callback, RendererInspectorResponseDelivery::DevToolsSession);
+ let _ = callback.send(message);
+ }
+
+ fn route_frontend_response(
+ &self,
+ callback: RendererRuntimeInspectorResponseSender,
+ delivery: RendererInspectorResponseDelivery,
+ ) -> RendererRuntimeInspectorResponseSender {
+ match delivery {
RendererInspectorResponseDelivery::CommandReply => callback,
RendererInspectorResponseDelivery::DevToolsSession => {
let host = self
@@ -437,8 +458,7 @@ impl InspectorOutbound {
.expect("frontend session output requires an attachment-scoped Page journal");
callback.route_to_devtools_session_output(host)
}
- };
- self.register_response_callback(callback);
+ }
}
pub(in crate::script_vm) fn cancel_response_callback(&self, call_id: i32) {
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 0f1d336ed..56ec1d607 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -224,15 +224,13 @@ impl RendererInspectorSessionExecutorLocal {
}
fn dispatch_io_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {
- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
- let session_key = command.ticket().session().clone();
- self.sessions
- .borrow()
- .get(&(context_group_id, session_key))
- .filter(|session| session.agent_token == command.agent_token)
- .cloned()
- });
- let session = session.flatten();
+ 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);
}
@@ -265,14 +263,12 @@ impl RendererInspectorSessionExecutorLocal {
let Some(command) = self.target.io_ref().claim_for_interrupt() else {
return;
};
- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
- let session_key = command.ticket().session();
- self.interrupt_sessions
- .borrow()
- .get(&(command.agent_token, session_key.clone()))
- .cloned()
- });
- let session = session.flatten();
+ let session_key = command.ticket().session();
+ let session = self
+ .interrupt_sessions
+ .borrow()
+ .get(&(command.agent_token, session_key.clone()))
+ .cloned();
self.dispatch_io_command_to_session(command, session);
}
@@ -280,14 +276,12 @@ impl RendererInspectorSessionExecutorLocal {
let Some(command) = self.target.io_ref().claim_for_owner() else {
return;
};
- let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
- let session_key = command.ticket().session();
- self.interrupt_sessions
- .borrow()
- .get(&(command.agent_token, session_key.clone()))
- .cloned()
- });
- let session = session.flatten();
+ let session_key = command.ticket().session();
+ let session = self
+ .interrupt_sessions
+ .borrow()
+ .get(&(command.agent_token, session_key.clone()))
+ .cloned();
self.dispatch_io_command_to_session(command, session);
}
@@ -337,13 +331,25 @@ impl RendererInspectorSessionExecutorLocal {
let mut first_dispatch = self.target.io_ref().first_dispatch_guard(&mut command);
match command.kind() {
RendererDevToolsIoCommandKind::Performance => {
- assert!(
- matches!(
- command.into_payload(),
- RendererDevToolsIoCommandPayload::PerformanceGetMetrics
- ),
- "Performance IO command kind must carry a Performance payload"
- );
+ let RendererDevToolsIoCommandPayload::PerformanceGetMetrics { result, response } =
+ command.into_payload()
+ else {
+ unreachable!("Performance IO command kind must carry a Performance payload")
+ };
+ if let Some(response) = response {
+ let Some(session) = session else {
+ send_inspector_dispatch_error(
+ Some(response),
+ "Inspector session is not available",
+ );
+ return;
+ };
+ let call_id = response.call_id();
+ session.outbound.publish_devtools_session_response(
+ response,
+ json!({ "id": call_id, "result": result }),
+ );
+ }
first_dispatch.release();
return;
}
@@ -351,11 +357,26 @@ impl RendererInspectorSessionExecutorLocal {
let RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
control,
disabled,
+ response,
} = command.into_payload()
else {
unreachable!("Emulation IO command kind must carry an Emulation payload")
};
+ if response.is_some() && session.is_none() {
+ send_inspector_dispatch_error(response, "Inspector session is not available");
+ return;
+ }
control.set_disabled(disabled);
+ if let Some(response) = response {
+ let call_id = response.call_id();
+ session
+ .expect("a checked frontend Emulation command must have a session")
+ .outbound
+ .publish_devtools_session_response(
+ response,
+ json!({ "id": call_id, "result": {} }),
+ );
+ }
first_dispatch.release();
return;
}