Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(cdp): unify renderer session response authority

ldm04d0b78f1f81f
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 68a26966e..83c86d416 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/inspector_routing.py
@@ -1049,6 +1049,57 @@ async def _nested_v8_main_receiver_matrix(
if not isinstance(call_frame_id, str) or not call_frame_id:
raise SmokeError(f"auxiliary pause has no callFrameId: {call_frames[0]}")
+ cross_session_ids: dict[str, list[int]] = {
+ page.primary_session_id: [],
+ page.auxiliary_session_id: [],
+ }
+ cross_session_expected_values: dict[int, int] = {}
+ for index in range(32):
+ for session_id, base in (
+ (page.primary_session_id, 1000),
+ (page.auxiliary_session_id, 2000),
+ ):
+ message_id = await client.send(
+ "Runtime.evaluate",
+ {
+ "expression": str(base + index),
+ "returnByValue": True,
+ },
+ session_id=session_id,
+ )
+ cross_session_ids[session_id].append(message_id)
+ cross_session_expected_values[message_id] = base + index
+ cross_session_expected_ids = set(cross_session_expected_values)
+ cross_session_responses, cross_session_seen = await _recv_responses(
+ client,
+ cross_session_expected_ids,
+ timeout=10,
+ )
+ cross_session_seen.extend(await _recv_for(client, 0.1))
+ for session_id, message_ids in cross_session_ids.items():
+ response_order = [
+ message["id"]
+ for message in cross_session_seen
+ if message.get("id") in message_ids
+ ]
+ assert_equal(
+ response_order,
+ message_ids,
+ f"nested Main per-session response order for {session_id}",
+ )
+ for message_id in message_ids:
+ response = cross_session_responses[message_id]
+ assert_equal(
+ response.get("sessionId"),
+ session_id,
+ f"nested Main response session for {message_id}",
+ )
+ assert_equal(
+ response.get("result", {}).get("result", {}).get("value"),
+ cross_session_expected_values[message_id],
+ f"nested Main cross-session value for {message_id}",
+ )
+
fifo_ids = [
await client.send(
"Runtime.evaluate",
@@ -1089,12 +1140,26 @@ async def _nested_v8_main_receiver_matrix(
if not isinstance(remote_object_id, str) or not remote_object_id:
raise SmokeError(f"nested Main object evaluate returned no objectId: {object_response}")
- properties_id = await client.send(
- "Runtime.getProperties",
- {"objectId": remote_object_id, "ownProperties": True},
- session_id=page.auxiliary_session_id,
+ property_ids = [
+ await client.send(
+ "Runtime.getProperties",
+ {"objectId": remote_object_id, "ownProperties": True},
+ session_id=page.auxiliary_session_id,
+ )
+ for _ in range(256)
+ ]
+ property_responses, property_seen = await _recv_responses(
+ client, set(property_ids), timeout=10
+ )
+ property_response_order = [
+ message["id"] for message in property_seen if message.get("id") in property_ids
+ ]
+ assert_equal(
+ property_response_order,
+ property_ids,
+ "nested Main Runtime.getProperties completion burst order",
)
- properties, _ = await client.recv_until_id(properties_id, timeout=5)
+ properties = property_responses[property_ids[0]]
descriptors = properties.get("result", {}).get("result", [])
if not any(
descriptor.get("name") == "answer"
@@ -1104,6 +1169,53 @@ async def _nested_v8_main_receiver_matrix(
):
raise SmokeError(f"nested Main getProperties missed answer=42: {properties}")
+ mixed_property_ids: list[int] = []
+ mixed_property_should_succeed: dict[int, bool] = {}
+ for index in range(128):
+ should_succeed = index % 2 == 0
+ message_id = await client.send(
+ "Runtime.getProperties",
+ {
+ "objectId": (
+ remote_object_id
+ if should_succeed
+ else f"missing-object-{index}"
+ ),
+ "ownProperties": True,
+ },
+ session_id=page.auxiliary_session_id,
+ )
+ mixed_property_ids.append(message_id)
+ mixed_property_should_succeed[message_id] = should_succeed
+ mixed_property_responses, mixed_property_seen = await _recv_responses(
+ client,
+ set(mixed_property_ids),
+ timeout=10,
+ )
+ mixed_property_seen.extend(await _recv_for(client, 0.1))
+ mixed_property_response_order = [
+ message["id"]
+ for message in mixed_property_seen
+ if message.get("id") in mixed_property_should_succeed
+ ]
+ assert_equal(
+ mixed_property_response_order,
+ mixed_property_ids,
+ "nested Main mixed-success getProperties response order",
+ )
+ for message_id in mixed_property_ids:
+ response = mixed_property_responses[message_id]
+ if mixed_property_should_succeed[message_id]:
+ if "error" in response:
+ raise SmokeError(
+ f"valid mixed getProperties command failed: {response}"
+ )
+ continue
+ if "error" not in response:
+ raise SmokeError(
+ f"invalid mixed getProperties command unexpectedly succeeded: {response}"
+ )
+
call_id = await client.send(
"Runtime.callFunctionOn",
{
@@ -1120,21 +1232,40 @@ async def _nested_v8_main_receiver_matrix(
"nested Main object-targeted callFunctionOn",
)
- frame_evaluate_id = await client.send(
- "Debugger.evaluateOnCallFrame",
- {
- "callFrameId": call_frame_id,
- "expression": "40 + 2",
- "returnByValue": True,
- },
- session_id=page.auxiliary_session_id,
+ frame_evaluate_ids = [
+ await client.send(
+ "Debugger.evaluateOnCallFrame",
+ {
+ "callFrameId": call_frame_id,
+ "expression": "40 + 2",
+ "returnByValue": True,
+ },
+ session_id=page.auxiliary_session_id,
+ )
+ for _ in range(64)
+ ]
+ frame_evaluate_responses, frame_evaluate_seen = await _recv_responses(
+ client, set(frame_evaluate_ids), timeout=10
)
- frame_evaluate, _ = await client.recv_until_id(frame_evaluate_id, timeout=5)
+ frame_evaluate_response_order = [
+ message["id"]
+ for message in frame_evaluate_seen
+ if message.get("id") in frame_evaluate_ids
+ ]
assert_equal(
- frame_evaluate.get("result", {}).get("result", {}).get("value"),
- 42,
- "nested Main Debugger.evaluateOnCallFrame",
+ frame_evaluate_response_order,
+ frame_evaluate_ids,
+ "nested Main Debugger.evaluateOnCallFrame completion burst order",
)
+ for frame_evaluate_id in frame_evaluate_ids:
+ assert_equal(
+ frame_evaluate_responses[frame_evaluate_id]
+ .get("result", {})
+ .get("result", {})
+ .get("value"),
+ 42,
+ "nested Main Debugger.evaluateOnCallFrame",
+ )
context_evaluate_id = await client.send(
"Runtime.evaluate",
@@ -1197,14 +1328,21 @@ async def _nested_v8_main_receiver_matrix(
),
source="Chromium nested main-thread RunLoop executable probe",
commands=[
- "Runtime.evaluate",
- "Runtime.getProperties",
+ "Runtime.evaluate (cross-session burst)",
+ "Runtime.getProperties (success and error bursts)",
"Runtime.callFunctionOn",
"Debugger.evaluateOnCallFrame",
"Debugger.resume",
],
observed={
"fifoResponseOrder": fifo_response_order,
+ "crossSessionBurstCounts": {
+ session_id: len(message_ids)
+ for session_id, message_ids in cross_session_ids.items()
+ },
+ "getPropertiesBurstCount": len(property_response_order),
+ "mixedGetPropertiesBurstCount": len(mixed_property_response_order),
+ "evaluateOnCallFrameBurstCount": len(frame_evaluate_response_order),
"resumedSessions": sorted(
session
for session in resumed_sessions
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index 15860cccf..e2bb78ff8 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -27,10 +27,13 @@ enum PendingRuntimeInspectorCommandDispatchKind {
Io(PendingDevToolsIoCommandDispatch),
}
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CompletedDevToolsIoCommandDispatch {
Dispatched,
- Canceled,
+ SessionResponse {
+ predecessor: RendererOutputFence,
+ response_succeeded: bool,
+ },
}
/// Identifies which execution owner consumed one routable Inspector command.
@@ -40,8 +43,16 @@ pub enum CompletedDevToolsIoCommandDispatch {
/// re-enter that Page before exposing the Inspector response.
pub enum CompletedRuntimeInspectorCommandDispatch {
Owner(Box<CompletedPageCommand>),
+ OwnerSessionResponse {
+ completion: Box<CompletedPageCommand>,
+ response_succeeded: bool,
+ },
+ OwnerSessionErrorSettled(RendererOutputFence),
Inspector,
- Canceled,
+ InspectorSessionResponse {
+ predecessor: RendererOutputFence,
+ response_succeeded: bool,
+ },
}
pub struct CompletedPageCommand {
@@ -416,11 +427,44 @@ impl PendingRuntimeInspectorCommandDispatch {
RendererRuntimeInspectorMainCommandCompletion::Inspector => {
Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
}
+ RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ predecessor,
+ response_succeeded,
+ } => Ok(
+ CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ predecessor,
+ response_succeeded,
+ },
+ ),
+ RendererRuntimeInspectorMainCommandCompletion::OwnerSessionResponse {
+ mut output,
+ response_succeeded,
+ } => {
+ if let Some(attachment_id) = renderer_agent_attachment_id {
+ output.bind_renderer_agent_attachment(attachment_id);
+ }
+ Ok(
+ CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ completion: Box::new(CompletedPageCommand {
+ output: *output,
+ renderer_agent_attachment_id,
+ }),
+ response_succeeded,
+ },
+ )
+ }
+ RendererRuntimeInspectorMainCommandCompletion::OwnerSessionErrorSettled(
+ predecessor,
+ ) => Ok(
+ CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ predecessor,
+ ),
+ ),
RendererRuntimeInspectorMainCommandCompletion::Page(_) => Err(anyhow::anyhow!(
"a Runtime Inspector command entered nested non-V8 Page dispatch"
)),
- RendererRuntimeInspectorMainCommandCompletion::Canceled => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)
+ RendererRuntimeInspectorMainCommandCompletion::Canceled(message) => {
+ Err(anyhow::anyhow!(message))
}
}
}
@@ -429,9 +473,15 @@ impl PendingRuntimeInspectorCommandDispatch {
CompletedDevToolsIoCommandDispatch::Dispatched => {
Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
}
- CompletedDevToolsIoCommandDispatch::Canceled => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)
- }
+ CompletedDevToolsIoCommandDispatch::SessionResponse {
+ predecessor,
+ response_succeeded,
+ } => Ok(
+ CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ predecessor,
+ response_succeeded,
+ },
+ ),
}
}
}
@@ -449,8 +499,15 @@ impl PendingDevToolsIoCommandDispatch {
RendererRuntimeInspectorIoCommandClaim::Dispatched => {
Ok(CompletedDevToolsIoCommandDispatch::Dispatched)
}
- RendererRuntimeInspectorIoCommandClaim::Canceled => {
- Ok(CompletedDevToolsIoCommandDispatch::Canceled)
+ RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ predecessor,
+ response_succeeded,
+ } => Ok(CompletedDevToolsIoCommandDispatch::SessionResponse {
+ predecessor,
+ response_succeeded,
+ }),
+ RendererRuntimeInspectorIoCommandClaim::Canceled(message) => {
+ Err(anyhow::anyhow!(message))
}
}
}
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index 7267ac648..c477598cf 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -1,5 +1,4 @@
use anyhow::{Result, anyhow};
-use moli_page_types::RendererInspectorResponseDelivery;
use serde_json::{Value, json};
use super::Page;
@@ -517,7 +516,6 @@ impl Page {
owner_context_resolution_action: Option<String>,
raw_json: String,
deferred_response: RendererRuntimeInspectorResponseSender,
- response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeInspectorCommandDispatch> {
match inspector_route {
RendererInspectorCommandRoute::MainThread => {
@@ -531,7 +529,6 @@ impl Page {
owner_context_resolution_action,
raw_json,
deferred_response,
- response_delivery,
),
);
Ok(Self::pending_main_ingress_runtime_inspector_command_dispatch(route))
@@ -551,7 +548,6 @@ impl Page {
),
raw_json,
Some(deferred_response),
- response_delivery,
),
);
Ok(Self::pending_io_runtime_inspector_command_dispatch(route))
@@ -573,7 +569,6 @@ impl Page {
),
raw_json,
None,
- RendererInspectorResponseDelivery::CommandReply,
),
);
Ok(Self::pending_io_runtime_inspector_command_dispatch(route))
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 48a9118a9..9bdbcbe13 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -346,6 +346,7 @@ impl CommandResponseFlushContext {
#[derive(Clone, Default)]
pub struct CommandDispatchContext {
response_flush: CommandResponseFlushContext,
+ terminal_response_delivery_override: Option<moli_page_types::RendererInspectorResponseDelivery>,
protocol_events: Vec<BackgroundProtocolEvent>,
post_renderer_output_events: Vec<BackgroundProtocolEvent>,
renderer_output_boundary: Option<moli_core::RendererOutputFence>,
@@ -357,6 +358,7 @@ impl CommandDispatchContext {
pub fn new(response_flush: CommandResponseFlushContext) -> Self {
Self {
response_flush,
+ terminal_response_delivery_override: None,
protocol_events: Vec::new(),
post_renderer_output_events: Vec::new(),
renderer_output_boundary: None,
@@ -369,6 +371,19 @@ impl CommandDispatchContext {
&self.response_flush
}
+ pub(crate) fn set_terminal_response_delivery_override(
+ &mut self,
+ response_delivery: moli_page_types::RendererInspectorResponseDelivery,
+ ) {
+ self.terminal_response_delivery_override = Some(response_delivery);
+ }
+
+ pub(crate) const fn terminal_response_delivery_override(
+ &self,
+ ) -> Option<moli_page_types::RendererInspectorResponseDelivery> {
+ self.terminal_response_delivery_override
+ }
+
pub(crate) fn push_protocol_event(&mut self, event: BackgroundProtocolEvent) {
self.protocol_events_mut().push(event);
}
diff --git a/moli-protocol/src/conn/command_view.rs b/moli-protocol/src/conn/command_view.rs
index 3082d6292..19ea8b1cd 100644
--- a/moli-protocol/src/conn/command_view.rs
+++ b/moli-protocol/src/conn/command_view.rs
@@ -1,5 +1,6 @@
use std::str::FromStr;
+use moli_page_types::RendererInspectorResponseDelivery;
use moli_protocol_cdp::{CdpRendererCommandPolicy, ParsedCdpCommand};
use serde::Deserialize;
use serde_json::{Map, Value};
@@ -30,6 +31,10 @@ pub struct Cmd<'a> {
/// command's policy. Domain dispatchers consume it through
/// [`Self::renderer_policy`].
renderer_policy: CdpRendererCommandPolicy,
+ /// Explicit terminal-response destination for a command synthesized by an
+ /// internal protocol adapter. Ordinary frontend commands use the domain's
+ /// Chromium-compatible default.
+ terminal_response_delivery_override: Option<RendererInspectorResponseDelivery>,
}
impl<'a> Cmd<'a> {
@@ -46,9 +51,18 @@ impl<'a> Cmd<'a> {
session_id: request.session_id(),
json: command.json(),
renderer_policy: command.renderer_policy(),
+ terminal_response_delivery_override: None,
})
}
+ pub(crate) fn with_terminal_response_delivery_override(
+ mut self,
+ response_delivery: Option<RendererInspectorResponseDelivery>,
+ ) -> Self {
+ self.terminal_response_delivery_override = response_delivery;
+ self
+ }
+
/// Build a low-level domain-test view while keeping method and renderer
/// policy inseparable.
///
@@ -84,6 +98,7 @@ impl<'a> Cmd<'a> {
session_id,
json,
renderer_policy: parsed.renderer_policy(),
+ terminal_response_delivery_override: None,
}
}
@@ -91,6 +106,13 @@ impl<'a> Cmd<'a> {
self.renderer_policy
}
+ pub(crate) fn terminal_response_delivery(
+ &self,
+ default: RendererInspectorResponseDelivery,
+ ) -> RendererInspectorResponseDelivery {
+ self.terminal_response_delivery_override.unwrap_or(default)
+ }
+
/// Build the protocol-neutral command context for shared DevTools command
/// dispatch. Existing domain handlers still own target/browser-context
/// resolution; those IDs can be filled by the caller once resolved.
diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rs
index 2a9d7ca49..fdb097aea 100644
--- a/moli-protocol/src/conn/dispatch.rs
+++ b/moli-protocol/src/conn/dispatch.rs
@@ -558,7 +558,10 @@ impl CdpConnection {
);
}
let cmd = Cmd::from_parsed(command)
- .expect("validated domain-qualified command must produce a command view");
+ .expect("validated domain-qualified command must produce a command view")
+ .with_terminal_response_delivery_override(
+ command_context.terminal_response_delivery_override(),
+ );
self.record_tracing_command(cmd.method, cmd.session_id);
let step = match domain {
"Browser" => Some(
@@ -1306,9 +1309,29 @@ impl CdpConnection {
pub async fn process_message_with_turn_outcome_async(
&mut self,
raw: &str,
+ ) -> CdpRendererOwnerTurnOutcome {
+ self.process_message_with_terminal_response_delivery_async(raw, None)
+ .await
+ }
+
+ pub(crate) async fn process_message_with_command_reply_turn_outcome_async(
+ &mut self,
+ raw: &str,
+ ) -> CdpRendererOwnerTurnOutcome {
+ self.process_message_with_terminal_response_delivery_async(
+ raw,
+ Some(moli_page_types::RendererInspectorResponseDelivery::CommandReply),
+ )
+ .await
+ }
+
+ async fn process_message_with_terminal_response_delivery_async(
+ &mut self,
+ raw: &str,
+ response_delivery_override: Option<moli_page_types::RendererInspectorResponseDelivery>,
) -> CdpRendererOwnerTurnOutcome {
let outcome = self
- .process_message_through_command_dispatch_async(raw)
+ .process_message_through_command_dispatch_async(raw, response_delivery_override)
.await;
let (
protocol_events,
@@ -1338,7 +1361,7 @@ impl CdpConnection {
#[cfg(test)]
pub async fn process_message_messages_only_for_test(&mut self, raw: &str) -> Vec<Value> {
let outcome = self
- .process_message_through_command_dispatch_async(raw)
+ .process_message_through_command_dispatch_async(raw, None)
.await;
outcome.into_parts().0
}
@@ -1346,6 +1369,7 @@ impl CdpConnection {
async fn process_message_through_command_dispatch_async(
&mut self,
raw: &str,
+ response_delivery_override: Option<moli_page_types::RendererInspectorResponseDelivery>,
) -> CdpRendererOwnerTurnOutcome {
let command = ParsedCdpCommand::parse_str(raw.to_owned());
let output_session_id = command
@@ -1359,6 +1383,9 @@ impl CdpConnection {
let mut scheduler_events = Vec::new();
let mut renderer_output_predecessor: Option<moli_core::RendererOutputFence> = None;
let mut command_context = CommandDispatchContext::default();
+ if let Some(response_delivery) = response_delivery_override {
+ command_context.set_terminal_response_delivery_override(response_delivery);
+ }
let mut step = match command.as_ref() {
Ok(command) => {
self.start_parsed_command_dispatch_with_context(command, &mut command_context)
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index e146844ce..fcc2e237f 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -10,7 +10,8 @@ use crate::devtools_runtime::{
DevToolsResultOwnership, DevToolsTargetId, RuntimeExecutionContextEvent, ScriptMessageEvent,
};
use moli_core::{
- RendererRuntimeCommandCausalIdentity, RendererRuntimeInspectorResponseSender,
+ RendererOutputFence, RendererRuntimeCommandCausalIdentity,
+ RendererRuntimeInspectorResponseSender,
page::{
DocumentNodeObjectSnapshot, DocumentNodeRuntimeObjectResolution,
MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH, RendererAgentAttachmentId, RendererCommandTurnOutput,
@@ -335,13 +336,71 @@ pub struct PendingRuntimeProtocolMessageDispatch {
session_id: Option<String>,
route: RuntimeProtocolMessagePageRoute,
pending: PendingRuntimeProtocolMessageDispatchKind,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
- // Main commands that fall back to the Page owner still complete through
- // the typed per-command reply capability.
- owner_response_delivery: RendererInspectorResponseDelivery,
- // A command claimed directly by the nested/IO Inspector receiver may use
- // the attachment-scoped DevTools session output capability instead.
- inspector_response_delivery: RendererInspectorResponseDelivery,
+ response_route: RuntimeProtocolResponseRoute,
+}
+
+enum RuntimeProtocolResponseRoute {
+ // The receiver is consumed before renderer completion is projected. It is
+ // absent for fire-and-forget commands and for replay, where the original
+ // dispatch still owns the command-reply waiter.
+ CommandReply(Option<RuntimeInspectorResponseReceiver>),
+ DevToolsSession,
+}
+
+impl RuntimeProtocolResponseRoute {
+ fn for_registered_delivery(
+ delivery: RendererInspectorResponseDelivery,
+ receiver: Option<RuntimeInspectorResponseReceiver>,
+ ) -> Self {
+ match delivery {
+ RendererInspectorResponseDelivery::CommandReply => Self::CommandReply(Some(
+ receiver.expect("a registered command-reply route must allocate its receiver"),
+ )),
+ RendererInspectorResponseDelivery::DevToolsSession => {
+ assert!(
+ receiver.is_none(),
+ "a DevTools session response cannot retain a command-reply receiver"
+ );
+ Self::DevToolsSession
+ }
+ }
+ }
+
+ const fn without_local_receiver_for_delivery(
+ delivery: RendererInspectorResponseDelivery,
+ ) -> Self {
+ match delivery {
+ RendererInspectorResponseDelivery::CommandReply => Self::CommandReply(None),
+ RendererInspectorResponseDelivery::DevToolsSession => Self::DevToolsSession,
+ }
+ }
+
+ const fn command_reply_without_receiver() -> Self {
+ Self::CommandReply(None)
+ }
+
+ const fn delivery(&self) -> RendererInspectorResponseDelivery {
+ match self {
+ Self::CommandReply(_) => RendererInspectorResponseDelivery::CommandReply,
+ Self::DevToolsSession => RendererInspectorResponseDelivery::DevToolsSession,
+ }
+ }
+
+ fn take_command_reply_receiver(&mut self) -> Option<RuntimeInspectorResponseReceiver> {
+ match self {
+ Self::CommandReply(receiver) => receiver.take(),
+ Self::DevToolsSession => None,
+ }
+ }
+
+ fn into_command_reply_receiver(self) -> Option<RuntimeInspectorResponseReceiver> {
+ match self {
+ Self::CommandReply(receiver) => receiver,
+ Self::DevToolsSession => {
+ panic!("a DevTools session response cannot become a command reply")
+ }
+ }
+ }
}
enum PendingRuntimeProtocolMessageDispatchKind {
@@ -392,8 +451,7 @@ pub struct CompletedRuntimeProtocolMessageDispatch {
session_id: Option<String>,
route: RuntimeProtocolMessagePageRoute,
completion: moli_core::page::CompletedRuntimeInspectorCommandDispatch,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
- response_delivery: RendererInspectorResponseDelivery,
+ response_route: RuntimeProtocolResponseRoute,
}
pub struct CompletedSharedWorkerRuntimeProtocolMessageDispatch {
@@ -542,20 +600,11 @@ impl PendingRuntimeProtocolMessageDispatch {
.await
.map_err(|error| format!("runtime inspector dispatch failed: {error}"))?,
};
- let response_delivery = if matches!(
- completion,
- moli_core::page::CompletedRuntimeInspectorCommandDispatch::Inspector
- ) {
- self.inspector_response_delivery
- } else {
- self.owner_response_delivery
- };
Ok(CompletedRuntimeProtocolMessageDispatch {
session_id: self.session_id,
route: self.route,
completion,
- deferred_response_rx: self.deferred_response_rx,
- response_delivery,
+ response_route: self.response_route,
})
}
}
@@ -589,17 +638,59 @@ impl CompletedRuntimeProtocolMessageDispatch {
matches!(
self.completion,
moli_core::page::CompletedRuntimeInspectorCommandDispatch::Owner(_)
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ ..
+ }
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ _
+ )
)
}
+ pub(crate) fn session_response_succeeded(&self) -> Option<bool> {
+ match &self.completion {
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ response_succeeded,
+ ..
+ }
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ response_succeeded,
+ ..
+ } => Some(*response_succeeded),
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ _,
+ ) => Some(false),
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::Owner(_)
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::Inspector => None,
+ }
+ }
+
+ pub(crate) fn session_response_predecessor(&self) -> Option<RendererOutputFence> {
+ match &self.completion {
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ completion,
+ ..
+ } => completion.renderer_output_predecessor(),
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ predecessor,
+ ) => Some(predecessor.clone()),
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ predecessor,
+ ..
+ } => Some(predecessor.clone()),
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::Owner(_)
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::Inspector => None,
+ }
+ }
+
pub(crate) fn take_deferred_response_receiver(
&mut self,
) -> Option<RuntimeInspectorResponseReceiver> {
- self.deferred_response_rx.take()
+ self.response_route.take_command_reply_receiver()
}
pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {
- self.response_delivery
+ self.response_route.delivery()
}
}
@@ -834,7 +925,7 @@ impl CdpConnection {
.map_err(|error| error.to_string())
}
- fn take_renderer_call_for_frontend_for_session_owner(
+ pub(crate) fn take_renderer_call_for_frontend_for_session_owner(
&mut self,
session_id: Option<&str>,
cdp_request_id: u64,
@@ -994,8 +1085,7 @@ impl CdpConnection {
RendererCommandCorrelation,
String,
RendererRuntimeInspectorResponseSender,
- RuntimeInspectorResponseReceiver,
- RendererInspectorResponseDelivery,
+ RuntimeProtocolResponseRoute,
),
String,
> {
@@ -1022,8 +1112,10 @@ impl CdpConnection {
correlation,
raw_json,
response_sender,
- response_receiver,
- response_delivery,
+ RuntimeProtocolResponseRoute::for_registered_delivery(
+ response_delivery,
+ response_receiver,
+ ),
))
}
Err(error) => {
@@ -3021,18 +3113,17 @@ impl CdpConnection {
let Some(renderer_call_id) = message.renderer_call_id() else {
return true;
};
- let result_object_group = self
+ let descriptor = self
.renderer_command_descriptor_for_renderer_if_attachment_matches_for_session_owner(
session_id,
renderer_call_id,
dispatched_attachment_id,
+ );
+ let result_object_group = descriptor.as_ref().and_then(|descriptor| {
+ self.runtime_result_object_group_for_renderer_command_descriptor(
+ session_id, descriptor,
)
- .and_then(|descriptor| {
- self.runtime_result_object_group_for_renderer_command_descriptor(
- session_id,
- &descriptor,
- )
- });
+ });
let Some(correlation) = self
.take_frontend_command_for_renderer_if_attachment_matches_for_session_owner(
session_id,
@@ -3076,7 +3167,7 @@ impl CdpConnection {
let method = command.get("method")?.as_str()?;
let params = command.get("params")?.as_object()?;
match method {
- "Runtime.evaluate" => params
+ "Runtime.evaluate" | "Runtime.runScript" => params
.get("objectGroup")
.and_then(Value::as_str)
.map(str::to_owned),
@@ -3090,6 +3181,24 @@ impl CdpConnection {
params.get("objectId")?.as_str()?,
)
}),
+ "Runtime.getProperties" => self.runtime_remote_object_group_for_session_owner(
+ session_id,
+ params.get("objectId")?.as_str()?,
+ ),
+ "Runtime.awaitPromise" => self.runtime_remote_object_group_for_session_owner(
+ session_id,
+ params.get("promiseObjectId")?.as_str()?,
+ ),
+ "Runtime.queryObjects" => params
+ .get("objectGroup")
+ .and_then(Value::as_str)
+ .map(str::to_owned)
+ .or_else(|| {
+ self.runtime_remote_object_group_for_session_owner(
+ session_id,
+ params.get("prototypeObjectId")?.as_str()?,
+ )
+ }),
_ => None,
}
}
@@ -3900,13 +4009,16 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
self.shared_worker_runtime_target_for_session(session_id)?;
- let (correlation, raw_json, response_sender, response_receiver, response_delivery) =
+ let (correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
debug_assert_eq!(
- response_delivery,
+ response_route.delivery(),
RendererInspectorResponseDelivery::CommandReply,
"worker responses have not migrated to the page DevTools session output"
);
+ let response_receiver = response_route
+ .into_command_reply_receiver()
+ .expect("CommandReply worker dispatch must allocate a response receiver");
let result = self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
@@ -4053,13 +4165,16 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
self.service_worker_runtime_target_for_session(session_id)?;
- let (correlation, raw_json, response_sender, response_receiver, response_delivery) =
+ let (correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
debug_assert_eq!(
- response_delivery,
+ response_route.delivery(),
RendererInspectorResponseDelivery::CommandReply,
"worker responses have not migrated to the page DevTools session output"
);
+ let response_receiver = response_route
+ .into_command_reply_receiver()
+ .expect("CommandReply worker dispatch must allocate a response receiver");
let result = self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
@@ -4455,9 +4570,7 @@ impl CdpConnection {
session_id: session_id.map(str::to_owned),
route,
pending,
- deferred_response_rx: None,
- owner_response_delivery: RendererInspectorResponseDelivery::CommandReply,
- inspector_response_delivery: RendererInspectorResponseDelivery::CommandReply,
+ response_route: RuntimeProtocolResponseRoute::command_reply_without_receiver(),
})
}
@@ -4497,13 +4610,13 @@ impl CdpConnection {
inspector_route: RendererInspectorCommandRoute,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;
- let (correlation, raw_json, response_sender, response_receiver, response_delivery) = self
+ let (correlation, raw_json, response_sender, response_route) = self
.prepare_renderer_call_for_session_owner(
- session_id,
- descriptor,
- command_id,
- Some(route.renderer_agent_attachment_id),
- )?;
+ session_id,
+ descriptor,
+ command_id,
+ Some(route.renderer_agent_attachment_id),
+ )?;
let inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_session(session_id);
let page_result = match inspector_route {
@@ -4529,7 +4642,6 @@ impl CdpConnection {
None,
raw_json,
response_sender,
- response_delivery,
) {
Ok(pending) => pending,
Err(error) => {
@@ -4543,9 +4655,7 @@ impl CdpConnection {
session_id: session_id.map(str::to_owned),
route,
pending: PendingRuntimeProtocolMessageDispatchKind::Routable(pending),
- deferred_response_rx: Some(response_receiver),
- owner_response_delivery: response_delivery,
- inspector_response_delivery: response_delivery,
+ response_route,
})
}
@@ -4572,9 +4682,7 @@ impl CdpConnection {
session_id: session_id.map(str::to_owned),
route,
pending: PendingRuntimeProtocolMessageDispatchKind::Page(pending),
- deferred_response_rx: None,
- owner_response_delivery: RendererInspectorResponseDelivery::CommandReply,
- inspector_response_delivery: RendererInspectorResponseDelivery::CommandReply,
+ response_route: RuntimeProtocolResponseRoute::command_reply_without_receiver(),
})
}
@@ -4584,33 +4692,15 @@ impl CdpConnection {
action: &str,
descriptor: RendererCommandDescriptor,
command_id: u64,
- ) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
- let inspector_response_delivery = descriptor.response_delivery();
- self.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response_and_nested_delivery(
- session_id,
- action,
- descriptor,
- command_id,
- inspector_response_delivery,
- )
- }
-
- pub(crate) fn start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response_and_nested_delivery(
- &mut self,
- session_id: Option<&str>,
- action: &str,
- descriptor: RendererCommandDescriptor,
- command_id: u64,
- inspector_response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;
- let (correlation, raw_json, response_sender, response_receiver, response_delivery) = self
+ let (correlation, raw_json, response_sender, response_route) = self
.prepare_renderer_call_for_session_owner(
- session_id,
- descriptor,
- command_id,
- Some(route.renderer_agent_attachment_id),
- )?;
+ session_id,
+ descriptor,
+ command_id,
+ Some(route.renderer_agent_attachment_id),
+ )?;
let inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_session(session_id);
let page = match self.runtime_session_owner_page_mut(session_id) {
@@ -4628,7 +4718,6 @@ impl CdpConnection {
Some(action.to_owned()),
raw_json,
response_sender,
- inspector_response_delivery,
) {
Ok(pending) => pending,
Err(error) => {
@@ -4642,9 +4731,7 @@ impl CdpConnection {
session_id: session_id.map(str::to_owned),
route,
pending: PendingRuntimeProtocolMessageDispatchKind::Routable(pending),
- deferred_response_rx: Some(response_receiver),
- owner_response_delivery: response_delivery,
- inspector_response_delivery,
+ response_route,
})
}
@@ -4657,8 +4744,17 @@ impl CdpConnection {
moli_core::page::CompletedRuntimeInspectorCommandDispatch::Owner(completion) => {
*completion
}
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ completion,
+ ..
+ } => *completion,
moli_core::page::CompletedRuntimeInspectorCommandDispatch::Inspector
- | moli_core::page::CompletedRuntimeInspectorCommandDispatch::Canceled => {
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ ..
+ }
+ | moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ _,
+ ) => {
return Ok(None);
}
};
@@ -4788,17 +4884,12 @@ impl CdpConnection {
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",
- );
- }
+ Ok(
+ moli_core::page::CompletedDevToolsIoCommandDispatch::SessionResponse {
+ ..
+ },
+ )
+ | Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}
Err(error) => {
self.settle_renderer_replay_error(
&mut events,
@@ -4833,17 +4924,12 @@ impl CdpConnection {
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",
- );
- }
+ Ok(
+ moli_core::page::CompletedDevToolsIoCommandDispatch::SessionResponse {
+ ..
+ },
+ )
+ | Ok(moli_core::page::CompletedDevToolsIoCommandDispatch::Dispatched) => {}
Err(error) => {
self.settle_renderer_replay_error(
&mut events,
@@ -4926,7 +5012,6 @@ impl CdpConnection {
None,
raw_json,
dispatch_sender,
- response_delivery,
)
.map(PendingRuntimeProtocolMessageDispatchKind::Routable)
}
@@ -4937,9 +5022,10 @@ impl CdpConnection {
session_id: frontend_session_id.clone(),
route,
pending,
- deferred_response_rx: None,
- owner_response_delivery: response_delivery,
- inspector_response_delivery: response_delivery,
+ response_route:
+ RuntimeProtocolResponseRoute::without_local_receiver_for_delivery(
+ response_delivery,
+ ),
},
Err(error) => {
self.settle_renderer_replay_error(
@@ -4974,17 +5060,20 @@ impl CdpConnection {
moli_core::page::CompletedRuntimeInspectorCommandDispatch::Inspector => {
continue;
}
- moli_core::page::CompletedRuntimeInspectorCommandDispatch::Canceled => {
- self.settle_renderer_replay_error(
- &mut events,
- frontend_session_id.as_deref(),
- response_delivery,
- &response_sender,
- correlation,
- "Inspected target navigated or closed",
- );
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::InspectorSessionResponse {
+ ..
+ } => {
+ continue;
+ }
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionErrorSettled(
+ _,
+ ) => {
continue;
}
+ moli_core::page::CompletedRuntimeInspectorCommandDispatch::OwnerSessionResponse {
+ completion,
+ ..
+ } => *completion,
};
let mut command_turn_output = match self
.consume_runtime_protocol_message_completion(&completed.route, completion)
@@ -6050,6 +6139,77 @@ mod tests {
use crate::testing::TestContext;
use moli_core::page::{MAX_INSPECTOR_PROTOCOL_VALUE_DEPTH, is_renderer_backend_node_id};
+ #[test]
+ fn registered_command_reply_route_owns_exactly_one_receiver() {
+ let (_response_tx, response_rx) = tokio::sync::oneshot::channel();
+ let mut route = RuntimeProtocolResponseRoute::for_registered_delivery(
+ RendererInspectorResponseDelivery::CommandReply,
+ Some(response_rx),
+ );
+
+ assert_eq!(
+ route.delivery(),
+ RendererInspectorResponseDelivery::CommandReply
+ );
+ assert!(route.take_command_reply_receiver().is_some());
+ assert!(route.take_command_reply_receiver().is_none());
+ }
+
+ #[test]
+ #[should_panic(expected = "registered command-reply route must allocate its receiver")]
+ fn registered_command_reply_route_rejects_a_missing_receiver() {
+ let _ = RuntimeProtocolResponseRoute::for_registered_delivery(
+ RendererInspectorResponseDelivery::CommandReply,
+ None,
+ );
+ }
+
+ #[test]
+ fn registered_devtools_session_route_has_no_command_reply_receiver() {
+ let mut route = RuntimeProtocolResponseRoute::for_registered_delivery(
+ RendererInspectorResponseDelivery::DevToolsSession,
+ None,
+ );
+
+ assert_eq!(
+ route.delivery(),
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+ assert!(route.take_command_reply_receiver().is_none());
+ }
+
+ #[test]
+ #[should_panic(expected = "DevTools session response cannot retain a command-reply receiver")]
+ fn devtools_session_route_rejects_command_reply_receiver() {
+ let (_response_tx, response_rx) = tokio::sync::oneshot::channel();
+ let _ = RuntimeProtocolResponseRoute::for_registered_delivery(
+ RendererInspectorResponseDelivery::DevToolsSession,
+ Some(response_rx),
+ );
+ }
+
+ #[test]
+ fn replay_response_routes_never_claim_a_second_local_receiver() {
+ let mut command_reply = RuntimeProtocolResponseRoute::without_local_receiver_for_delivery(
+ RendererInspectorResponseDelivery::CommandReply,
+ );
+ let mut devtools_session =
+ RuntimeProtocolResponseRoute::without_local_receiver_for_delivery(
+ RendererInspectorResponseDelivery::DevToolsSession,
+ );
+
+ assert_eq!(
+ command_reply.delivery(),
+ RendererInspectorResponseDelivery::CommandReply
+ );
+ assert_eq!(
+ devtools_session.delivery(),
+ RendererInspectorResponseDelivery::DevToolsSession
+ );
+ assert!(command_reply.take_command_reply_receiver().is_none());
+ assert!(devtools_session.take_command_reply_receiver().is_none());
+ }
+
#[test]
fn runtime_inspector_command_rewrites_large_frontend_id_to_renderer_call_id() {
let frontend_command_id = FrontendCommandId::new(i32::MAX as u64 + 73);
@@ -6224,6 +6384,195 @@ mod tests {
.unwrap()
}
+ fn register_devtools_session_response_for_test(
+ conn: &mut CdpConnection,
+ session_id: &str,
+ frontend_command_id: u64,
+ attachment_id: RendererAgentAttachmentId,
+ frontend_payload: &str,
+ ) -> RendererCommandCorrelation {
+ let frontend =
+ ParsedCdpCommand::parse_str(frontend_payload).expect("frontend command should parse");
+ let prepared = conn
+ .try_register_renderer_call_for_session_owner(
+ Some(session_id),
+ frontend_command_id,
+ Some(attachment_id),
+ RendererCommandDescriptor::from_frontend_policy(
+ frontend.json().to_owned(),
+ frontend.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ ),
+ )
+ .expect("frontend response correlation should register");
+ let (correlation, response_sender, response_receiver) = prepared.into_parts();
+ assert!(
+ response_receiver.is_none(),
+ "DevToolsSession delivery must not allocate a command-reply receiver"
+ );
+ drop(response_sender);
+ correlation
+ }
+
+ #[test]
+ fn devtools_session_output_wrong_attachment_does_not_consume_live_correlation() {
+ let mut conn = CdpConnection::default();
+ let mut browser_context = BrowserContext::new("BID-attachment-race".to_owned());
+ browser_context.set_active_target_id("TID-attachment-race".to_owned());
+ browser_context.attach_active_session("SID-attachment-race".to_owned());
+ conn.browser_context = Some(browser_context);
+
+ let live_attachment = RendererAgentAttachmentId::allocate();
+ let stale_attachment = RendererAgentAttachmentId::allocate();
+ let correlation = register_devtools_session_response_for_test(
+ &mut conn,
+ "SID-attachment-race",
+ 70,
+ live_attachment,
+ r#"{"id":70,"method":"Runtime.evaluate","params":{"expression":"70"}}"#,
+ );
+ let response = || {
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "id": correlation.renderer_call_id().get(),
+ "result": { "result": { "type": "number", "value": 70 } },
+ }))
+ };
+
+ let mut stale_messages = vec![response()];
+ conn.restore_frontend_command_ids_in_devtools_session_output(
+ Some("SID-attachment-race"),
+ stale_attachment,
+ &mut stale_messages,
+ );
+ assert!(
+ stale_messages.is_empty(),
+ "a response from the retired attachment must be dropped"
+ );
+ assert!(
+ conn.renderer_runtime_command_cause_for_frontend(Some("SID-attachment-race"), 70,)
+ .is_some(),
+ "the retired attachment must not consume the live correlation"
+ );
+
+ let mut live_messages = vec![response()];
+ conn.restore_frontend_command_ids_in_devtools_session_output(
+ Some("SID-attachment-race"),
+ live_attachment,
+ &mut live_messages,
+ );
+ let [RendererRuntimeInspectorMessage::Protocol(message)] = live_messages.as_slice() else {
+ panic!("the live attachment must publish exactly one response");
+ };
+ assert_eq!(message.value()["id"], json!(70));
+ assert!(
+ conn.renderer_runtime_command_cause_for_frontend(Some("SID-attachment-race"), 70,)
+ .is_none(),
+ "the live attachment must consume the correlation exactly once"
+ );
+ }
+
+ #[test]
+ fn devtools_session_output_keeps_first_of_duplicate_terminal_responses() {
+ let mut conn = CdpConnection::default();
+ let mut browser_context = BrowserContext::new("BID-duplicate-response".to_owned());
+ browser_context.set_active_target_id("TID-duplicate-response".to_owned());
+ browser_context.attach_active_session("SID-duplicate-response".to_owned());
+ conn.browser_context = Some(browser_context);
+
+ let attachment_id = RendererAgentAttachmentId::allocate();
+ let correlation = register_devtools_session_response_for_test(
+ &mut conn,
+ "SID-duplicate-response",
+ 71,
+ attachment_id,
+ r#"{"id":71,"method":"Runtime.evaluate","params":{"expression":"71"}}"#,
+ );
+ let mut messages = vec![
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "id": correlation.renderer_call_id().get(),
+ "result": { "result": { "type": "string", "value": "first" } },
+ })),
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "id": correlation.renderer_call_id().get(),
+ "result": { "result": { "type": "string", "value": "duplicate" } },
+ })),
+ ];
+
+ conn.restore_frontend_command_ids_in_devtools_session_output(
+ Some("SID-duplicate-response"),
+ attachment_id,
+ &mut messages,
+ );
+
+ let [RendererRuntimeInspectorMessage::Protocol(message)] = messages.as_slice() else {
+ panic!("duplicate terminal responses must collapse to one frontend response");
+ };
+ assert_eq!(message.value()["id"], json!(71));
+ assert_eq!(message.value()["result"]["result"]["value"], json!("first"));
+ }
+
+ #[test]
+ fn devtools_session_output_restores_interleaved_calls_without_reordering() {
+ let mut conn = CdpConnection::default();
+ let mut browser_context = BrowserContext::new("BID-interleaved-response".to_owned());
+ browser_context.set_active_target_id("TID-interleaved-response".to_owned());
+ browser_context.attach_active_session("SID-interleaved-response".to_owned());
+ conn.browser_context = Some(browser_context);
+
+ let attachment_id = RendererAgentAttachmentId::allocate();
+ let first = register_devtools_session_response_for_test(
+ &mut conn,
+ "SID-interleaved-response",
+ 80,
+ attachment_id,
+ r#"{"id":80,"method":"Runtime.evaluate","params":{"expression":"80"}}"#,
+ );
+ let second = register_devtools_session_response_for_test(
+ &mut conn,
+ "SID-interleaved-response",
+ 81,
+ attachment_id,
+ r#"{"id":81,"method":"Runtime.evaluate","params":{"expression":"81"}}"#,
+ );
+ let mut messages = vec![
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "id": second.renderer_call_id().get(),
+ "result": { "result": { "type": "number", "value": 81 } },
+ })),
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "method": "Debugger.scriptParsed",
+ "params": { "scriptId": "interleaved" },
+ })),
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "id": first.renderer_call_id().get(),
+ "result": { "result": { "type": "number", "value": 80 } },
+ })),
+ ];
+
+ conn.restore_frontend_command_ids_in_devtools_session_output(
+ Some("SID-interleaved-response"),
+ attachment_id,
+ &mut messages,
+ );
+
+ assert_eq!(messages.len(), 3);
+ let RendererRuntimeInspectorMessage::Protocol(second_response) = &messages[0] else {
+ panic!("the second call response must remain first");
+ };
+ let RendererRuntimeInspectorMessage::Protocol(notification) = &messages[1] else {
+ panic!("the notification must remain between the responses");
+ };
+ let RendererRuntimeInspectorMessage::Protocol(first_response) = &messages[2] else {
+ panic!("the first call response must remain last");
+ };
+ assert_eq!(second_response.value()["id"], json!(81));
+ assert_eq!(
+ notification.value()["method"],
+ json!("Debugger.scriptParsed")
+ );
+ assert_eq!(first_response.value()["id"], json!(80));
+ }
+
#[tokio::test]
async fn devtools_session_output_restores_only_the_exact_registered_frontend_response() {
let mut conn = CdpConnection::default();
@@ -6250,6 +6599,10 @@ mod tests {
)
.expect("frontend response correlation should register");
let (correlation, response_sender, response_receiver) = prepared.into_parts();
+ assert!(
+ response_receiver.is_none(),
+ "DevToolsSession delivery must not allocate a legacy command-reply receiver"
+ );
drop(response_sender);
let mut messages = vec![
RendererRuntimeInspectorMessage::protocol(json!({
@@ -6299,9 +6652,64 @@ mod tests {
.is_none(),
"publishing the session response must consume its exact correlation"
);
- assert!(
- response_receiver.await.is_err(),
- "the legacy reply receiver should close after session output takes ownership"
+ }
+
+ #[test]
+ fn devtools_session_output_preserves_remote_object_group_projection() {
+ let mut conn = CdpConnection::default();
+ let mut browser_context = BrowserContext::new("BID-session-projection".to_owned());
+ browser_context.set_active_target_id("TID-session-projection".to_owned());
+ browser_context.attach_active_session("SID-session-projection".to_owned());
+ conn.browser_context = Some(browser_context);
+ let session_id = Some("SID-session-projection");
+ let attachment_id = RendererAgentAttachmentId::allocate();
+
+ conn.register_runtime_remote_object_ids_from_value_for_session_owner_with_group(
+ session_id,
+ &json!({ "objectId": "nested-parent-object" }),
+ "nested-object-group",
+ );
+
+ let get_properties = ParsedCdpCommand::parse_str(
+ r#"{"id":45,"method":"Runtime.getProperties","params":{"objectId":"nested-parent-object","ownProperties":true}}"#,
+ )
+ .expect("getProperties command should parse");
+ let prepared = conn
+ .try_register_renderer_call_for_session_owner(
+ session_id,
+ 45,
+ Some(attachment_id),
+ RendererCommandDescriptor::from_frontend_policy(
+ get_properties.json().to_owned(),
+ get_properties.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ ),
+ )
+ .expect("getProperties response correlation should register");
+ let (correlation, response_sender, response_receiver) = prepared.into_parts();
+ assert!(response_receiver.is_none());
+ drop(response_sender);
+ let mut messages = vec![RendererRuntimeInspectorMessage::protocol(json!({
+ "id": correlation.renderer_call_id().get(),
+ "result": {
+ "result": [{
+ "name": "child",
+ "value": {
+ "type": "object",
+ "objectId": "nested-child-object"
+ }
+ }]
+ },
+ }))];
+ conn.restore_frontend_command_ids_in_devtools_session_output(
+ session_id,
+ attachment_id,
+ &mut messages,
+ );
+ assert_eq!(
+ conn.runtime_remote_object_group_for_session_owner(session_id, "nested-child-object",),
+ Some("nested-object-group".to_owned()),
+ "getProperties results must inherit the receiver object's group",
);
}
@@ -7032,6 +7440,8 @@ mod tests {
)
.expect("non-await command should register");
let (correlation, old_sender, response_receiver) = prepared.into_parts();
+ let response_receiver = response_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
let mut direct_events = Vec::new();
let mut claimed_events = Vec::new();
diff --git a/moli-protocol/src/conn/state/pending_renderer_command.rs b/moli-protocol/src/conn/state/pending_renderer_command.rs
index de7f15f34..b060af3d8 100644
--- a/moli-protocol/src/conn/state/pending_renderer_command.rs
+++ b/moli-protocol/src/conn/state/pending_renderer_command.rs
@@ -53,11 +53,12 @@ impl RendererCommandDescriptor {
pub(crate) fn performance_get_metrics(
frontend_payload: String,
policy: CdpRendererCommandPolicy,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Self {
Self {
replacement: policy.replacement(),
replay: RendererCommandReplay::PerformanceGetMetrics,
- response_delivery: RendererInspectorResponseDelivery::DevToolsSession,
+ response_delivery,
frontend_payload,
}
}
@@ -66,11 +67,12 @@ impl RendererCommandDescriptor {
frontend_payload: String,
policy: CdpRendererCommandPolicy,
disabled: bool,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Self {
Self {
replacement: policy.replacement(),
replay: RendererCommandReplay::SetScriptExecutionDisabled { disabled },
- response_delivery: RendererInspectorResponseDelivery::DevToolsSession,
+ response_delivery,
frontend_payload,
}
}
@@ -200,7 +202,8 @@ impl RendererCommandCorrelation {
pub(crate) struct PreparedRendererCallDispatch {
correlation: RendererCommandCorrelation,
response_sender: RendererRuntimeInspectorResponseSender,
- response_receiver: tokio::sync::oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>,
+ response_receiver:
+ Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>>,
}
impl PreparedRendererCallDispatch {
@@ -213,7 +216,7 @@ impl PreparedRendererCallDispatch {
) -> (
RendererCommandCorrelation,
RendererRuntimeInspectorResponseSender,
- tokio::sync::oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>,
+ Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>>,
) {
(
self.correlation,
@@ -351,7 +354,9 @@ impl<T> PendingRendererCommandRegistry<T> {
let renderer_call_id = self
.allocate_renderer_call_id()
.map_err(RegisterRendererCallError::Exhausted)?;
- let (response_channel, response_receiver) = RendererRuntimeInspectorResponseChannel::new();
+ let response_delivery = descriptor.response_delivery();
+ let (response_channel, response_receiver) =
+ RendererRuntimeInspectorResponseChannel::new_for_delivery(response_delivery);
let response_sender =
response_channel.activate_sender(renderer_call_id.get(), dispatched_attachment_id);
let previous_renderer_call = self.renderer_calls_by_frontend.insert(
@@ -945,6 +950,7 @@ mod tests {
let performance_descriptor = RendererCommandDescriptor::performance_get_metrics(
performance.json().to_owned(),
performance.renderer_policy(),
+ RendererInspectorResponseDelivery::DevToolsSession,
);
assert_eq!(
performance_descriptor.replay(),
@@ -963,6 +969,7 @@ mod tests {
emulation.json().to_owned(),
emulation.renderer_policy(),
true,
+ RendererInspectorResponseDelivery::DevToolsSession,
);
assert_eq!(
emulation_descriptor.replay(),
@@ -975,7 +982,7 @@ mod tests {
}
#[tokio::test]
- async fn replay_rotates_renderer_id_attachment_and_response_lease() {
+ async fn session_replay_rotates_renderer_id_and_lease_without_command_reply_receiver() {
let frontend_id = FrontendCommandId::new(41);
let old_attachment = RendererAgentAttachmentId::allocate();
let new_attachment = RendererAgentAttachmentId::allocate();
@@ -1001,6 +1008,10 @@ mod tests {
)
.unwrap();
let (old_correlation, old_sender, response_receiver) = prepared.into_parts();
+ assert!(
+ response_receiver.is_none(),
+ "DevToolsSession delivery must not allocate a command-reply receiver"
+ );
let mut replays = registry
.prepare_replays_from_attachment(old_attachment, new_attachment)
@@ -1035,15 +1046,16 @@ mod tests {
.is_err(),
"rotating the registry lease must invalidate the old sender"
);
- replay
- .into_response_sender()
- .send(serde_json::json!({
- "id": new_correlation.renderer_call_id().get(),
- "result": { "current": true },
- }))
- .unwrap();
- let completion = response_receiver.await.unwrap();
- assert_eq!(completion.call_id, new_correlation.renderer_call_id().get());
+ assert!(
+ replay
+ .into_response_sender()
+ .send(serde_json::json!({
+ "id": new_correlation.renderer_call_id().get(),
+ "result": { "current": true },
+ }))
+ .is_err(),
+ "a session response cannot publish until its concrete output host is bound"
+ );
assert_eq!(
registry.take_frontend_command_for_renderer_if_attachment_matches(
old_correlation.renderer_call_id(),
@@ -1074,6 +1086,8 @@ mod tests {
)
.unwrap();
let (correlation, sender, response_receiver) = prepared.into_parts();
+ let response_receiver = response_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
sender
.send(serde_json::json!({
"id": correlation.renderer_call_id().get(),
@@ -1117,6 +1131,8 @@ mod tests {
)
.unwrap();
let (old_correlation, old_sender, response_receiver) = prepared.into_parts();
+ let response_receiver = response_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
let mut terminations = registry
.prepare_terminations_from_attachment(old_attachment, new_attachment)
@@ -1204,6 +1220,10 @@ mod tests {
.unwrap();
let (_, first_sender, first_receiver) = first.into_parts();
let (_, second_sender, second_receiver) = second.into_parts();
+ let first_receiver = first_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
+ let second_receiver = second_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
let terminated = registry.terminate_all_renderer_calls("Inspector detached");
diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rs
index d60ac5c03..3ddf620df 100644
--- a/moli-protocol/src/conn/tests/resource_runtime.rs
+++ b/moli-protocol/src/conn/tests/resource_runtime.rs
@@ -1892,23 +1892,12 @@ async fn direct_runtime_evaluate_self_popup_does_not_navigate_active_target_for_
active.set_target_url("https://active.example/current".to_owned());
ctx.conn.browser_context = Some(active);
- let mut page = ctx
- .conn
- .load_page_via_runtime_async("data:text/html,<!doctype html><title>self-popup</title>")
- .await
- .expect("background page should load");
- let _ = page
- .dispatch_runtime_protocol_message_async(
- &json!({"id": 9007, "method": "Runtime.enable", "params": {}}).to_string(),
- )
- .await
- .expect("Runtime.enable should create the owner inspector context");
- let mut background = BackgroundTarget::with_url(
+ let page_url = "data:text/html,<!doctype html><title>self-popup</title>";
+ let background = BackgroundTarget::with_url(
"TID-self-popup-background".to_owned(),
Some("SID-self-popup-background".to_owned()),
- page.final_url().as_str().to_owned(),
+ page_url.to_owned(),
);
- background.replace_loaded_page(Some(page));
let mut inactive = BrowserContext::new("BID-self-popup-background".into());
inactive.background_targets.push(background);
@@ -1919,6 +1908,8 @@ async fn direct_runtime_evaluate_self_popup_does_not_navigate_active_target_for_
.runtime_frontend_enabled = true;
});
ctx.conn.inactive_browser_contexts.push(inactive);
+ ctx.install_navigation_fixture_for_session_owner(page_url, Some("SID-self-popup-background"))
+ .await;
ctx.sent.clear();
ctx.process_async(json!({
diff --git a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
index 74f0b9841..e14f98fef 100644
--- a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
+++ b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
@@ -66,7 +66,7 @@ impl PreparedProtocolOutputs {
Some(prepared)
}
- pub(in crate::domains::activity) fn from_renderer_observation(
+ pub(in crate::domains::activity) async fn from_renderer_observation(
conn: &mut CdpConnection,
session_id: Option<&str>,
source_renderer_agent: moli_core::page::RendererDevToolsAgentToken,
@@ -111,10 +111,45 @@ impl PreparedProtocolOutputs {
.append_to_output_sink(&mut prepared);
}
RendererProtocolObservation::RuntimeInspector(batch) => {
- let batches = conn.route_current_renderer_inspector_output_for_session_owner(
+ let mut batches = conn.route_current_renderer_inspector_output_for_session_owner(
session_id,
vec![batch.clone()],
);
+ for batch in &mut batches {
+ let Some(attachment) = conn
+ .target_page_protocol_attachment_identity_for_renderer_inspector_route(
+ session_id,
+ batch.session.wire_session_id(),
+ )
+ else {
+ continue;
+ };
+ let output_session_id = attachment.session_id().map(str::to_owned);
+ let normalize_node_objects = !conn
+ .runtime_inspector_pause_active_for_session_owner(
+ output_session_id.as_deref(),
+ );
+ for message in &mut batch.messages {
+ let moli_core::page::RendererRuntimeInspectorMessage::Protocol(message) =
+ message
+ else {
+ continue;
+ };
+ let mut value = message.value_mut();
+ conn.normalize_runtime_event_context_ids_for_session_owner_async(
+ output_session_id.as_deref(),
+ &mut value,
+ )
+ .await;
+ if normalize_node_objects {
+ conn.normalize_node_remote_objects_for_session_owner_async(
+ output_session_id.as_deref(),
+ &mut value,
+ )
+ .await;
+ }
+ }
+ }
crate::domains::runtime::RuntimePreparedOutputs::
from_renderer_runtime_inspector_message_batches(
conn,
diff --git a/moli-protocol/src/domains/activity/output_ingress/renderer.rs b/moli-protocol/src/domains/activity/output_ingress/renderer.rs
index ea9f03b54..6516fd932 100644
--- a/moli-protocol/src/domains/activity/output_ingress/renderer.rs
+++ b/moli-protocol/src/domains/activity/output_ingress/renderer.rs
@@ -226,6 +226,7 @@ async fn project_renderer_output_records_for_route(
cursor.stream().renderer_agent(),
&observation,
)
+ .await
};
barriers
.route_publication_outputs(
diff --git a/moli-protocol/src/domains/activity/publication_route.rs b/moli-protocol/src/domains/activity/publication_route.rs
index f720819b2..d018dfbeb 100644
--- a/moli-protocol/src/domains/activity/publication_route.rs
+++ b/moli-protocol/src/domains/activity/publication_route.rs
@@ -148,42 +148,81 @@ impl RendererPublicationOwner {
.chain(conn.inactive_browser_contexts.iter())
.filter(|browser_context| browser_context.id == *browser_context_id)
.find_map(|browser_context| {
- let (runtime_slot, route_target_id, session_id) = if target_id.is_none()
+ let projection_for = |runtime_slot: &crate::conn::TargetRuntimeSlot| {
+ if runtime_slot.routes_current_renderer_page_owner(
+ *renderer_page,
+ page_owner.page_attachment_id(),
+ ) {
+ Some(RendererPublicationProjection::CurrentPage)
+ } else if runtime_slot.routes_retiring_renderer_page_owner(
+ *renderer_page,
+ page_owner.page_attachment_id(),
+ ) {
+ Some(RendererPublicationProjection::RetiringNetworkOnly)
+ } else {
+ None
+ }
+ };
+ let route_for =
+ |runtime_slot: &crate::conn::TargetRuntimeSlot,
+ route_target_id: Option<String>,
+ session_id: Option<String>| {
+ projection_for(runtime_slot).map(|projection| {
+ RendererPublicationRoute::for_target(
+ browser_context.id.clone(),
+ route_target_id,
+ session_id,
+ projection,
+ )
+ })
+ };
+
+ // Prefer the target route captured when the renderer stream
+ // was bound. This disambiguates the brief handoff window in
+ // which active and parked state can both refer to one Page.
+ let frozen_route = if target_id.is_none()
|| browser_context.active_target_id() == target_id.as_deref()
{
- (
+ route_for(
&browser_context.active_target.runtime_slot,
None,
browser_context.active_session_id_owned(),
)
} else {
- let target_id = target_id.as_deref()?;
- let target = browser_context.background_target(target_id)?;
- (
- target.runtime_slot(),
- Some(target_id.to_owned()),
- target.session_id().map(str::to_owned),
- )
+ target_id.as_deref().and_then(|target_id| {
+ let target = browser_context.background_target(target_id)?;
+ route_for(
+ target.runtime_slot(),
+ Some(target_id.to_owned()),
+ target.session_id().map(str::to_owned),
+ )
+ })
};
- let projection = if runtime_slot.routes_current_renderer_page_owner(
- *renderer_page,
- page_owner.page_attachment_id(),
- ) {
- RendererPublicationProjection::CurrentPage
- } else if runtime_slot.routes_retiring_renderer_page_owner(
- *renderer_page,
- page_owner.page_attachment_id(),
+ if frozen_route.is_some() {
+ return frozen_route;
+ }
+
+ // A target can acquire its externally visible id after its
+ // initial Page was installed. The Page residence and Page
+ // attachment id remain stable across that rename, so use
+ // those identities to recover the current concrete route.
+ if let Some(route) = route_for(
+ &browser_context.active_target.runtime_slot,
+ None,
+ browser_context.active_session_id_owned(),
) {
- RendererPublicationProjection::RetiringNetworkOnly
- } else {
- return None;
- };
- Some(RendererPublicationRoute::for_target(
- browser_context.id.clone(),
- route_target_id,
- session_id,
- projection,
- ))
+ return Some(route);
+ }
+ browser_context
+ .background_targets
+ .iter()
+ .find_map(|target| {
+ route_for(
+ target.runtime_slot(),
+ Some(target.target_id().to_owned()),
+ target.session_id().map(str::to_owned),
+ )
+ })
}),
}
}
diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
index ecb3f89fa..0aef7f1cf 100644
--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs
+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
@@ -740,7 +740,8 @@ mod tests {
Some(SESSION_ID),
agent_token,
&observation,
- );
+ )
+ .await;
let mut command_context = CommandDispatchContext::default();
barriers
diff --git a/moli-protocol/src/domains/dom_debugger.rs b/moli-protocol/src/domains/dom_debugger.rs
index bc8abdc61..5cd8375c9 100644
--- a/moli-protocol/src/domains/dom_debugger.rs
+++ b/moli-protocol/src/domains/dom_debugger.rs
@@ -415,6 +415,9 @@ mod tests {
evaluate: Value,
resumes: Vec<Value>,
) {
+ let evaluate_id = evaluate["id"]
+ .as_u64()
+ .expect("Runtime.evaluate test command must have a numeric id");
// Keep the pending Runtime.evaluate receiver alive while the test
// scheduler observes the real renderer publication. Dispatching the
// interruptible resume before that publication is racy: the interrupt
@@ -477,6 +480,21 @@ mod tests {
.await
.expect("resumed Runtime.evaluate should complete");
assert!(scheduler_events.is_empty(), "{scheduler_events:?}");
+ if !evaluate_messages
+ .iter()
+ .any(|message| message["id"] == json!(evaluate_id))
+ {
+ if !ctx
+ .sent
+ .iter()
+ .any(|message| message["id"] == json!(evaluate_id))
+ {
+ let response_start = ctx.sent.len();
+ ctx.wait_for_test_command_response(evaluate_id, response_start)
+ .await;
+ }
+ evaluate_messages.push(ctx.take_response_by_id(evaluate_id));
+ }
messages.append(&mut evaluate_messages);
ctx.sent.extend(messages);
}
diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rs
index a98615dd3..6e26c4805 100644
--- a/moli-protocol/src/domains/emulation.rs
+++ b/moli-protocol/src/domains/emulation.rs
@@ -367,7 +367,12 @@ fn start_script_execution_disabled_command(
};
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 response_delivery = cmd.terminal_response_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ if cmd.id.is_none()
+ || response_delivery == moli_page_types::RendererInspectorResponseDelivery::CommandReply
+ {
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);
@@ -376,11 +381,15 @@ fn start_script_execution_disabled_command(
session_id: cmd.session_id.map(str::to_owned),
pending: PendingEmulationRendererDispatch::IoCommandReply(pending),
});
- };
+ }
+ let command_id = cmd
+ .id
+ .expect("session output requires a frontend command id");
let descriptor = RendererCommandDescriptor::set_script_execution_disabled(
cmd.json.to_owned(),
cmd.renderer_policy(),
params.value,
+ response_delivery,
);
let prepared = match conn.try_register_renderer_call_for_session_owner(
cmd.session_id,
@@ -394,7 +403,10 @@ fn start_script_execution_disabled_command(
}
};
let (correlation, response, response_rx) = prepared.into_parts();
- drop(response_rx);
+ debug_assert!(
+ response_rx.is_none(),
+ "Emulation session output must not allocate a command-reply receiver",
+ );
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())
@@ -2447,16 +2459,23 @@ pub(crate) fn complete_pending_emulation_command(
Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {
CommandOutputPlan::result(json!({}))
}
- Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
- CommandOutputPlan::error(-32000, "Emulation IO command was canceled")
+ Ok(CompletedDevToolsIoCommandDispatch::SessionResponse { .. }) => {
+ CommandOutputPlan::error(
+ -32000,
+ "command-reply Emulation dispatch used session output",
+ )
}
Err(error) => CommandOutputPlan::error(-32000, error),
};
}
CompletedEmulationRendererDispatch::IoSessionOutput {
- completed: Ok(CompletedDevToolsIoCommandDispatch::Dispatched),
+ completed: Ok(CompletedDevToolsIoCommandDispatch::SessionResponse { predecessor, .. }),
..
- } => return CommandOutputPlan::default(),
+ } => {
+ let mut plan = CommandOutputPlan::default();
+ plan.set_renderer_output_predecessor(predecessor);
+ return plan;
+ }
CompletedEmulationRendererDispatch::IoSessionOutput {
completed,
correlation,
@@ -2468,10 +2487,11 @@ pub(crate) fn complete_pending_emulation_command(
return CommandOutputPlan::default();
}
return match completed {
- Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
- CommandOutputPlan::error(-32000, "Emulation IO command was canceled")
- }
- Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => unreachable!(),
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => CommandOutputPlan::error(
+ -32000,
+ "Emulation IO dispatch completed without publishing its session response",
+ ),
+ Ok(CompletedDevToolsIoCommandDispatch::SessionResponse { .. }) => unreachable!(),
Err(error) => CommandOutputPlan::error(-32000, error),
};
}
diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rs
index 59171b8c2..f9e9b3540 100644
--- a/moli-protocol/src/domains/emulation/tests.rs
+++ b/moli-protocol/src/domains/emulation/tests.rs
@@ -20,15 +20,11 @@ use tokio::{
async fn complete_pending_command_task_for_test(
ctx: &mut TestContext,
- mut pending: PendingCdpCommandDispatch,
+ pending: PendingCdpCommandDispatch,
) -> Vec<serde_json::Value> {
- loop {
- let completed = pending.wait().await;
- match ctx.conn.complete_pending_command_dispatch(completed).await {
- CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,
- }
- }
+ ctx.complete_command_task_step_for_test(CdpCommandTaskStep::Pending(Box::new(pending)))
+ .await
+ .0
}
async fn loaded_page_html_for_test(ctx: &mut TestContext) -> String {
diff --git a/moli-protocol/src/domains/performance.rs b/moli-protocol/src/domains/performance.rs
index d4cc960c4..1b8d2e6cd 100644
--- a/moli-protocol/src/domains/performance.rs
+++ b/moli-protocol/src/domains/performance.rs
@@ -81,9 +81,9 @@ impl PendingPerformanceCommandDispatch {
Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => Ok(
CompletedPerformanceRendererCommand::IoCommandReply(snapshot),
),
- Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
- Err(anyhow::anyhow!("Performance IO command was canceled"))
- }
+ Ok(CompletedDevToolsIoCommandDispatch::SessionResponse { .. }) => Err(
+ anyhow::anyhow!("command-reply Performance dispatch used session output"),
+ ),
Err(error) => Err(error),
}
}
@@ -254,7 +254,12 @@ pub(crate) fn try_start_performance_command_dispatch(
page.cached_performance_metric_snapshot(),
)
};
- let Some(command_id) = cmd.id else {
+ let response_delivery = cmd.terminal_response_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ if cmd.id.is_none()
+ || response_delivery == moli_page_types::RendererInspectorResponseDelivery::CommandReply
+ {
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();
@@ -268,7 +273,10 @@ pub(crate) fn try_start_performance_command_dispatch(
snapshot,
}),
});
- };
+ }
+ let command_id = cmd
+ .id
+ .expect("session output requires a frontend command id");
let Some(attachment_id) = attachment_id else {
return PerformanceCommandTaskStep::Complete(default_metrics_command_output_plan());
};
@@ -278,6 +286,7 @@ pub(crate) fn try_start_performance_command_dispatch(
let descriptor = RendererCommandDescriptor::performance_get_metrics(
cmd.json.to_owned(),
cmd.renderer_policy(),
+ response_delivery,
);
let prepared = match conn.try_register_renderer_call_for_session_owner(
cmd.session_id,
@@ -293,7 +302,10 @@ pub(crate) fn try_start_performance_command_dispatch(
}
};
let (correlation, response, response_rx) = prepared.into_parts();
- drop(response_rx);
+ debug_assert!(
+ response_rx.is_none(),
+ "Performance session output must not allocate a command-reply receiver",
+ );
let pending = loaded_page_mut_for_renderer_access(conn, cmd.session_id, renderer_access)
.ok()
.filter(|page| {
@@ -420,11 +432,12 @@ pub(crate) async fn complete_pending_performance_command(
completed,
correlation,
}) => {
- if matches!(
- completed,
- Ok(CompletedDevToolsIoCommandDispatch::Dispatched)
- ) {
- return CommandOutputPlan::default();
+ if let Ok(CompletedDevToolsIoCommandDispatch::SessionResponse { predecessor, .. }) =
+ completed
+ {
+ let mut plan = CommandOutputPlan::default();
+ plan.set_renderer_output_predecessor(predecessor);
+ return plan;
}
if !owner_scope
.conn_mut()
@@ -706,27 +719,16 @@ mod tests {
command_id: u64,
) -> Vec<Value> {
let response_start = ctx.sent.len();
- let mut step = step;
- loop {
- match step {
- CdpCommandTaskStep::Pending(pending) => {
- let completed = pending.wait().await;
- step = ctx.conn.complete_pending_command_dispatch(completed).await;
- }
- 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;
- }
- }
+ let (mut messages, _) = ctx.complete_command_task_step_for_test(step).await;
+ 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));
}
+ messages
}
fn complete_immediate_command_task_step_for_test(step: CdpCommandTaskStep) -> Vec<Value> {
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index 2f0037592..e5d770e10 100644
--- a/moli-protocol/src/domains/runtime/dispatcher.rs
+++ b/moli-protocol/src/domains/runtime/dispatcher.rs
@@ -1031,8 +1031,16 @@ fn start_main_runtime_inspector_command(
));
}
};
- let pending = match start_pending_runtime_routable_inspector_dispatch(conn, cmd, inspector_json)
- {
+ let pending = match start_pending_runtime_routable_inspector_dispatch(
+ conn,
+ cmd,
+ inspector_json,
+ if await_promise {
+ RendererInspectorResponseDelivery::CommandReply
+ } else {
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)
+ },
+ ) {
Ok(pending) => pending,
Err(message) => {
forget_pre_registered_runtime_await(conn, pre_registered_await, cmd.session_id);
@@ -1088,15 +1096,17 @@ pub(crate) fn start_profiler_inspector_command_dispatch(
}
let action = dispatch.protocol_method();
- let pending =
- match start_pending_runtime_inspector_dispatch(conn, cmd, dispatch.into_inspector_json()) {
- Ok(pending) => pending,
- Err(message) => {
- return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
- cmd.id, message,
- ));
- }
- };
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ dispatch.into_inspector_json(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
+ Ok(pending) => pending,
+ Err(message) => {
+ return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(cmd.id, message));
+ }
+ };
RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {
command_id: cmd.id,
@@ -1173,7 +1183,12 @@ pub(crate) fn start_heap_profiler_inspector_command_dispatch(
let method = heap_profiler_action_protocol_method(action);
let object_group = heap_profiler_object_group_for_command_result(cmd, action);
- let pending = match start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ RendererInspectorResponseDelivery::CommandReply,
+ ) {
Ok(pending) => pending,
Err(message) => {
return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(cmd.id, message));
@@ -1220,11 +1235,19 @@ pub(crate) fn start_debugger_inspector_command_dispatch(
let pending = match cmd.renderer_policy().access() {
CdpRendererCommandAccess::MainThread => {
- start_pending_runtime_inspector_dispatch(conn, cmd, inspector_json)
- }
- CdpRendererCommandAccess::Io => {
- start_pending_runtime_io_inspector_dispatch(conn, cmd, inspector_json)
+ start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ inspector_json,
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ )
}
+ CdpRendererCommandAccess::Io => start_pending_runtime_io_inspector_dispatch(
+ conn,
+ cmd,
+ inspector_json,
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ),
CdpRendererCommandAccess::OwnerIndependent => Err(
"an owner-independent command cannot enter the Debugger Inspector dispatcher"
.to_owned(),
@@ -1427,7 +1450,12 @@ pub(crate) fn start_console_inspector_command_dispatch(
));
}
- let pending = match start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
Ok(pending) => pending,
Err(message) => {
return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(cmd.id, message));
@@ -1817,9 +1845,12 @@ fn try_start_pending_runtime_binding_command(
action_label,
cmd.json.to_owned(),
),
- RuntimeBindingCommand::Remove => {
- start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned())
- }
+ RuntimeBindingCommand::Remove => start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ RendererInspectorResponseDelivery::CommandReply,
+ ),
};
let pending = match pending {
Ok(pending) => pending,
@@ -1851,14 +1882,23 @@ fn start_pending_runtime_routable_inspector_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
inspector_json: String,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
match cmd.renderer_policy().access() {
CdpRendererCommandAccess::MainThread => {
- start_pending_runtime_inspector_dispatch(conn, cmd, inspector_json)
- }
- CdpRendererCommandAccess::Io => {
- start_pending_runtime_io_inspector_dispatch(conn, cmd, inspector_json)
+ start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ inspector_json,
+ response_delivery,
+ )
}
+ CdpRendererCommandAccess::Io => start_pending_runtime_io_inspector_dispatch(
+ conn,
+ cmd,
+ inspector_json,
+ response_delivery,
+ ),
CdpRendererCommandAccess::OwnerIndependent => Err(
"an owner-independent command cannot enter the Runtime Inspector dispatcher".to_owned(),
),
@@ -1869,12 +1909,13 @@ fn start_pending_runtime_io_inspector_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
inspector_json: String,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
cmd.renderer_policy(),
- RendererInspectorResponseDelivery::DevToolsSession,
+ response_delivery,
);
conn.start_runtime_io_protocol_message_for_session_owner_with_deferred_response(
cmd.session_id,
@@ -1906,21 +1947,20 @@ fn start_pending_runtime_context_resolved_inspector_dispatch_with_delivery(
cmd: &Cmd<'_>,
action: &'static str,
inspector_json: String,
- nested_response_delivery: RendererInspectorResponseDelivery,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
cmd.renderer_policy(),
- RendererInspectorResponseDelivery::CommandReply,
+ response_delivery,
);
- conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response_and_nested_delivery(
- cmd.session_id,
- action,
- descriptor,
- command_id,
- nested_response_delivery,
- )
+ conn.start_runtime_protocol_message_with_context_resolution_for_session_owner_with_deferred_response(
+ cmd.session_id,
+ action,
+ descriptor,
+ command_id,
+ )
} else {
conn.start_runtime_protocol_message_with_context_resolution_for_session_owner(
cmd.session_id,
@@ -1930,16 +1970,17 @@ fn start_pending_runtime_context_resolved_inspector_dispatch_with_delivery(
}
}
-fn start_pending_runtime_inspector_dispatch(
+fn start_pending_runtime_inspector_dispatch_with_delivery(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
inspector_json: String,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
cmd.renderer_policy(),
- RendererInspectorResponseDelivery::CommandReply,
+ response_delivery,
);
conn.start_runtime_protocol_message_for_session_owner_with_deferred_response(
cmd.session_id,
@@ -2041,7 +2082,7 @@ fn start_cdp_devtools_script_runtime_command(
if await_promise {
RendererInspectorResponseDelivery::CommandReply
} else {
- RendererInspectorResponseDelivery::DevToolsSession
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)
},
)
}
@@ -8186,25 +8227,69 @@ async fn complete_pending_runtime_inspector_command(
timing_started: Option<std::time::Instant>,
response_flush: &crate::conn::CommandResponseFlushContext,
) -> RuntimeCommandTaskStep {
- let (messages, mut renderer_response_rx, page_owner_access_allowed, response_delivery) =
- match completed_inspector {
- Ok(mut completed_protocol) => {
- let page_owner_access_allowed = completed_protocol.page_owner_access_allowed();
- let response_delivery = completed_protocol.response_delivery();
- let renderer_response_rx = completed_protocol.take_deferred_response_receiver();
- match conn
- .complete_runtime_protocol_message_for_session_owner_async(completed_protocol)
- .await
- {
- Ok(messages) => (
- messages,
- renderer_response_rx,
- page_owner_access_allowed,
- response_delivery,
- ),
- Err(message) => {
+ let (
+ messages,
+ mut renderer_response_rx,
+ page_owner_access_allowed,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ) = match completed_inspector {
+ Ok(mut completed_protocol) => {
+ let page_owner_access_allowed = completed_protocol.page_owner_access_allowed();
+ let session_response_succeeded = completed_protocol.session_response_succeeded();
+ let session_response_predecessor = completed_protocol.session_response_predecessor();
+ let response_delivery = completed_protocol.response_delivery();
+ let renderer_response_rx = completed_protocol.take_deferred_response_receiver();
+ match conn
+ .complete_runtime_protocol_message_for_session_owner_async(completed_protocol)
+ .await
+ {
+ Ok(messages) => (
+ messages,
+ renderer_response_rx,
+ page_owner_access_allowed,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ),
+ Err(message) => {
+ if let Some(command_id) = completed.command_id {
+ conn.forget_pending_inspector_await(command_id, completed.session_id());
+ }
+ if session_response_succeeded.is_some() {
+ tracing::debug!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "ignored browser-side completion error after the renderer session settled the terminal response"
+ );
+ (
+ None,
+ renderer_response_rx,
+ page_owner_access_allowed,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ )
+ } else {
if let Some(command_id) = completed.command_id {
- conn.forget_pending_inspector_await(command_id, completed.session_id());
+ let correlation = conn
+ .take_renderer_call_for_frontend_for_session_owner(
+ completed.session_id(),
+ command_id,
+ );
+ if correlation.is_none() {
+ tracing::debug!(
+ command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "ignored renderer completion error after another route settled the frontend call"
+ );
+ return RuntimeCommandTaskStep::Complete(
+ CommandOutputPlan::default(),
+ );
+ }
}
return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
completed.command_id,
@@ -8213,16 +8298,30 @@ async fn complete_pending_runtime_inspector_command(
}
}
}
- Err(message) => {
- if let Some(command_id) = completed.command_id {
- conn.forget_pending_inspector_await(command_id, completed.session_id());
+ }
+ Err(message) => {
+ if let Some(command_id) = completed.command_id {
+ conn.forget_pending_inspector_await(command_id, completed.session_id());
+ let correlation = conn.take_renderer_call_for_frontend_for_session_owner(
+ completed.session_id(),
+ command_id,
+ );
+ if correlation.is_none() {
+ tracing::debug!(
+ command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "ignored canceled renderer route after another route settled the frontend call"
+ );
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::default());
}
- return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
- completed.command_id,
- message,
- ));
}
- };
+ return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
+ completed.command_id,
+ message,
+ ));
+ }
+ };
let initial_message_count = messages.as_ref().map_or(0, |messages| {
messages
.runtime_inspector_output()
@@ -8240,6 +8339,9 @@ async fn complete_pending_runtime_inspector_command(
let mut plan = CommandOutputPlan::default();
let mut routed_output = RuntimeInspectorRoutedOutput::default();
+ if let Some(predecessor) = session_response_predecessor {
+ routed_output.set_renderer_output_predecessor(predecessor);
+ }
let mut saw_current_response = if let Some(messages) = messages {
route_renderer_command_turn_output_into_routed_output(
conn,
@@ -8316,7 +8418,8 @@ async fn complete_pending_runtime_inspector_command(
page_owner_access_allowed,
);
}
- let succeeded = routed_output.command_response_succeeded(completed.command_id);
+ let succeeded = session_response_succeeded
+ .unwrap_or_else(|| routed_output.command_response_succeeded(completed.command_id));
if succeeded {
routed_output.register_object_group_for_success(
conn,
@@ -8328,10 +8431,20 @@ async fn complete_pending_runtime_inspector_command(
if let Some(console_action) = console_action_from_protocol_method(completed.action)
&& !apply_console_output_state_for_session(conn, completed.session_id(), console_action)
{
- return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
- completed.command_id,
- format!("ConsoleCommandCompletionFailed: {}", completed.action),
- ));
+ let message = format!("ConsoleCommandCompletionFailed: {}", completed.action);
+ if session_response_succeeded.is_some() {
+ tracing::warn!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "could not apply browser projection after the terminal renderer response was published"
+ );
+ } else {
+ return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
+ completed.command_id,
+ message,
+ ));
+ }
}
if completed.action == "discardConsoleEntries" {
advance_runtime_observable_cursors_to_current_for_session_owner(
@@ -8343,19 +8456,37 @@ async fn complete_pending_runtime_inspector_command(
if let Err(message) =
apply_runtime_disable_projection_after_success(conn, completed.session_id())
{
- return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
- completed.command_id,
- message,
- ));
+ if session_response_succeeded.is_some() {
+ tracing::warn!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "could not apply browser projection after the terminal renderer response was published"
+ );
+ } else {
+ return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
+ completed.command_id,
+ message,
+ ));
+ }
}
if let Err(message) = conn
.apply_runtime_binding_state_for_session_owner_async(completed.session_id())
.await
{
- return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
- completed.command_id,
- message,
- ));
+ if session_response_succeeded.is_some() {
+ tracing::warn!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "could not apply browser projection after the terminal renderer response was published"
+ );
+ } else {
+ return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(
+ completed.command_id,
+ message,
+ ));
+ }
}
}
if !completed.release_object_ids.is_empty() {
@@ -10163,7 +10294,12 @@ fn start_pending_runtime_disable_command(
return RuntimeCommandTaskStep::Complete(disable_command_output_plan_sync(conn, cmd));
}
- let pending = match start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
Ok(pending) => pending,
Err(message) => {
return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(cmd.id, message));
@@ -10194,7 +10330,12 @@ fn start_runtime_run_if_waiting_for_debugger_command(
return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
}
- let pending = match start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
Ok(pending) => pending,
Err(message) if message == "NoDocumentLoaded" => {
return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
@@ -10249,7 +10390,12 @@ fn start_runtime_discard_console_entries_command(
advance_runtime_observable_cursors_to_current_for_session_owner(conn, cmd.session_id);
return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
}
- let pending = match start_pending_runtime_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
+ let pending = match start_pending_runtime_inspector_dispatch_with_delivery(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
Ok(pending) => pending,
Err(message) => {
return RuntimeCommandTaskStep::Complete(runtime_inspector_error_plan(cmd.id, message));
@@ -10284,6 +10430,7 @@ mod protocol_neutral_tests {
BrowserContext, CdpConnection, CdpSessionRoute, Cmd, SharedWorkerTargetState,
};
use crate::domains::actions::ConsoleAction;
+ use crate::testing::TestContext;
use super::super::bidi_nodes::{
BidiIncludeShadowTree, BidiNodeSerializationOptions,
@@ -11353,16 +11500,18 @@ mod protocol_neutral_tests {
#[tokio::test]
async fn duplicate_non_await_v8_command_preserves_original_completion_owner() {
- let mut conn = CdpConnection::new();
+ let mut ctx = TestContext::new();
let mut browser_context = BrowserContext::new("BID-console-duplicate".to_owned());
browser_context.set_active_target_id("TID-console-duplicate".to_owned());
browser_context.attach_active_session("SID-console-duplicate".to_owned());
- conn.browser_context = Some(browser_context);
- let page = conn
+ ctx.conn.browser_context = Some(browser_context);
+ let page = ctx
+ .conn
.load_page_via_runtime_async("data:text/html,<p>console duplicate</p>")
.await
.expect("page should load");
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_mut()
.expect("browser context")
.active_target
@@ -11378,7 +11527,7 @@ mod protocol_neutral_tests {
r#"{"id":78,"method":"Console.enable","sessionId":"SID-console-duplicate"}"#,
);
let RuntimeCommandTaskStep::Pending(original) =
- start_console_inspector_command_dispatch(&mut conn, &enable, ConsoleAction::Enable)
+ start_console_inspector_command_dispatch(&mut ctx.conn, &enable, ConsoleAction::Enable)
else {
panic!("first Console command should own a renderer correlation");
};
@@ -11391,7 +11540,11 @@ mod protocol_neutral_tests {
r#"{"id":78,"method":"Console.disable","sessionId":"SID-console-duplicate"}"#,
);
let RuntimeCommandTaskStep::Complete(duplicate_plan) =
- start_console_inspector_command_dispatch(&mut conn, &disable, ConsoleAction::Disable)
+ start_console_inspector_command_dispatch(
+ &mut ctx.conn,
+ &disable,
+ ConsoleAction::Disable,
+ )
else {
panic!("duplicate Console command must fail before renderer dispatch");
};
@@ -11410,13 +11563,19 @@ mod protocol_neutral_tests {
);
let completed = original.wait().await;
- let RuntimeCommandTaskStep::Complete(original_plan) =
- super::complete_pending_runtime_command(&mut conn, completed).await
+ let RuntimeCommandTaskStep::Complete(mut original_plan) =
+ super::complete_pending_runtime_command(&mut ctx.conn, completed).await
else {
panic!("original Console command should still complete");
};
+ let predecessor = original_plan
+ .take_renderer_output_predecessor()
+ .expect("original Console command should publish a session response");
+ ctx.route_direct_command_renderer_predecessor_for_test(predecessor)
+ .await;
let mut original_output = Vec::new();
original_plan.emit_into(&mut original_output, enable.id, enable.session_id);
+ original_output.push(ctx.take_response_by_id(78));
assert_eq!(original_output.len(), 1);
assert_eq!(original_output[0]["id"], json!(78));
assert_eq!(
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index 0424b1d2b..75ca1fcb5 100644
--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs
+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs
@@ -8075,6 +8075,8 @@ fn replay_policy_command_rotates_lease_and_completes_on_replacement_attachment()
)
.expect("register replay command");
let (old_correlation, old_sender, response_receiver) = prepared.into_parts();
+ let response_receiver = response_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
ctx.process_async(json!({
"id": 9_022,
diff --git a/moli-protocol/src/domains/target/attachment.rs b/moli-protocol/src/domains/target/attachment.rs
index 0f5a2970d..5df0944a1 100644
--- a/moli-protocol/src/domains/target/attachment.rs
+++ b/moli-protocol/src/domains/target/attachment.rs
@@ -454,7 +454,7 @@ async fn send_message_to_target_inner_async(
}
let nested_outcome =
- Box::pin(conn.process_message_with_turn_outcome_async(&params.message)).await;
+ Box::pin(conn.process_message_with_command_reply_turn_outcome_async(&params.message)).await;
let (
nested_events,
post_renderer_output_events,
diff --git a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p1_target_multipage.rs b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p1_target_multipage.rs
index c99d6b144..b58c6972d 100644
--- a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p1_target_multipage.rs
+++ b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p1_target_multipage.rs
@@ -1421,6 +1421,52 @@ async fn rust_cdp_chromium_target_send_message_to_target_wraps_nested_result() {
.expect("nested protocol JSON");
assert_eq!(nested["id"], 1);
assert_eq!(nested["result"]["result"]["value"], 3, "{nested}");
+
+ for (outer_id, nested) in [
+ (
+ 260_044,
+ json!({
+ "id": 2,
+ "method": "Emulation.setScriptExecutionDisabled",
+ "params": { "value": true }
+ }),
+ ),
+ (
+ 260_045,
+ json!({ "id": 3, "method": "Performance.enable", "params": {} }),
+ ),
+ (
+ 260_046,
+ json!({ "id": 4, "method": "Performance.getMetrics", "params": {} }),
+ ),
+ ] {
+ ctx.process_async(json!({
+ "id": outer_id,
+ "method": "Target.sendMessageToTarget",
+ "params": {
+ "sessionId": "SID-active",
+ "message": nested.to_string(),
+ }
+ }))
+ .await;
+ let messages = ctx.take_all();
+ assert_eq!(response(&messages, outer_id)["result"], json!({}));
+ let received = event(&messages, "Target.receivedMessageFromTarget");
+ let nested_response: Value = serde_json::from_str(
+ received["params"]["message"]
+ .as_str()
+ .expect("nested protocol message"),
+ )
+ .expect("nested protocol JSON");
+ assert_eq!(nested_response["id"], nested["id"]);
+ assert!(nested_response.get("result").is_some(), "{nested_response}");
+ if nested["method"] == "Performance.getMetrics" {
+ assert!(
+ nested_response["result"]["metrics"].is_array(),
+ "{nested_response}"
+ );
+ }
+ }
}
// Chromium source:
diff --git a/moli-protocol/src/domains/target/tests/tests_control_plane.rs b/moli-protocol/src/domains/target/tests/tests_control_plane.rs
index 07e8d9862..5581eccb4 100644
--- a/moli-protocol/src/domains/target/tests/tests_control_plane.rs
+++ b/moli-protocol/src/domains/target/tests/tests_control_plane.rs
@@ -1362,36 +1362,41 @@ async fn set_auto_attach_sweep_chain_promotes_multiple_existing_background_targe
async fn set_auto_attach_prefers_existing_background_target_with_parked_loaded_runtime() {
let mut ctx = TestContext::new();
load_bc_with_target(&mut ctx, "BID-9", "TID-000000000E");
- let parked_page = ctx
- .conn
- .load_page_via_runtime_async(
- "data:text/html,<title>parked</title><div id='ok'>parked runtime</div>",
- )
- .await
- .expect("parked background page should initialize");
- let bc = ctx.conn.browser_context.as_mut().unwrap();
- bc.background_targets
- .push(crate::conn::BackgroundTarget::new(
- "TID-000000000F".into(),
- None,
- crate::conn::TargetIdentityState::new(
- "about:blank#metadata-only".into(),
- crate::conn::URL_BASE.into(),
- "Secure".into(),
- ),
- crate::conn::TargetPageSlot::empty_for_test_fixture(),
- ));
- bc.background_targets
- .push(crate::conn::BackgroundTarget::new(
+ {
+ let bc = ctx.conn.browser_context.as_mut().unwrap();
+ bc.background_targets
+ .push(crate::conn::BackgroundTarget::new(
+ "TID-000000000F".into(),
+ None,
+ crate::conn::TargetIdentityState::new(
+ "about:blank#metadata-only".into(),
+ crate::conn::URL_BASE.into(),
+ "Secure".into(),
+ ),
+ crate::conn::TargetPageSlot::empty_for_test_fixture(),
+ ));
+ bc.stage_active_target_demoting_current(
"TID-0000000010".into(),
None,
- crate::conn::TargetIdentityState::new(
- "about:blank#parked".into(),
- "null".into(),
- "Secure".into(),
- ),
- crate::conn::TargetPageSlot::with_loaded_page_for_test(parked_page),
- ));
+ "about:blank#parked".into(),
+ Some("about:blank".into()),
+ );
+ }
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<title>parked</title><div id='ok'>parked runtime</div>",
+ None,
+ )
+ .await;
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_mut()
+ .unwrap()
+ .promote_background_target_to_active_slot_async("TID-000000000E")
+ .await
+ .expect("restoring the original active target should succeed"),
+ "the original active target should remain parked during fixture setup"
+ );
ctx.process_async(json!({
"id": 17023,
diff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rs
index e4e629604..6c51cf164 100644
--- a/moli-protocol/src/domains/target/worker_target.rs
+++ b/moli-protocol/src/domains/target/worker_target.rs
@@ -6705,6 +6705,8 @@ mod tests {
.expect("attached shared worker session")
.expect("non-await renderer call should register");
let (correlation, old_sender, terminal_receiver) = prepared.into_parts();
+ let terminal_receiver = terminal_receiver
+ .expect("a synthesized CommandReply call must allocate a response receiver");
let outputs =
remove_shared_worker_target(&mut conn, "BID-1", SharedWorkerInstanceId::from_u64(15))
diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rs
index 11cc17fb6..977e3a02b 100644
--- a/moli-protocol/src/testing.rs
+++ b/moli-protocol/src/testing.rs
@@ -530,6 +530,8 @@ impl TestContext {
) -> TestCommandResponseFlushPermit {
let command = ParsedCdpCommand::from_serializable(msg)
.expect("test message must be a valid serialisable CDP command");
+ let command_id = command.request().id();
+ let response_start = self.sent.len();
let (response_flush_permit, response_flush_context) =
self.conn.begin_command_response_flush_permit();
let mut command_context = CommandDispatchContext::new(response_flush_context);
@@ -555,6 +557,7 @@ impl TestContext {
protocol_events.extend(command_context.take_post_response_events());
scheduler_events.extend(self.conn.take_scheduler_events());
Box::pin(self.route_test_scheduler_causal_batch(protocol_events, scheduler_events)).await;
+ Box::pin(self.route_ready_test_command_response(command_id, response_start)).await;
TestCommandResponseFlushPermit {
response_flush: response_flush_permit,
runtime_output_barrier,
@@ -586,6 +589,10 @@ impl TestContext {
step: CdpCommandTaskStep,
) -> (Vec<Value>, Vec<CdpSchedulerEvent>) {
let sent_start = self.sent.len();
+ let command_id = match &step {
+ CdpCommandTaskStep::Pending(pending) => pending.command_id(),
+ CdpCommandTaskStep::Complete(_) => None,
+ };
let mut protocol_events = Vec::new();
let mut scheduler_events = Vec::new();
let mut runtime_output_barrier = None;
@@ -598,10 +605,30 @@ impl TestContext {
))
.await;
if completed {
- return (
- protocol_events_into_messages(protocol_events),
- scheduler_events,
- );
+ let mut messages = protocol_events_into_messages(protocol_events);
+ if let Some(command_id) = command_id
+ && !messages
+ .iter()
+ .any(|message| message.get("id").and_then(Value::as_u64) == Some(command_id))
+ {
+ // Synchronous renderer-owned Runtime commands publish their
+ // terminal response through the DevTools-session output
+ // transport. The command completion only proves that the
+ // publication was committed; admit that independently
+ // transported response just as `process_async` does, while
+ // leaving sibling renderer events in the scheduler queue.
+ Box::pin(self.route_ready_test_command_response(command_id, sent_start)).await;
+ if let Some(position) = self.sent.get(sent_start..).and_then(|sent| {
+ sent.iter()
+ .position(|message| {
+ message.get("id").and_then(Value::as_u64) == Some(command_id)
+ })
+ .map(|position| sent_start + position)
+ }) {
+ messages.push(self.sent.remove(position));
+ }
+ }
+ return (messages, scheduler_events);
}
Box::pin(self.route_test_scheduler_causal_batch(protocol_events, scheduler_events)).await;
@@ -1257,10 +1284,13 @@ impl TestContext {
}
})
.await;
- assert!(
- response.is_ok(),
- "timed out waiting for CDP command `{command_id}` response"
- );
+ if response.is_err() {
+ panic!(
+ "timed out waiting for CDP command `{command_id}` response; sent={:?}; diagnostics={}",
+ self.sent,
+ self.conn.moli_memory_diagnostics()
+ );
+ }
}
async fn route_ready_test_command_response(&mut self, command_id: u64, response_start: usize) {
@@ -1757,7 +1787,12 @@ impl TestContext {
.sent
.iter()
.position(|message| message["id"] == json!(id))
- .unwrap_or_else(|| panic!("expected a response with id {id}"));
+ .unwrap_or_else(|| {
+ panic!(
+ "expected a response with id {id} in sent queue: {:?}",
+ self.sent
+ )
+ });
self.sent.remove(pos)
}
diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs
index edb3c54a5..d8b212537 100644
--- a/moli-renderer-v8/src/devtools/command.rs
+++ b/moli-renderer-v8/src/devtools/command.rs
@@ -4,10 +4,7 @@ use crate::runtime::{
RendererInspectorPageCommand, RendererPageCommand, RendererRuntimeInspectorResponseSender,
};
use crate::script_execution_control::RendererScriptExecutionControl;
-use moli_page_types::{
- DevToolsSessionKey, RendererAgentAttachmentId, RendererDevToolsCommandId,
- RendererInspectorResponseDelivery,
-};
+use moli_page_types::{DevToolsSessionKey, RendererAgentAttachmentId, RendererDevToolsCommandId};
use serde_json::Value;
/// Chromium routes Page DevTools work through separate main-thread and IO
@@ -20,15 +17,6 @@ pub enum RendererInspectorCommandRoute {
Io,
}
-/// The command owns its receiver dispatch slot until its first access to the
-/// target agent. Protocol response completion is not part of this lifetime:
-/// V8 may complete a response asynchronously, and holding the slot for that
-/// response could prevent a later resume command from running.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum RendererInspectorFirstDispatchLifecycle {
- OrderedUntilFirstDispatch,
-}
-
/// Pause-loop transition owned by an Inspector command. This is derived once
/// when the ingress envelope is created so executors do not need to reparse
/// protocol JSON to decide how resumed/paused notifications are attributed.
@@ -129,12 +117,8 @@ impl RendererInspectorIngressTicket {
/// envelope.
pub struct RendererInspectorCommandEnvelope {
ticket: RendererInspectorIngressTicket,
- first_dispatch: RendererInspectorFirstDispatchLifecycle,
pause_effect: RendererInspectorPauseCommandEffect,
main_dispatch_boundary: RendererInspectorMainDispatchBoundary,
- /// Terminal sink when an Inspector session directly claims this command.
- /// A Main command claimed by the Page owner keeps its typed reply sink.
- inspector_response_delivery: RendererInspectorResponseDelivery,
payload: RendererInspectorCommandPayload,
}
@@ -254,10 +238,6 @@ impl RendererDevToolsIoCommandEnvelope {
&self.ticket
}
- pub(crate) fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch
- }
-
pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {
match &self.payload {
RendererDevToolsIoCommandPayload::Inspector(_) => {
@@ -288,6 +268,16 @@ impl RendererDevToolsIoCommandEnvelope {
}
}
+ pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
+ match &self.payload {
+ RendererDevToolsIoCommandPayload::Inspector(envelope) => envelope.response(),
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics { response, .. }
+ | RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { response, .. } => {
+ response.as_ref()
+ }
+ }
+ }
+
pub(crate) fn into_payload(self) -> RendererDevToolsIoCommandPayload {
self.payload
}
@@ -340,10 +330,6 @@ impl RendererDevToolsMainCommandEnvelope {
&self.ticket
}
- pub(crate) fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch
- }
-
pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {
match self.payload.as_ref() {
RendererPageCommand::Inspector(envelope)
@@ -363,6 +349,11 @@ impl RendererDevToolsMainCommandEnvelope {
}
}
+ pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
+ self.inspector_envelope()
+ .and_then(RendererInspectorCommandEnvelope::response)
+ }
+
pub(crate) fn into_nested_inspector_envelope(self) -> RendererInspectorCommandEnvelope {
assert_eq!(
self.nested_dispatch(),
@@ -375,13 +366,6 @@ impl RendererDevToolsMainCommandEnvelope {
envelope
}
- pub(crate) fn into_inspector_envelope(self) -> Option<RendererInspectorCommandEnvelope> {
- match *self.payload {
- RendererPageCommand::Inspector(envelope) => Some(envelope),
- _ => None,
- }
- }
-
pub(crate) fn into_nested_page_command(self) -> RendererPageCommand {
assert_eq!(
self.nested_dispatch(),
@@ -415,10 +399,8 @@ impl RendererInspectorCommandEnvelope {
inspector_session_id,
RendererInspectorCommandRoute::MainThread,
),
- first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
pause_effect: RendererInspectorPauseCommandEffect::None,
main_dispatch_boundary: RendererInspectorMainDispatchBoundary::PageOwner,
- inspector_response_delivery: RendererInspectorResponseDelivery::CommandReply,
payload: RendererInspectorCommandPayload::MainThread(command),
}
}
@@ -429,7 +411,6 @@ impl RendererInspectorCommandEnvelope {
owner_context_resolution_action: Option<String>,
raw_json: String,
response: RendererRuntimeInspectorResponseSender,
- inspector_response_delivery: RendererInspectorResponseDelivery,
) -> Self {
assert_eq!(
ticket.route(),
@@ -458,10 +439,8 @@ impl RendererInspectorCommandEnvelope {
};
Self {
ticket,
- first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),
main_dispatch_boundary,
- inspector_response_delivery,
payload: RendererInspectorCommandPayload::MainThread(command),
}
}
@@ -471,7 +450,6 @@ impl RendererInspectorCommandEnvelope {
ticket: RendererInspectorIngressTicket,
raw_json: String,
response: Option<RendererRuntimeInspectorResponseSender>,
- response_delivery: RendererInspectorResponseDelivery,
) -> Self {
assert_eq!(
ticket.route(),
@@ -481,10 +459,8 @@ impl RendererInspectorCommandEnvelope {
let message = serde_json::from_str::<Value>(&raw_json).ok();
Self {
ticket,
- first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),
main_dispatch_boundary: RendererInspectorMainDispatchBoundary::InspectorSession,
- inspector_response_delivery: response_delivery,
payload: RendererInspectorCommandPayload::Io { raw_json, response },
}
}
@@ -493,16 +469,25 @@ impl RendererInspectorCommandEnvelope {
&self.ticket
}
- pub fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
- self.first_dispatch
- }
-
pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {
self.pause_effect
}
- pub(crate) fn inspector_response_delivery(&self) -> RendererInspectorResponseDelivery {
- self.inspector_response_delivery
+ pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
+ match &self.payload {
+ RendererInspectorCommandPayload::MainThread(
+ RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
+ deferred_response,
+ ..
+ }
+ | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
+ deferred_response,
+ ..
+ },
+ ) => Some(deferred_response),
+ RendererInspectorCommandPayload::Io { response, .. } => response.as_ref(),
+ RendererInspectorCommandPayload::MainThread(_) => None,
+ }
}
pub(crate) fn can_dispatch_at_nested_inspector_session_boundary(&self) -> bool {
@@ -529,17 +514,6 @@ impl RendererInspectorCommandEnvelope {
command
}
- pub(crate) fn is_main_protocol_command_with_deferred_response(&self) -> bool {
- matches!(
- self.main_thread_payload(),
- RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
- ..
- } | RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
- ..
- }
- )
- }
-
#[cfg(test)]
pub(crate) fn main_protocol_raw_json(&self) -> &str {
match self.main_thread_payload() {
@@ -556,17 +530,8 @@ impl RendererInspectorCommandEnvelope {
}
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"),
- }
+ self.response()
+ .expect("only a deferred Main protocol command can enter the nested receiver")
}
pub(crate) fn into_main_protocol_parts(
@@ -604,20 +569,6 @@ impl RendererInspectorCommandEnvelope {
raw_json
}
- pub(crate) fn io_response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
- let RendererInspectorCommandPayload::Io { response, .. } = &self.payload else {
- panic!("a MainThread Inspector envelope cannot enter IO dispatch");
- };
- response.as_ref()
- }
-
- pub(crate) fn io_response_delivery(&self) -> RendererInspectorResponseDelivery {
- let RendererInspectorCommandPayload::Io { .. } = &self.payload else {
- panic!("a MainThread Inspector envelope cannot enter IO dispatch");
- };
- self.inspector_response_delivery
- }
-
pub(crate) fn take_io_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {
let RendererInspectorCommandPayload::Io { response, .. } = &mut self.payload else {
panic!("a MainThread Inspector envelope cannot enter IO dispatch");
diff --git a/moli-renderer-v8/src/devtools/ingress/io.rs b/moli-renderer-v8/src/devtools/ingress/io.rs
index d47a5c6ba..61ffc52e1 100644
--- a/moli-renderer-v8/src/devtools/ingress/io.rs
+++ b/moli-renderer-v8/src/devtools/ingress/io.rs
@@ -9,7 +9,6 @@ use std::{
use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};
use parking_lot::Mutex;
-use serde_json::json;
use crate::{
devtools::{
@@ -44,10 +43,14 @@ pub(crate) enum RendererInspectorIoCommandConsumer {
Pause,
}
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
pub enum RendererRuntimeInspectorIoCommandClaim {
Dispatched,
- Canceled,
+ SessionResponse {
+ predecessor: crate::runtime::RendererOutputFence,
+ response_succeeded: bool,
+ },
+ Canceled(String),
}
type RendererInspectorIoFirstDispatchSender =
@@ -72,12 +75,6 @@ impl RendererInspectorIoCommand {
self.envelope.ticket()
}
- pub(crate) fn first_dispatch_lifecycle(
- &self,
- ) -> crate::runtime::RendererInspectorFirstDispatchLifecycle {
- self.envelope.first_dispatch_lifecycle()
- }
-
pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {
self.envelope.kind()
}
@@ -90,16 +87,7 @@ impl RendererInspectorIoCommand {
}
pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
- self.envelope
- .inspector_envelope()
- .and_then(RendererInspectorCommandEnvelope::io_response)
- }
-
- pub(crate) fn response_delivery(&self) -> moli_page_types::RendererInspectorResponseDelivery {
- self.envelope
- .inspector_envelope()
- .expect("only an Inspector IO payload has a response delivery")
- .io_response_delivery()
+ self.envelope.response()
}
pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {
@@ -130,6 +118,11 @@ pub struct RendererRuntimeInspectorIoCommandRoute {
command_id: u64,
ticket: RendererInspectorIngressTicket,
first_dispatch_rx: Option<RendererInspectorIoFirstDispatchReceiver>,
+ session_response_settlement_rx: Option<
+ tokio::sync::oneshot::Receiver<
+ crate::runtime::RendererRuntimeInspectorSessionResponseSettlement,
+ >,
+ >,
ingress: RendererInspectorIoIngress,
}
@@ -145,11 +138,66 @@ impl RendererRuntimeInspectorIoCommandRoute {
pub async fn wait_for_first_dispatch(
mut self,
) -> Result<RendererRuntimeInspectorIoCommandClaim, &'static str> {
- self.first_dispatch_rx
+ let claim = match self
+ .first_dispatch_rx
.take()
.expect("runtime Inspector IO first dispatch should only be awaited once")
.await
- .map_err(|_| "runtime Inspector IO first-dispatch channel closed")
+ {
+ Ok(claim) => claim,
+ Err(_) => {
+ let Some(session_response_settlement_rx) =
+ self.session_response_settlement_rx.take()
+ else {
+ return Err("runtime Inspector IO first-dispatch channel closed");
+ };
+ let (predecessor, response_succeeded) = session_response_settlement_rx
+ .await
+ .map_err(|_| "runtime Inspector IO first-dispatch channel closed")?
+ .into_parts();
+ return Ok(RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ predecessor,
+ response_succeeded,
+ });
+ }
+ };
+ match claim {
+ RendererRuntimeInspectorIoCommandClaim::Dispatched => {
+ let Some(session_response_settlement_rx) =
+ self.session_response_settlement_rx.take()
+ else {
+ return Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched);
+ };
+ let (predecessor, response_succeeded) = session_response_settlement_rx
+ .await
+ .map_err(|_| "runtime Inspector IO session response was not published")?
+ .into_parts();
+ Ok(RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ predecessor,
+ response_succeeded,
+ })
+ }
+ RendererRuntimeInspectorIoCommandClaim::Canceled(message) => {
+ let Some(session_response_settlement_rx) =
+ self.session_response_settlement_rx.take()
+ else {
+ return Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(message));
+ };
+ match session_response_settlement_rx.await {
+ Ok(settlement) => {
+ let (predecessor, response_succeeded) = settlement.into_parts();
+ Ok(RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ predecessor,
+ response_succeeded,
+ })
+ }
+ Err(_) => Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(message)),
+ }
+ }
+ response @ RendererRuntimeInspectorIoCommandClaim::SessionResponse { .. } => {
+ Ok(response)
+ }
+ }
}
}
@@ -223,6 +271,8 @@ impl RendererInspectorIoState {
}
}
+/// Owns the target IO task slot only until the command reaches its executor.
+/// A later interrupt command must not wait for an asynchronous response.
pub(crate) struct RendererInspectorIoFirstDispatchGuard {
ingress: RendererInspectorIoIngress,
active_command_id: Option<u64>,
@@ -236,13 +286,18 @@ pub(crate) struct RendererInspectorIoPostDispatchWakeGuard {
impl Drop for RendererInspectorIoFirstDispatchGuard {
fn drop(&mut self) {
- self.release();
+ let has_ready = self.finish_task(RendererRuntimeInspectorIoCommandClaim::Canceled(
+ "Inspector IO command was abandoned before first dispatch".to_owned(),
+ ));
+ if has_ready {
+ self.ingress.notify_execution_opportunities();
+ }
}
}
impl RendererInspectorIoFirstDispatchGuard {
pub(crate) fn release(&mut self) {
- let has_ready = self.release_task();
+ let has_ready = self.finish_task(RendererRuntimeInspectorIoCommandClaim::Dispatched);
if has_ready {
self.ingress.notify_execution_opportunities();
}
@@ -253,13 +308,22 @@ impl RendererInspectorIoFirstDispatchGuard {
/// from this dispatch. V8 may enter a nested debugger loop before the call
/// returns, so the command's ingress lifecycle must already be settled.
pub(crate) fn release_for_dispatch(&mut self) -> RendererInspectorIoPostDispatchWakeGuard {
- let has_ready = self.release_task();
+ let has_ready = self.finish_task(RendererRuntimeInspectorIoCommandClaim::Dispatched);
RendererInspectorIoPostDispatchWakeGuard {
ingress: has_ready.then(|| self.ingress.clone()),
}
}
- fn release_task(&mut self) -> bool {
+ pub(crate) fn reject(&mut self, message: impl Into<String>) {
+ let has_ready = self.finish_task(RendererRuntimeInspectorIoCommandClaim::Canceled(
+ message.into(),
+ ));
+ if has_ready {
+ self.ingress.notify_execution_opportunities();
+ }
+ }
+
+ fn finish_task(&mut self, claim: RendererRuntimeInspectorIoCommandClaim) -> bool {
let Some(command_id) = self.active_command_id.take() else {
return false;
};
@@ -271,7 +335,7 @@ impl RendererInspectorIoFirstDispatchGuard {
}
let has_ready = self.ingress.finish_first_dispatch(command_id);
if let Some(first_dispatch_tx) = self.first_dispatch_tx.take() {
- let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Dispatched);
+ let _ = first_dispatch_tx.send(claim);
}
has_ready
}
@@ -365,6 +429,9 @@ impl RendererInspectorIoIngress {
RendererDevToolsSessionLaneKey::new(agent_token, envelope.ticket().session().clone());
let mut state = self.shared.state.lock();
let (first_dispatch_tx, first_dispatch_rx) = tokio::sync::oneshot::channel();
+ let session_response_settlement_rx = envelope.response().and_then(
+ RendererRuntimeInspectorResponseSender::take_session_response_settlement_receiver,
+ );
let ticket = envelope.ticket().clone();
let command_id = ticket.sequence();
let command = RendererInspectorIoCommand {
@@ -392,6 +459,7 @@ impl RendererInspectorIoIngress {
command_id,
ticket,
first_dispatch_rx: Some(first_dispatch_rx),
+ session_response_settlement_rx,
ingress: self.clone(),
}
}
@@ -451,10 +519,6 @@ impl RendererInspectorIoIngress {
command: &mut RendererInspectorIoCommand,
) -> RendererInspectorIoFirstDispatchGuard {
let state = self.shared.state.lock();
- assert_eq!(
- command.first_dispatch_lifecycle(),
- crate::runtime::RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
- );
assert_eq!(
state.active_command_id,
Some(command.command_id),
@@ -614,19 +678,10 @@ impl std::fmt::Debug for RendererInspectorIoIngress {
fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {
if let Some(first_dispatch_tx) = command.first_dispatch_tx.take() {
- let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled);
+ let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled(
+ message.to_owned(),
+ ));
}
- let Some(response) = command.take_response() else {
- return;
- };
- let call_id = response.call_id();
- let _ = response.send(json!({
- "id": call_id,
- "error": {
- "code": -32000,
- "message": message,
- },
- }));
}
#[cfg(test)]
@@ -634,7 +689,13 @@ mod tests {
use super::*;
use crate::{
devtools::pause::RendererInspectorPauseBridge,
- runtime::{RendererInspectorCommandEnvelope, RendererInspectorIngressTicket},
+ runtime::{
+ RendererDevToolsSessionOutputHost, RendererInspectorCommandEnvelope,
+ RendererInspectorIngressTicket, RendererOutputStreamIdentity,
+ RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage,
+ RendererRuntimeInspectorResponseChannel, RendererTurnOutputJournal,
+ renderer_output_transport_channel,
+ },
};
fn ingress() -> RendererInspectorIoIngress {
@@ -658,7 +719,6 @@ mod tests {
),
raw_json.to_owned(),
None,
- moli_page_types::RendererInspectorResponseDelivery::CommandReply,
)),
)
}
@@ -671,6 +731,18 @@ mod tests {
)
}
+ fn session_response_output(
+ call_id: i32,
+ result: serde_json::Value,
+ ) -> RendererRuntimeCommandOutput {
+ RendererRuntimeCommandOutput::from_inspector_message(
+ RendererRuntimeInspectorMessage::protocol(serde_json::json!({
+ "id": call_id,
+ "result": result,
+ })),
+ )
+ }
+
#[test]
fn owner_interrupt_and_pause_race_can_claim_one_command_only_once() {
let ingress = ingress();
@@ -818,6 +890,148 @@ mod tests {
drop(first);
}
+ #[tokio::test]
+ async fn dispatched_io_route_completes_from_its_session_response() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let attachment = moli_page_types::RendererAgentAttachmentId::allocate();
+ let session = DevToolsSessionKey::Attached("session-output".to_owned());
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(response_rx.is_none());
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(
+ crate::runtime::PageId::new_for_testing(31),
+ );
+ let (transport, _transport_rx) = renderer_output_transport_channel();
+ let response = channel
+ .activate_sender(31, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session.clone(),
+ attachment,
+ RendererTurnOutputJournal::new_with_transport(stream, transport),
+ ));
+ let publisher = response.clone();
+ let route = ingress.enqueue_command(
+ agent,
+ RendererDevToolsIoCommandEnvelope::inspector(RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ session.wire_session_id().map(str::to_owned),
+ RendererInspectorCommandRoute::Io,
+ ),
+ r#"{"id":31,"method":"Debugger.getScriptSource","params":{"scriptId":"1"}}"#
+ .to_owned(),
+ Some(response),
+ )),
+ );
+ let mut command = ingress
+ .claim_for_interrupt()
+ .expect("the IO command must reach first dispatch");
+ ingress.first_dispatch_guard(&mut command).release();
+ publisher
+ .send_output(session_response_output(
+ 31,
+ serde_json::json!({"scriptSource": "source"}),
+ ))
+ .expect("the session response must publish");
+
+ assert!(matches!(
+ route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ response_succeeded: true,
+ ..
+ })
+ ));
+ }
+
+ #[tokio::test]
+ async fn canceled_io_route_accepts_a_replayed_session_response() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let attachment = moli_page_types::RendererAgentAttachmentId::allocate();
+ let session = DevToolsSessionKey::Attached("session-replayed-output".to_owned());
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(response_rx.is_none());
+ let original_response = channel.activate_sender(32, Some(attachment));
+ let route = ingress.enqueue_command(
+ agent,
+ RendererDevToolsIoCommandEnvelope::inspector(RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ session.wire_session_id().map(str::to_owned),
+ RendererInspectorCommandRoute::Io,
+ ),
+ r#"{"id":32,"method":"Debugger.getScriptSource","params":{"scriptId":"2"}}"#
+ .to_owned(),
+ Some(original_response),
+ )),
+ );
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(
+ crate::runtime::PageId::new_for_testing(32),
+ );
+ let (transport, _transport_rx) = renderer_output_transport_channel();
+ let replayed_response = channel
+ .activate_sender(33, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session,
+ attachment,
+ RendererTurnOutputJournal::new_with_transport(stream, transport),
+ ));
+
+ ingress.close("old attachment closed");
+ replayed_response
+ .send_output(session_response_output(
+ 33,
+ serde_json::json!({"scriptSource": "replacement"}),
+ ))
+ .expect("the replayed session response must publish");
+
+ assert!(matches!(
+ route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::SessionResponse {
+ response_succeeded: true,
+ ..
+ })
+ ));
+ }
+
+ #[tokio::test]
+ async fn canceled_io_route_keeps_cancellation_when_session_replay_closes() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let attachment = moli_page_types::RendererAgentAttachmentId::allocate();
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(response_rx.is_none());
+ let route = ingress.enqueue_command(
+ agent,
+ RendererDevToolsIoCommandEnvelope::inspector(RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ Some("session-canceled-output".to_owned()),
+ RendererInspectorCommandRoute::Io,
+ ),
+ r#"{"id":34,"method":"Debugger.getScriptSource","params":{"scriptId":"3"}}"#
+ .to_owned(),
+ Some(channel.activate_sender(34, Some(attachment))),
+ )),
+ );
+
+ ingress.close("attachment closed before replay");
+
+ assert!(matches!(
+ route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(message))
+ if message == "attachment closed before replay"
+ ));
+ }
+
#[tokio::test]
async fn target_fifo_orders_inspector_performance_and_emulation_first_dispatch() {
let ingress = ingress();
@@ -899,6 +1113,33 @@ mod tests {
);
}
+ #[tokio::test]
+ async fn claimed_io_rejection_preserves_error_and_releases_target_fifo() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let rejected = enqueue(&ingress, agent, Some("session-reject"), "rejected");
+ let _following = enqueue(&ingress, agent, Some("session-reject"), "following");
+ let mut command = ingress
+ .claim_for_owner()
+ .expect("the first IO command should be claimable");
+ assert!(
+ ingress.claim_for_pause().is_none(),
+ "the target FIFO must remain occupied until rejection is published"
+ );
+ let mut first_dispatch = ingress.first_dispatch_guard(&mut command);
+ first_dispatch.reject("Inspector session is not available");
+
+ assert!(matches!(
+ rejected.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(message))
+ if message == "Inspector session is not available"
+ ));
+ assert!(
+ ingress.claim_for_pause().is_some(),
+ "rejecting the active command must release the next target task"
+ );
+ }
+
#[tokio::test]
async fn detach_cancels_all_queued_commands_while_active_first_dispatch_retires_safely() {
let ingress = ingress();
@@ -920,9 +1161,11 @@ mod tests {
ingress.detach_session(agent, &DevToolsSessionKey::Attached("session-a".to_owned()));
for (index, route) in routes.into_iter().enumerate() {
- assert_eq!(
- route.wait_for_first_dispatch().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
+ assert!(
+ matches!(
+ route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))
+ ),
"detach must cancel queued command {}",
index + 1
);
@@ -961,9 +1204,11 @@ mod tests {
ingress.close("test target closed");
for route in [a2_route, b1_route, b2_route] {
- assert_eq!(
- route.wait_for_first_dispatch().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
+ assert!(
+ matches!(
+ route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))
+ ),
"close must cancel every unclaimed session command"
);
}
@@ -980,9 +1225,11 @@ mod tests {
);
let late = enqueue(&ingress, agent, Some("session-late"), "late");
- assert_eq!(
- late.wait_for_first_dispatch().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
+ assert!(
+ matches!(
+ late.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))
+ ),
"a closed target must reject late IO ingress"
);
}
diff --git a/moli-renderer-v8/src/devtools/ingress/lane.rs b/moli-renderer-v8/src/devtools/ingress/lane.rs
index 8fc2732cc..61b7c2fc6 100644
--- a/moli-renderer-v8/src/devtools/ingress/lane.rs
+++ b/moli-renderer-v8/src/devtools/ingress/lane.rs
@@ -47,11 +47,12 @@ impl<C> Default for RendererDevToolsSessionLane<C> {
}
}
-/// Route-local per-session admission state.
+/// Main-receiver admission state for all frontend sessions on one target.
///
-/// Main and IO each own a distinct instance under a distinct mutex. Sharing
-/// this implementation keeps their FIFO, cancellation and first-dispatch
-/// invariants aligned without creating a shared cross-route queue.
+/// Chromium gives each session its own ordered Main receiver. The active slot
+/// ends when a command first reaches the target agent; asynchronous response
+/// completion is deliberately outside that lifetime so a later resume command
+/// can enter a nested pause loop.
pub(crate) struct RendererDevToolsSessionLanes<C> {
sessions: BTreeMap<RendererDevToolsSessionLaneKey, RendererDevToolsSessionLane<C>>,
ready_sessions: VecDeque<RendererDevToolsSessionLaneKey>,
diff --git a/moli-renderer-v8/src/devtools/ingress/main.rs b/moli-renderer-v8/src/devtools/ingress/main.rs
index f029fdbaa..f37f3410b 100644
--- a/moli-renderer-v8/src/devtools/ingress/main.rs
+++ b/moli-renderer-v8/src/devtools/ingress/main.rs
@@ -5,7 +5,6 @@ use std::sync::{
use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};
use parking_lot::Mutex;
-use serde_json::json;
use crate::{
devtools::{
@@ -23,6 +22,7 @@ use crate::{
RendererInspectorCommandRoute, RendererInspectorIngressTicket,
RendererInspectorPauseCommandEffect, RendererOwnerReply, RendererPageCommand,
RendererPageStateCapturePolicy, RendererPageToken, RendererRuntimeInspectorResponseSender,
+ RendererRuntimeInspectorSessionResponseSettlement,
},
};
@@ -32,19 +32,28 @@ pub(crate) enum RendererInspectorMainCommandConsumer {
Pause,
}
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
enum RendererInspectorMainCommandClaim {
Owner,
Inspector,
Page,
- Canceled,
+ Canceled(String),
}
pub enum RendererRuntimeInspectorMainCommandCompletion {
Owner(Box<RendererCommandTurnOutput>),
+ OwnerSessionResponse {
+ output: Box<RendererCommandTurnOutput>,
+ response_succeeded: bool,
+ },
+ OwnerSessionErrorSettled(crate::runtime::RendererOutputFence),
Inspector,
+ InspectorSessionResponse {
+ predecessor: crate::runtime::RendererOutputFence,
+ response_succeeded: bool,
+ },
Page(Box<RendererCommandTurnOutput>),
- Canceled,
+ Canceled(String),
}
pub(crate) struct RendererInspectorMainCommand {
@@ -67,12 +76,6 @@ impl RendererInspectorMainCommand {
self.envelope.ticket()
}
- pub(crate) fn first_dispatch_lifecycle(
- &self,
- ) -> crate::runtime::RendererInspectorFirstDispatchLifecycle {
- self.envelope.first_dispatch_lifecycle()
- }
-
#[cfg(test)]
pub(crate) fn raw_json(&self) -> &str {
self.envelope
@@ -95,15 +98,6 @@ impl RendererInspectorMainCommand {
.pause_effect()
}
- pub(crate) fn inspector_response_delivery(
- &self,
- ) -> moli_page_types::RendererInspectorResponseDelivery {
- self.envelope
- .inspector_envelope()
- .expect("an Inspector response delivery requires an Inspector payload")
- .inspector_response_delivery()
- }
-
pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {
self.envelope.nested_dispatch()
}
@@ -151,6 +145,8 @@ pub struct RendererRuntimeInspectorMainCommandRoute {
ticket: RendererInspectorIngressTicket,
claim_rx: Option<tokio::sync::oneshot::Receiver<RendererInspectorMainCommandClaim>>,
owner_reply_rx: Option<tokio::sync::oneshot::Receiver<anyhow::Result<RendererOwnerReply>>>,
+ session_response_settlement_rx:
+ Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>>,
ingress: RendererInspectorMainIngress,
}
@@ -162,33 +158,87 @@ impl RendererRuntimeInspectorMainCommandRoute {
pub async fn wait_for_completion(
mut self,
) -> anyhow::Result<RendererRuntimeInspectorMainCommandCompletion> {
- let claim = self
+ let claim = match 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"))?;
+ {
+ Ok(claim) => claim,
+ Err(_) => {
+ if let Some(completion) = self.take_replayed_session_response().await {
+ return Ok(completion);
+ }
+ return Err(anyhow::anyhow!(
+ "runtime inspector Main command claim channel closed"
+ ));
+ }
+ };
match claim {
RendererInspectorMainCommandClaim::Owner => {
- let reply = self
+ let reply = match 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")
- })??;
+ {
+ Ok(Ok(reply)) => reply,
+ Ok(Err(error)) => {
+ if let Some(completion) = self.take_replayed_session_response().await {
+ return Ok(completion);
+ }
+ return Err(error);
+ }
+ Err(_) => {
+ if let Some(completion) = self.take_replayed_session_response().await {
+ return Ok(completion);
+ }
+ return Err(anyhow::anyhow!(
+ "runtime inspector Main owner reply channel closed"
+ ));
+ }
+ };
match reply {
RendererOwnerReply::AsyncPageCommandRan(output) => {
Ok(RendererRuntimeInspectorMainCommandCompletion::Owner(output))
}
+ RendererOwnerReply::RuntimeInspectorSessionResponseSettled {
+ output,
+ response_succeeded,
+ } => Ok(
+ RendererRuntimeInspectorMainCommandCompletion::OwnerSessionResponse {
+ output,
+ response_succeeded,
+ },
+ ),
+ RendererOwnerReply::RuntimeInspectorSessionErrorSettled(predecessor) => Ok(
+ RendererRuntimeInspectorMainCommandCompletion::OwnerSessionErrorSettled(
+ predecessor,
+ ),
+ ),
_ => Err(anyhow::anyhow!(
"runtime inspector Main owner returned an unexpected renderer reply"
)),
}
}
RendererInspectorMainCommandClaim::Inspector => {
- Ok(RendererRuntimeInspectorMainCommandCompletion::Inspector)
+ let Some(session_response_settlement_rx) =
+ self.session_response_settlement_rx.take()
+ else {
+ return Ok(RendererRuntimeInspectorMainCommandCompletion::Inspector);
+ };
+ let (predecessor, response_succeeded) = session_response_settlement_rx
+ .await
+ .map_err(|_| {
+ anyhow::anyhow!("runtime Inspector Main session response was not published")
+ })?
+ .into_parts();
+ Ok(
+ RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ predecessor,
+ response_succeeded,
+ },
+ )
}
RendererInspectorMainCommandClaim::Page => {
let reply = self
@@ -206,11 +256,34 @@ impl RendererRuntimeInspectorMainCommandRoute {
)),
}
}
- RendererInspectorMainCommandClaim::Canceled => {
- Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)
+ RendererInspectorMainCommandClaim::Canceled(message) => {
+ if let Some(completion) = self.take_replayed_session_response().await {
+ Ok(completion)
+ } else {
+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled(
+ message,
+ ))
+ }
}
}
}
+
+ async fn take_replayed_session_response(
+ &mut self,
+ ) -> Option<RendererRuntimeInspectorMainCommandCompletion> {
+ let (predecessor, response_succeeded) = self
+ .session_response_settlement_rx
+ .take()?
+ .await
+ .ok()?
+ .into_parts();
+ Some(
+ RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ predecessor,
+ response_succeeded,
+ },
+ )
+ }
}
impl Drop for RendererRuntimeInspectorMainCommandRoute {
@@ -253,6 +326,7 @@ struct RendererInspectorMainState {
pub(crate) struct RendererInspectorMainFirstDispatchGuard {
ingress: RendererInspectorMainIngress,
active: Option<(RendererDevToolsSessionLaneKey, u64)>,
+ claim_tx: Option<tokio::sync::oneshot::Sender<RendererInspectorMainCommandClaim>>,
}
pub(crate) struct RendererInspectorMainPostDispatchWakeGuard {
@@ -289,24 +363,48 @@ impl RendererInspectorMainOwnerDispatch {
impl Drop for RendererInspectorMainFirstDispatchGuard {
fn drop(&mut self) {
- self.release();
+ if let Some(claim_tx) = self.claim_tx.take() {
+ let _ = claim_tx.send(RendererInspectorMainCommandClaim::Canceled(
+ "Inspector Main command was abandoned before first dispatch".to_owned(),
+ ));
+ }
+ if self.release_lane() {
+ self.ingress.notify_execution_opportunities();
+ }
}
}
impl RendererInspectorMainFirstDispatchGuard {
pub(crate) fn release(&mut self) {
+ self.publish_first_dispatch();
if self.release_lane() {
self.ingress.notify_execution_opportunities();
}
}
pub(crate) fn release_for_dispatch(&mut self) -> RendererInspectorMainPostDispatchWakeGuard {
+ self.publish_first_dispatch();
let has_ready = self.release_lane();
RendererInspectorMainPostDispatchWakeGuard {
ingress: has_ready.then(|| self.ingress.clone()),
}
}
+ pub(crate) fn reject(&mut self, message: impl Into<String>) {
+ if let Some(claim_tx) = self.claim_tx.take() {
+ let _ = claim_tx.send(RendererInspectorMainCommandClaim::Canceled(message.into()));
+ }
+ if self.release_lane() {
+ self.ingress.notify_execution_opportunities();
+ }
+ }
+
+ fn publish_first_dispatch(&mut self) {
+ if let Some(claim_tx) = self.claim_tx.take() {
+ let _ = claim_tx.send(RendererInspectorMainCommandClaim::Inspector);
+ }
+ }
+
fn release_lane(&mut self) -> bool {
let Some((lane, command_id)) = self.active.take() else {
return false;
@@ -418,6 +516,9 @@ impl RendererInspectorMainIngress {
);
let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();
let (owner_reply_tx, owner_reply_rx) = tokio::sync::oneshot::channel();
+ let session_response_settlement_rx = envelope.response().and_then(
+ RendererRuntimeInspectorResponseSender::take_session_response_settlement_receiver,
+ );
let mut state = self.shared.state.lock();
let lane_key =
RendererDevToolsSessionLaneKey::new(agent_token, envelope.ticket().session().clone());
@@ -452,6 +553,7 @@ impl RendererInspectorMainIngress {
ticket,
claim_rx: Some(claim_rx),
owner_reply_rx: Some(owner_reply_rx),
+ session_response_settlement_rx,
ingress: self.clone(),
}
}
@@ -479,23 +581,23 @@ impl RendererInspectorMainIngress {
|| command.nested_dispatch() != RendererDevToolsMainNestedDispatch::OwnerOnly
})?;
command.claimed_by = Some(consumer);
- if let Some(claim_tx) = command.claim_tx.take() {
- let claim = match consumer {
- RendererInspectorMainCommandConsumer::Owner => {
- RendererInspectorMainCommandClaim::Owner
+ let claim = match consumer {
+ RendererInspectorMainCommandConsumer::Owner => {
+ Some(RendererInspectorMainCommandClaim::Owner)
+ }
+ RendererInspectorMainCommandConsumer::Pause => match command.nested_dispatch() {
+ RendererDevToolsMainNestedDispatch::InspectorSession => None,
+ RendererDevToolsMainNestedDispatch::PageAgent => {
+ Some(RendererInspectorMainCommandClaim::Page)
}
- RendererInspectorMainCommandConsumer::Pause => match command.nested_dispatch() {
- RendererDevToolsMainNestedDispatch::InspectorSession => {
- RendererInspectorMainCommandClaim::Inspector
- }
- RendererDevToolsMainNestedDispatch::PageAgent => {
- RendererInspectorMainCommandClaim::Page
- }
- RendererDevToolsMainNestedDispatch::OwnerOnly => {
- unreachable!("owner-only commands are skipped by pause claim")
- }
- },
- };
+ RendererDevToolsMainNestedDispatch::OwnerOnly => {
+ unreachable!("owner-only commands are skipped by pause claim")
+ }
+ },
+ };
+ if let Some(claim) = claim
+ && let Some(claim_tx) = command.claim_tx.take()
+ {
let _ = claim_tx.send(claim);
}
if consumer == RendererInspectorMainCommandConsumer::Pause
@@ -508,17 +610,13 @@ impl RendererInspectorMainIngress {
pub(crate) fn first_dispatch_guard(
&self,
- command: &RendererInspectorMainCommand,
+ command: &mut RendererInspectorMainCommand,
) -> RendererInspectorMainFirstDispatchGuard {
let lane_key = RendererDevToolsSessionLaneKey::new(
command.agent_token,
command.ticket().session().clone(),
);
let state = self.shared.state.lock();
- assert_eq!(
- command.first_dispatch_lifecycle(),
- crate::runtime::RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
- );
state.lanes.assert_active(
&lane_key,
command.command_id,
@@ -528,6 +626,7 @@ impl RendererInspectorMainIngress {
RendererInspectorMainFirstDispatchGuard {
ingress: self.clone(),
active: Some((lane_key, command.command_id)),
+ claim_tx: command.claim_tx.take(),
}
}
@@ -540,7 +639,8 @@ impl RendererInspectorMainIngress {
Some(RendererInspectorMainCommandConsumer::Owner),
"only an owner-claimed Main command can enter a Page owner turn"
);
- let first_dispatch = self.first_dispatch_guard(&command);
+ let mut command = command;
+ let first_dispatch = self.first_dispatch_guard(&mut command);
let RendererInspectorMainCommand {
page_token,
capture_policy,
@@ -634,26 +734,14 @@ fn fail_main_command(command: RendererInspectorMainCommand, message: &str) {
..
} = command;
if let Some(claim_tx) = claim_tx {
- let _ = claim_tx.send(RendererInspectorMainCommandClaim::Canceled);
+ let _ = claim_tx.send(RendererInspectorMainCommandClaim::Canceled(
+ message.to_owned(),
+ ));
}
if let Some(owner_reply_tx) = owner_reply_tx {
let _ = owner_reply_tx.send(Err(anyhow::anyhow!(message.to_owned())));
}
- let Some(envelope) = envelope.into_inspector_envelope() else {
- return;
- };
- if !envelope.is_main_protocol_command_with_deferred_response() {
- return;
- }
- 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,
- },
- }));
+ drop(envelope);
}
impl std::fmt::Debug for RendererInspectorMainIngress {
@@ -675,9 +763,12 @@ mod tests {
use crate::{
devtools::pause::RendererInspectorPauseBridge,
runtime::{
- RendererInspectorIngressTicket, RendererPageReply, RendererPageState,
+ RendererDevToolsSessionOutputHost, RendererInspectorIngressTicket,
+ RendererOutputStreamIdentity, RendererPageReply, RendererPageState,
RendererPerformanceMetricSnapshot, RendererRuntimeCommandOutput,
- RendererRuntimeInspectorAsyncCompletion,
+ RendererRuntimeInspectorAsyncCompletion, RendererRuntimeInspectorMessage,
+ RendererRuntimeInspectorResponseChannel, RendererTurnOutputJournal,
+ renderer_output_transport_channel,
},
types::ScriptExecutionReport,
};
@@ -740,7 +831,6 @@ mod tests {
action.map(str::to_owned),
raw_json.to_owned(),
RendererRuntimeInspectorResponseSender::new(1, response_tx),
- moli_page_types::RendererInspectorResponseDelivery::CommandReply,
),
)
}
@@ -791,7 +881,7 @@ mod tests {
r#"{"id":3,"method":"Runtime.getProperties","params":{"objectId":"b1"}}"#,
);
- let first = ingress.claim_for_owner().expect("first ready Main session");
+ let mut first = ingress.claim_for_owner().expect("first ready Main session");
assert!(first.raw_json().contains(r#""a1""#));
let second = ingress
.claim_for_pause()
@@ -799,7 +889,7 @@ mod tests {
assert!(second.raw_json().contains(r#""b1""#));
assert!(ingress.claim_for_owner().is_none());
- ingress.first_dispatch_guard(&first).release();
+ ingress.first_dispatch_guard(&mut first).release();
let third = ingress.claim_for_pause().expect("a2 after a1 dispatch");
assert!(third.raw_json().contains(r#""a2""#));
}
@@ -820,10 +910,10 @@ mod tests {
Some("session-detaching"),
r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"queued"}}"#,
);
- let active = ingress
+ let mut active = ingress
.claim_for_owner()
.expect("the session head should become active");
- let mut first_dispatch = ingress.first_dispatch_guard(&active);
+ let mut first_dispatch = ingress.first_dispatch_guard(&mut active);
ingress.detach_session(
agent,
@@ -831,7 +921,7 @@ mod tests {
);
assert!(matches!(
queued_route.wait_for_completion().await,
- Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)
+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled(_))
));
let late_route = enqueue(
@@ -842,7 +932,7 @@ mod tests {
);
assert!(matches!(
late_route.wait_for_completion().await,
- Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)
+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled(_))
));
first_dispatch.release();
@@ -863,6 +953,171 @@ mod tests {
);
}
+ #[tokio::test]
+ async fn direct_inspector_rejection_reports_error_before_releasing_next_main_command() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let rejected = enqueue(
+ &ingress,
+ agent,
+ Some("session-reject"),
+ r#"{"id":1,"method":"Runtime.getProperties","params":{"objectId":"missing"}}"#,
+ );
+ let _following = enqueue(
+ &ingress,
+ agent,
+ Some("session-reject"),
+ r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"next"}}"#,
+ );
+ let mut command = ingress
+ .claim_for_pause()
+ .expect("the direct Inspector command should be claimable");
+ assert!(
+ ingress.claim_for_owner().is_none(),
+ "the following command must remain behind the unresolved first-dispatch boundary"
+ );
+ let mut first_dispatch = ingress.first_dispatch_guard(&mut command);
+ first_dispatch.reject("Inspector session is not available");
+
+ assert!(matches!(
+ rejected.wait_for_completion().await,
+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled(message))
+ if message == "Inspector session is not available"
+ ));
+ assert!(
+ ingress.claim_for_owner().is_some(),
+ "rejecting first dispatch must release the next command in the same session"
+ );
+ }
+
+ #[tokio::test]
+ async fn claimed_owner_failure_waits_for_replacement_session_response() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let attachment = moli_page_types::RendererAgentAttachmentId::allocate();
+ let session = DevToolsSessionKey::Attached("session-replay".to_owned());
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(response_rx.is_none());
+ let old_response = channel.activate_sender(1, Some(attachment));
+ let route = ingress.enqueue_command(
+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(1)),
+ agent,
+ RendererInspectorCommandEnvelope::new_main_protocol(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ session.wire_session_id().map(str::to_owned),
+ RendererInspectorCommandRoute::MainThread,
+ ),
+ None,
+ r#"{"id":1,"method":"Runtime.evaluate","params":{"expression":"1"}}"#.to_owned(),
+ old_response,
+ ),
+ );
+ let claimed = ingress
+ .claim_for_owner()
+ .expect("the original command should be claimed by the owner");
+ let owner_dispatch = ingress.prepare_owner_dispatch(claimed);
+
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(
+ crate::runtime::PageId::new_for_testing(2),
+ );
+ let (transport, _transport_rx) = renderer_output_transport_channel();
+ let replacement_response = channel
+ .activate_sender(2, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session,
+ attachment,
+ RendererTurnOutputJournal::new_with_transport(stream, transport),
+ ));
+ drop(owner_dispatch);
+ replacement_response
+ .send_output(RendererRuntimeCommandOutput::from_inspector_message(
+ RendererRuntimeInspectorMessage::protocol(serde_json::json!({
+ "id": 2,
+ "result": {}
+ })),
+ ))
+ .expect("the replacement route should publish the terminal response");
+
+ assert!(matches!(
+ route.wait_for_completion().await,
+ Ok(
+ RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ response_succeeded: true,
+ ..
+ }
+ )
+ ));
+ }
+
+ #[tokio::test]
+ async fn direct_inspector_error_completes_from_the_session_response() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let attachment = moli_page_types::RendererAgentAttachmentId::allocate();
+ let session = DevToolsSessionKey::Attached("session-direct-error".to_owned());
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(response_rx.is_none());
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(
+ crate::runtime::PageId::new_for_testing(35),
+ );
+ let (transport, _transport_rx) = renderer_output_transport_channel();
+ let response = channel
+ .activate_sender(35, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session.clone(),
+ attachment,
+ RendererTurnOutputJournal::new_with_transport(stream, transport),
+ ));
+ let publisher = response.clone();
+ let route = ingress.enqueue_command(
+ RendererPageToken::new_for_testing(crate::runtime::PageId::new_for_testing(35)),
+ agent,
+ RendererInspectorCommandEnvelope::new_main_protocol(
+ RendererInspectorIngressTicket::new(
+ Some(attachment),
+ session.wire_session_id().map(str::to_owned),
+ RendererInspectorCommandRoute::MainThread,
+ ),
+ None,
+ r#"{"id":35,"method":"Runtime.getProperties","params":{"objectId":"missing"}}"#
+ .to_owned(),
+ response,
+ ),
+ );
+ let mut command = ingress
+ .claim_for_pause()
+ .expect("the direct Inspector command must reach nested Main");
+ ingress.first_dispatch_guard(&mut command).release();
+ publisher
+ .send_output(RendererRuntimeCommandOutput::from_inspector_message(
+ RendererRuntimeInspectorMessage::protocol(serde_json::json!({
+ "id": 35,
+ "error": {
+ "code": -32000,
+ "message": "Cannot find object with given id",
+ },
+ })),
+ ))
+ .expect("the direct Inspector error must publish");
+
+ assert!(matches!(
+ route.wait_for_completion().await,
+ Ok(
+ RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ response_succeeded: false,
+ ..
+ }
+ )
+ ));
+ }
+
#[test]
fn mixed_v8_and_page_agents_share_one_main_session_lane() {
let ingress = ingress();
@@ -883,7 +1138,7 @@ mod tests {
r#"{"id":2,"method":"Runtime.getProperties","params":{"objectId":"v8"}}"#,
);
- let page = ingress
+ let mut page = ingress
.claim_for_pause()
.expect("the Page agent command should be first");
assert_eq!(
@@ -903,7 +1158,7 @@ mod tests {
None,
)
.expect("test Page-agent output")
- .hold_until_protocol_handoff(ingress.first_dispatch_guard(&page));
+ .hold_until_protocol_handoff(ingress.first_dispatch_guard(&mut page));
assert!(
ingress.claim_for_pause().is_none(),
"settled Page output must retain the lane until protocol consumes it"
@@ -993,7 +1248,6 @@ mod tests {
RendererInspectorIngressTicket::new(None, None, RendererInspectorCommandRoute::Io),
r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),
None,
- moli_page_types::RendererInspectorResponseDelivery::CommandReply,
),
);
}
diff --git a/moli-renderer-v8/src/devtools/pause/tests.rs b/moli-renderer-v8/src/devtools/pause/tests.rs
index c8fe3349a..c1eac790c 100644
--- a/moli-renderer-v8/src/devtools/pause/tests.rs
+++ b/moli-renderer-v8/src/devtools/pause/tests.rs
@@ -63,7 +63,6 @@ fn enqueue_command(
),
raw_json,
Some(response),
- moli_page_types::RendererInspectorResponseDelivery::CommandReply,
),
),
)
@@ -446,16 +445,9 @@ async fn dropping_io_route_cancels_the_unclaimed_command() {
io_ingress.claim_for_owner().is_none(),
"a canceled frontend route must remove its queued IO command"
);
- let completion = response_rx
- .await
- .expect("route cancellation should explicitly fail the deferred response");
- let response = completion
- .output
- .protocol_response(8)
- .expect("route cancellation response");
- assert_eq!(
- response["error"]["message"],
- json!("Runtime inspector IO route was canceled before dispatch")
+ assert!(
+ response_rx.await.is_err(),
+ "abandoning the frontend route must close its obsolete command-reply capability"
);
}
diff --git a/moli-renderer-v8/src/devtools/target.rs b/moli-renderer-v8/src/devtools/target.rs
index df75c3537..9c624ab6d 100644
--- a/moli-renderer-v8/src/devtools/target.rs
+++ b/moli-renderer-v8/src/devtools/target.rs
@@ -155,18 +155,17 @@ mod tests {
None,
r#"{"id":1,"method":"Runtime.evaluate"}"#.to_owned(),
RendererRuntimeInspectorResponseSender::new(1, response_tx),
- moli_page_types::RendererInspectorResponseDelivery::CommandReply,
),
);
target.crash_from_io();
- assert_eq!(
+ assert!(matches!(
io_route.wait_for_first_dispatch().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Canceled)
- );
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))
+ ));
assert!(matches!(
main_route.wait_for_completion().await,
- Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled)
+ Ok(RendererRuntimeInspectorMainCommandCompletion::Canceled(_))
));
let late = io.enqueue_command(
@@ -179,9 +178,11 @@ mod tests {
),
),
);
- assert_eq!(
- late.wait_for_first_dispatch().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
+ assert!(
+ matches!(
+ late.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Canceled(_))
+ ),
"terminal Page.crash must reject late ordinary IO work"
);
}
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index 8174c773d..c163ac0e5 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -253,14 +253,14 @@ pub use runtime::{
RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,
RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererFrameToken,
RendererGeometryQuad, RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,
- RendererInspectorCommandRoute, RendererInspectorFirstDispatchLifecycle,
- RendererInspectorIngressTicket, RendererInspectorProtocolConfiguration,
- RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,
- RendererJavaScriptDialogCompletion, RendererJavaScriptDialogId, RendererJavaScriptDialogResult,
- RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererLifecycleDecider,
- RendererLifecycleDecision, RendererLifecycleEpoch, RendererLifecycleEventStamp,
- RendererLifecycleSnapshot, RendererLifecycleStartReason, RendererLifecycleTerminationStamp,
- RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
+ RendererInspectorCommandRoute, RendererInspectorIngressTicket,
+ RendererInspectorProtocolConfiguration, RendererInspectorProtocolConfigurationCommand,
+ RendererInspectorSessionRestoreSnapshot, RendererJavaScriptDialogCompletion,
+ RendererJavaScriptDialogId, RendererJavaScriptDialogResult, RendererJavaScriptDialogSource,
+ RendererLayoutMetrics, RendererLifecycleDecider, RendererLifecycleDecision,
+ RendererLifecycleEpoch, RendererLifecycleEventStamp, RendererLifecycleSnapshot,
+ RendererLifecycleStartReason, RendererLifecycleTerminationStamp, RendererMainDocumentCommit,
+ RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics, RendererOutputCursor,
RendererOutputFence, RendererOutputFenceLeaseId, RendererOutputItem, RendererOutputPublication,
RendererOutputPublicationOrdering, RendererOutputRecord, RendererOutputResidenceIdentity,
diff --git a/moli-renderer-v8/src/page_task_queue/resource_completions.rs b/moli-renderer-v8/src/page_task_queue/resource_completions.rs
index aa748f74a..7b76205fa 100644
--- a/moli-renderer-v8/src/page_task_queue/resource_completions.rs
+++ b/moli-renderer-v8/src/page_task_queue/resource_completions.rs
@@ -406,7 +406,7 @@ impl RendererOwnerWakeSender {
else {
unreachable!("runtime response send must return its exact wake payload")
};
- publication.commit(None)
+ publication.commit(None).map(|_| ())
}
}
}
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index 3ef3d2520..5fdd81210 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -368,7 +368,8 @@ pub use self::page_surface::{
pub(crate) use self::page_surface::{
RendererCommandTurnOutputRecorder, RendererDevToolsSessionOutputHost,
RendererInspectorPageCommand, RendererRuntimeCommandOutputRecorder,
- RendererRuntimeInspectorResponsePublication, RendererRuntimeObservableSourceQueue,
+ RendererRuntimeCommandOutputSettlement, RendererRuntimeInspectorResponsePublication,
+ RendererRuntimeInspectorSessionResponseSettlement, RendererRuntimeObservableSourceQueue,
};
pub(crate) use self::page_vm::PageVm;
use self::page_vm::PageVmDropTracker;
@@ -413,7 +414,7 @@ pub use self::service_worker_run::RendererServiceWorkerRunIdentity;
pub use crate::devtools::command::{
RendererDevToolsIoCommandEnvelope, RendererDevToolsMainCommandEnvelope,
RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
- RendererInspectorFirstDispatchLifecycle, RendererInspectorIngressTicket,
+ RendererInspectorIngressTicket,
};
pub(crate) use crate::devtools::command::{
RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,
diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs
index 17510c786..929d93852 100644
--- a/moli-renderer-v8/src/runtime/owner.rs
+++ b/moli-renderer-v8/src/runtime/owner.rs
@@ -295,6 +295,11 @@ pub enum RendererOwnerReply {
PreparedRendererDocumentCommitConfigurationUpdated,
PreparedRendererDocumentCanceled,
AsyncPageCommandRan(Box<RendererCommandTurnOutput>),
+ RuntimeInspectorSessionResponseSettled {
+ output: Box<RendererCommandTurnOutput>,
+ response_succeeded: bool,
+ },
+ RuntimeInspectorSessionErrorSettled(RendererOutputFence),
RuntimeInspectorSessionDetachFinalized(bool),
PageRemoved,
TestingCurrentPageState(Arc<RendererPageState>),
@@ -4564,7 +4569,8 @@ impl RendererOwnerHandle {
post_response_continuation: Option<RendererPageCommandPostResponseContinuation>,
capture_policy: super::RendererPageStateCapturePolicy,
) -> RenderRuntimeDispatchOutcome {
- let runtime_command_output = entry.page_vm_mut().take_runtime_command_output();
+ let (runtime_command_output, runtime_session_response) =
+ entry.page_vm_mut().take_runtime_command_settlement();
let command_produced_records = !turn_records.is_empty();
entry.page_vm().append_renderer_output_records(turn_records);
let (mut entry, page_state_result) = commit_page_state_on_entry_via_local_task_with_policy(
@@ -4598,18 +4604,65 @@ impl RendererOwnerHandle {
if let Some(output) = concrete_output {
self.publish_renderer_output(output);
}
- match page_state_result {
+ let completion = match page_state_result {
Ok(page_state) => match RendererCommandTurnOutput::new(
reply,
page_state,
runtime_command_output,
post_response_continuation,
- renderer_output_predecessor,
+ renderer_output_predecessor.clone(),
) {
- Ok(output) => Ok(RendererOwnerReply::AsyncPageCommandRan(Box::new(output))).into(),
- Err(error) => Err(error).into(),
+ Ok(output) => Ok(output),
+ Err(error) => Err(error),
},
- Err(error) => Err(error).into(),
+ Err(error) => Err(error),
+ };
+ match (completion, runtime_session_response) {
+ (Ok(mut output), Some(publication)) => {
+ match publication.commit(renderer_output_predecessor) {
+ Ok(Some(settlement)) => {
+ let (response_predecessor, response_succeeded) = settlement.into_parts();
+ output.merge_renderer_output_predecessor(response_predecessor);
+ Ok(RendererOwnerReply::RuntimeInspectorSessionResponseSettled {
+ output: Box::new(output),
+ response_succeeded,
+ })
+ .into()
+ }
+ Ok(None) => unreachable!(
+ "a DevTools session publication must return its concrete response fence"
+ ),
+ Err(completion) => Err(anyhow!(
+ "Runtime response output closed before call {} was published",
+ completion.call_id
+ ))
+ .into(),
+ }
+ }
+ (Err(error), Some(publication)) => {
+ match publication.commit_error(error.to_string(), renderer_output_predecessor) {
+ Ok(Some(settlement)) => {
+ let (response_predecessor, response_succeeded) = settlement.into_parts();
+ debug_assert!(!response_succeeded);
+ Ok(RendererOwnerReply::RuntimeInspectorSessionErrorSettled(
+ response_predecessor,
+ ))
+ .into()
+ }
+ Ok(None) => unreachable!(
+ "a DevTools session publication must return its concrete response fence"
+ ),
+ Err(completion) => Err(anyhow!(
+ "Runtime error output closed before call {} was published",
+ completion.call_id
+ ))
+ .into(),
+ }
+ }
+ (Ok(output), None) => {
+ Ok(RendererOwnerReply::AsyncPageCommandRan(Box::new(output))).into()
+ }
+ (Err(error), None) => Err(error).into(),
}
}
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index 59f784ca6..e24e774b6 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -574,12 +574,23 @@ impl RendererPageCommandPending {
match route.wait_for_completion().await? {
RendererRuntimeInspectorMainCommandCompletion::Owner(output) => Ok(*output),
RendererRuntimeInspectorMainCommandCompletion::Page(output) => Ok(*output),
- RendererRuntimeInspectorMainCommandCompletion::Inspector => Err(anyhow!(
+ RendererRuntimeInspectorMainCommandCompletion::Inspector
+ | RendererRuntimeInspectorMainCommandCompletion::InspectorSessionResponse {
+ ..
+ } => Err(anyhow!(
"an owner-only Inspector Main command entered nested dispatch"
)),
- RendererRuntimeInspectorMainCommandCompletion::Canceled => Err(anyhow!(
- "Inspector Main command was canceled before owner dispatch"
+ RendererRuntimeInspectorMainCommandCompletion::OwnerSessionResponse {
+ ..
+ }
+ | RendererRuntimeInspectorMainCommandCompletion::OwnerSessionErrorSettled(
+ _,
+ ) => Err(anyhow!(
+ "an owner-only Page command settled a DevTools session response"
)),
+ RendererRuntimeInspectorMainCommandCompletion::Canceled(message) => {
+ Err(anyhow!(message))
+ }
}
}
}
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index 41efb2302..baf23c0f6 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -1171,7 +1171,7 @@ impl PageVm {
raw_json,
deferred_response,
} => self
- .dispatch_runtime_protocol_message_for_inspector_session_with_deferred_response(
+ .dispatch_frontend_runtime_protocol_message_for_inspector_session_with_deferred_response(
inspector_session_id,
&raw_json,
deferred_response,
@@ -1194,7 +1194,7 @@ impl PageVm {
raw_json,
deferred_response,
} => self
- .dispatch_runtime_protocol_message_for_inspector_session_with_context_resolution_and_deferred_response(
+ .dispatch_frontend_runtime_protocol_message_for_inspector_session_with_context_resolution_and_deferred_response(
inspector_session_id,
&action,
&raw_json,
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index b7d786d7f..112395a56 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -730,7 +730,7 @@ impl PageVm {
Ok(messages)
}
- pub(crate) fn dispatch_runtime_protocol_message_for_inspector_session_with_deferred_response(
+ pub(crate) fn dispatch_frontend_runtime_protocol_message_for_inspector_session_with_deferred_response(
&mut self,
inspector_session_id: Option<&str>,
raw_json: &str,
@@ -771,7 +771,7 @@ impl PageVm {
Ok(messages)
}
- pub(crate) fn dispatch_runtime_protocol_message_for_inspector_session_with_context_resolution_and_deferred_response(
+ pub(crate) fn dispatch_frontend_runtime_protocol_message_for_inspector_session_with_context_resolution_and_deferred_response(
&mut self,
inspector_session_id: Option<&str>,
action: &str,
@@ -782,14 +782,27 @@ impl PageVm {
&& let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)?
{
let call_id = deferred_response.call_id();
- if let Some(message) = messages.into_iter().next()
- && let Err(message) = deferred_response.send(message.into_v8_inspector_message())
- {
- tracing::debug!(
- call_id,
- message = ?message,
- "dropping child-frame runtime response because deferred receiver was closed"
- );
+ if let Some(message) = messages.into_iter().next() {
+ if deferred_response.response_delivery()
+ == moli_page_types::RendererInspectorResponseDelivery::DevToolsSession
+ {
+ let deferred_response = self.vm().route_frontend_runtime_inspector_response(
+ inspector_session_id,
+ deferred_response,
+ )?;
+ let settlement = deferred_response.finalize_output(
+ RendererRuntimeCommandOutput::from_inspector_message(message),
+ );
+ self.append_runtime_command_output_settlement(settlement);
+ } else if let Err(message) =
+ deferred_response.send(message.into_v8_inspector_message())
+ {
+ tracing::debug!(
+ call_id,
+ message = ?message,
+ "dropping child-frame runtime response because deferred receiver was closed"
+ );
+ }
}
return Ok(Vec::new());
}
@@ -812,6 +825,10 @@ impl PageVm {
self.pending_runtime_command_output.is_none(),
"renderer runtime command output scopes cannot overlap"
);
+ ensure!(
+ !self.runtime_command_settlement.has_session_response(),
+ "a previous runtime session response must settle at its owner boundary before another command starts"
+ );
// A V8 Inspector response can settle after this command's physical
// Page turn. Commit it through the Page owner so the response carries
// the exact concrete-output tail visible at that owner boundary.
@@ -875,7 +892,7 @@ impl PageVm {
fn capture_runtime_inspector_v8_state(&mut self, inspector_session_id: Option<&str>) {
if let Some(state) = self.vm().inspector_v8_session_state(inspector_session_id) {
- self.runtime_command_output.set_v8_state_update(state);
+ self.runtime_command_settlement.set_v8_state_update(state);
}
}
@@ -963,20 +980,29 @@ impl PageVm {
scope.recorder.call_id(),
);
}
- let output = match error_message {
- Some(message) if had_response => Some(scope.recorder.finish_with_error(message)),
+ let settlement = match error_message {
+ Some(message) if had_response => {
+ Some(scope.recorder.finish_with_error_for_page(message))
+ }
Some(_) => {
let _ = scope.recorder.finish();
None
}
- None => Some(scope.recorder.finish()),
+ None => Some(scope.recorder.finish_for_page()),
};
- if let Some(output) = output {
- self.runtime_command_output.append(output);
+ if let Some(settlement) = settlement {
+ self.append_runtime_command_output_settlement(settlement);
}
had_response
}
+ fn append_runtime_command_output_settlement(
+ &mut self,
+ settlement: super::RendererRuntimeCommandOutputSettlement,
+ ) {
+ self.runtime_command_settlement.append(settlement);
+ }
+
fn record_runtime_inspector_protocol_configuration_command(
&mut self,
inspector_session_id: Option<&str>,
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index 5f8f36c49..b087f73f8 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -1179,8 +1179,8 @@ fn runtime_context_restore_event_v8_inspector_message(
/// response. Debugger resume/step transitions are the important inverse: V8
/// sends the response first, then reports `Debugger.resumed` and any following
/// step pause. Keeping that edge on the frozen batch lets protocol preserve the
-/// producer order even though response and renderer output use separate
-/// transports.
+/// producer order even though response and surrounding notifications cross
+/// separate publication boundaries.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum RendererRuntimeInspectorMessageResponseOrder {
#[default]
@@ -2721,11 +2721,33 @@ pub(crate) struct RendererRuntimeInspectorResponsePublication {
destination: RendererRuntimeInspectorResponseDestination,
}
+#[derive(Clone, Debug)]
+pub(crate) struct RendererRuntimeInspectorSessionResponseSettlement {
+ predecessor: RendererOutputFence,
+ response_succeeded: bool,
+}
+
+impl RendererRuntimeInspectorSessionResponseSettlement {
+ fn new(predecessor: RendererOutputFence, response_succeeded: bool) -> Self {
+ Self {
+ predecessor,
+ response_succeeded,
+ }
+ }
+
+ pub(crate) fn into_parts(self) -> (RendererOutputFence, bool) {
+ (self.predecessor, self.response_succeeded)
+ }
+}
+
impl RendererRuntimeInspectorResponsePublication {
pub(crate) fn commit(
self,
renderer_output_predecessor: Option<RendererOutputFence>,
- ) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {
+ ) -> Result<
+ Option<RendererRuntimeInspectorSessionResponseSettlement>,
+ RendererRuntimeInspectorAsyncCompletion,
+ > {
self.destination.send(
RendererRuntimeInspectorAsyncCompletion::from_renderer_response_edge(
self.call_id,
@@ -2734,6 +2756,102 @@ impl RendererRuntimeInspectorResponsePublication {
),
)
}
+
+ pub(crate) fn commit_error(
+ mut self,
+ message: String,
+ renderer_output_predecessor: Option<RendererOutputFence>,
+ ) -> Result<
+ Option<RendererRuntimeInspectorSessionResponseSettlement>,
+ RendererRuntimeInspectorAsyncCompletion,
+ > {
+ let error = RendererRuntimeInspectorMessage::from_v8_inspector_message(json!({
+ "id": self.call_id,
+ "error": {
+ "code": -32000,
+ "message": message,
+ }
+ }));
+ let mut response_indices =
+ self.output
+ .messages
+ .iter()
+ .enumerate()
+ .filter_map(|(index, candidate)| {
+ matches!(
+ candidate,
+ RendererRuntimeInspectorMessage::Protocol(protocol)
+ if protocol.renderer_call_id().is_some_and(|id| id.get() == self.call_id)
+ )
+ .then_some(index)
+ });
+ let response_index = response_indices
+ .next()
+ .expect("a parked session response must remain exactly once");
+ assert!(
+ response_indices.next().is_none(),
+ "a parked session response must remain exactly once"
+ );
+ self.output.messages[response_index] = error;
+ self.commit(renderer_output_predecessor)
+ }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct RendererRuntimeCommandOutputSettlement {
+ output: RendererRuntimeCommandOutput,
+ session_response: Option<RendererRuntimeInspectorResponsePublication>,
+}
+
+impl RendererRuntimeCommandOutputSettlement {
+ fn command_reply(output: RendererRuntimeCommandOutput) -> Self {
+ Self {
+ output,
+ session_response: None,
+ }
+ }
+
+ fn session_response(publication: RendererRuntimeInspectorResponsePublication) -> Self {
+ Self {
+ output: RendererRuntimeCommandOutput::default(),
+ session_response: Some(publication),
+ }
+ }
+
+ pub(crate) fn append(&mut self, other: Self) {
+ self.output.append(other.output);
+ if let Some(session_response) = other.session_response {
+ assert!(
+ self.session_response.replace(session_response).is_none(),
+ "one Page command cannot settle multiple terminal session responses"
+ );
+ }
+ }
+
+ pub(crate) fn has_session_response(&self) -> bool {
+ self.session_response.is_some()
+ }
+
+ pub(crate) fn set_v8_state_update(&mut self, state: V8InspectorSessionState) {
+ self.output.set_v8_state_update(state);
+ }
+
+ fn into_command_reply_output(self) -> RendererRuntimeCommandOutput {
+ assert!(
+ self.session_response.is_none(),
+ "a DevTools session response cannot become a typed command reply"
+ );
+ self.output
+ }
+
+ pub(crate) fn into_parts(
+ self,
+ ) -> (
+ RendererRuntimeCommandOutput,
+ Option<RendererRuntimeInspectorResponsePublication>,
+ ) {
+ (self.output, self.session_response)
+ }
}
#[derive(Clone)]
@@ -2810,7 +2928,7 @@ impl RendererRuntimeCommandOutputRecorder {
) {
let mut state = self.0.borrow_mut();
debug_assert_eq!(state.causal_identity.call_id(), sender.call_id());
- debug_assert!(
+ assert!(
state.response.is_none(),
"one runtime command output scope cannot own multiple responses"
);
@@ -2818,23 +2936,31 @@ impl RendererRuntimeCommandOutputRecorder {
}
pub(crate) fn finish(self) -> RendererRuntimeCommandOutput {
- self.finish_with_response_override(None)
+ self.finish_settlement_with_response_override(None)
+ .into_command_reply_output()
}
- pub(crate) fn finish_with_error(self, message: String) -> RendererRuntimeCommandOutput {
- self.finish_with_response_override(Some(message))
+ pub(crate) fn finish_for_page(self) -> RendererRuntimeCommandOutputSettlement {
+ self.finish_settlement_with_response_override(None)
}
- fn finish_with_response_override(
+ pub(crate) fn finish_with_error_for_page(
+ self,
+ message: String,
+ ) -> RendererRuntimeCommandOutputSettlement {
+ self.finish_settlement_with_response_override(Some(message))
+ }
+
+ fn finish_settlement_with_response_override(
self,
error_message: Option<String>,
- ) -> RendererRuntimeCommandOutput {
+ ) -> RendererRuntimeCommandOutputSettlement {
let mut state = self.0.borrow_mut();
let mut output = std::mem::take(&mut state.output);
let response = state.response.take();
drop(state);
let Some((sender, message)) = response else {
- return output;
+ return RendererRuntimeCommandOutputSettlement::command_reply(output);
};
let message = error_message.map_or(message, |message| {
json!({
@@ -2853,11 +2979,15 @@ impl RendererRuntimeCommandOutputRecorder {
struct RendererRuntimeInspectorResponseChannelState {
next_lease_id: u64,
active_lease_id: Option<u64>,
+ open: bool,
tx: Option<oneshot::Sender<RendererRuntimeInspectorAsyncCompletion>>,
+ session_response_settlement_tx:
+ Option<oneshot::Sender<RendererRuntimeInspectorSessionResponseSettlement>>,
}
#[derive(Clone)]
pub struct RendererRuntimeInspectorResponseChannel {
+ delivery: moli_page_types::RendererInspectorResponseDelivery,
state: Arc<Mutex<RendererRuntimeInspectorResponseChannelState>>,
}
@@ -2866,6 +2996,7 @@ impl std::fmt::Debug for RendererRuntimeInspectorResponseChannel {
let state = self.state.lock();
formatter
.debug_struct("RendererRuntimeInspectorResponseChannel")
+ .field("delivery", &self.delivery)
.field("active_lease_id", &state.active_lease_id)
.field("has_receiver", &state.tx.is_some())
.finish()
@@ -2888,16 +3019,46 @@ impl RendererRuntimeInspectorResponseChannel {
let (tx, rx) = oneshot::channel();
(
Self {
+ delivery: moli_page_types::RendererInspectorResponseDelivery::CommandReply,
state: Arc::new(Mutex::new(RendererRuntimeInspectorResponseChannelState {
next_lease_id: 1,
active_lease_id: None,
+ open: true,
tx: Some(tx),
+ session_response_settlement_tx: None,
})),
},
rx,
)
}
+ pub fn new_for_delivery(
+ delivery: moli_page_types::RendererInspectorResponseDelivery,
+ ) -> (
+ Self,
+ Option<oneshot::Receiver<RendererRuntimeInspectorAsyncCompletion>>,
+ ) {
+ match delivery {
+ moli_page_types::RendererInspectorResponseDelivery::CommandReply => {
+ let (channel, receiver) = Self::new();
+ (channel, Some(receiver))
+ }
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession => (
+ Self {
+ delivery,
+ state: Arc::new(Mutex::new(RendererRuntimeInspectorResponseChannelState {
+ next_lease_id: 1,
+ active_lease_id: None,
+ open: true,
+ tx: None,
+ session_response_settlement_tx: None,
+ })),
+ },
+ None,
+ ),
+ }
+ }
+
pub fn activate_sender(
&self,
call_id: i32,
@@ -2914,7 +3075,9 @@ impl RendererRuntimeInspectorResponseChannel {
) -> Option<RendererRuntimeInspectorResponseSender> {
let lease_id = {
let mut state = self.state.lock();
- state.tx.as_ref()?;
+ if !state.open {
+ return None;
+ }
let lease_id = state.next_lease_id;
state.next_lease_id = lease_id
.checked_add(1)
@@ -2922,23 +3085,29 @@ impl RendererRuntimeInspectorResponseChannel {
state.active_lease_id = Some(lease_id);
lease_id
};
+ let lease = RendererRuntimeInspectorResponseLease::new(lease_id, self.clone());
+ let destination = match self.delivery {
+ moli_page_types::RendererInspectorResponseDelivery::CommandReply => {
+ RendererRuntimeInspectorResponseDestination::CommandReply(lease)
+ }
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession => {
+ RendererRuntimeInspectorResponseDestination::DevToolsSessionPending(lease)
+ }
+ };
Some(RendererRuntimeInspectorResponseSender {
call_id,
attachment_id,
- destination: RendererRuntimeInspectorResponseDestination::CommandReply(
- RendererRuntimeInspectorCommandReplyDestination {
- lease_id,
- channel: self.clone(),
- },
- ),
+ destination,
publication_boundary: RendererRuntimeInspectorResponsePublicationBoundary::Immediate,
})
}
pub fn cancel(&self) {
let mut state = self.state.lock();
+ state.open = false;
state.active_lease_id = None;
state.tx.take();
+ state.session_response_settlement_tx.take();
}
fn send(
@@ -2951,6 +3120,7 @@ impl RendererRuntimeInspectorResponseChannel {
if state.active_lease_id != Some(lease_id) {
return Err(completion);
}
+ state.open = false;
state.active_lease_id = None;
state.tx.take()
};
@@ -2959,20 +3129,98 @@ impl RendererRuntimeInspectorResponseChannel {
};
tx.send(completion)
}
+
+ fn take_session_response_settlement_receiver(
+ &self,
+ lease_id: u64,
+ ) -> Option<oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>> {
+ let mut state = self.state.lock();
+ if !state.open
+ || state.active_lease_id != Some(lease_id)
+ || state.session_response_settlement_tx.is_some()
+ {
+ return None;
+ }
+ let (tx, rx) = oneshot::channel();
+ state.session_response_settlement_tx = Some(tx);
+ Some(rx)
+ }
+
+ fn cancel_lease(&self, lease_id: u64) -> bool {
+ let mut state = self.state.lock();
+ if !state.open || state.active_lease_id != Some(lease_id) {
+ return false;
+ }
+ state.open = false;
+ state.active_lease_id = None;
+ state.tx.take();
+ state.session_response_settlement_tx.take();
+ true
+ }
+
+ fn claim_session_lease(
+ &self,
+ lease_id: u64,
+ ) -> Result<Option<oneshot::Sender<RendererRuntimeInspectorSessionResponseSettlement>>, ()>
+ {
+ let mut state = self.state.lock();
+ if !state.open || state.active_lease_id != Some(lease_id) {
+ return Err(());
+ }
+ state.open = false;
+ state.active_lease_id = None;
+ Ok(state.session_response_settlement_tx.take())
+ }
}
-#[derive(Clone, Debug)]
-struct RendererRuntimeInspectorCommandReplyDestination {
+#[derive(Debug)]
+struct RendererRuntimeInspectorResponseLeaseLifetime {
lease_id: u64,
channel: RendererRuntimeInspectorResponseChannel,
}
-impl RendererRuntimeInspectorCommandReplyDestination {
- fn send(
+impl Drop for RendererRuntimeInspectorResponseLeaseLifetime {
+ fn drop(&mut self) {
+ self.channel.cancel_lease(self.lease_id);
+ }
+}
+
+#[derive(Clone, Debug)]
+struct RendererRuntimeInspectorResponseLease {
+ lifetime: Arc<RendererRuntimeInspectorResponseLeaseLifetime>,
+}
+
+impl RendererRuntimeInspectorResponseLease {
+ fn new(lease_id: u64, channel: RendererRuntimeInspectorResponseChannel) -> Self {
+ Self {
+ lifetime: Arc::new(RendererRuntimeInspectorResponseLeaseLifetime { lease_id, channel }),
+ }
+ }
+
+ fn send_command_reply(
self,
completion: RendererRuntimeInspectorAsyncCompletion,
) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {
- self.channel.send(self.lease_id, completion)
+ self.lifetime
+ .channel
+ .send(self.lifetime.lease_id, completion)
+ }
+
+ fn take_session_response_settlement_receiver(
+ &self,
+ ) -> Option<oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>> {
+ self.lifetime
+ .channel
+ .take_session_response_settlement_receiver(self.lifetime.lease_id)
+ }
+
+ fn claim_session(
+ &self,
+ ) -> Result<Option<oneshot::Sender<RendererRuntimeInspectorSessionResponseSettlement>>, ()>
+ {
+ self.lifetime
+ .channel
+ .claim_session_lease(self.lifetime.lease_id)
}
}
@@ -3008,7 +3256,7 @@ impl RendererDevToolsSessionOutputHost {
fn publish(
&self,
completion: RendererRuntimeInspectorAsyncCompletion,
- ) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {
+ ) -> Result<RendererOutputFence, RendererRuntimeInspectorAsyncCompletion> {
if completion.renderer_agent_attachment_id() != Some(self.attachment_id) {
return Err(completion);
}
@@ -3040,26 +3288,80 @@ impl RendererDevToolsSessionOutputHost {
RendererProtocolObservation::RuntimeInspector(batch),
);
self.output_journal
- .try_publish_records([record])
- .then_some(())
+ .try_publish_records_and_declare_fence([record])
.ok_or(completion)
}
}
#[derive(Clone, Debug)]
enum RendererRuntimeInspectorResponseDestination {
- CommandReply(RendererRuntimeInspectorCommandReplyDestination),
- DevToolsSession(RendererDevToolsSessionOutputHost),
+ CommandReply(RendererRuntimeInspectorResponseLease),
+ DevToolsSessionPending(RendererRuntimeInspectorResponseLease),
+ DevToolsSession {
+ lease: RendererRuntimeInspectorResponseLease,
+ host: RendererDevToolsSessionOutputHost,
+ },
}
impl RendererRuntimeInspectorResponseDestination {
fn send(
self,
completion: RendererRuntimeInspectorAsyncCompletion,
- ) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {
+ ) -> Result<
+ Option<RendererRuntimeInspectorSessionResponseSettlement>,
+ RendererRuntimeInspectorAsyncCompletion,
+ > {
match self {
- Self::CommandReply(destination) => destination.send(completion),
- Self::DevToolsSession(host) => host.publish(completion),
+ Self::CommandReply(lease) => lease.send_command_reply(completion).map(|()| None),
+ Self::DevToolsSessionPending(_) => Err(completion),
+ Self::DevToolsSession { lease, host } => {
+ let settlement_tx = match lease.claim_session() {
+ Ok(settlement_tx) => settlement_tx,
+ Err(()) => return Err(completion),
+ };
+ let mut responses =
+ completion
+ .output
+ .messages
+ .iter()
+ .filter_map(|message| match message {
+ RendererRuntimeInspectorMessage::Protocol(response)
+ if response.renderer_call_id().is_some_and(
+ |renderer_call_id| renderer_call_id.get() == completion.call_id,
+ ) =>
+ {
+ Some(response.value())
+ }
+ _ => None,
+ });
+ let Some(response) = responses.next() else {
+ return Err(completion);
+ };
+ if responses.next().is_some() {
+ return Err(completion);
+ }
+ let response_succeeded = response.get("error").is_none();
+ let fence = host.publish(completion)?;
+ let settlement = RendererRuntimeInspectorSessionResponseSettlement::new(
+ fence,
+ response_succeeded,
+ );
+ if let Some(settlement_tx) = settlement_tx {
+ let _ = settlement_tx.send(settlement.clone());
+ }
+ Ok(Some(settlement))
+ }
+ }
+ }
+
+ fn take_session_response_settlement_receiver(
+ &self,
+ ) -> Option<oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>> {
+ match self {
+ Self::CommandReply(_) => None,
+ Self::DevToolsSessionPending(lease) | Self::DevToolsSession { lease, .. } => {
+ lease.take_session_response_settlement_receiver()
+ }
}
}
}
@@ -3090,20 +3392,20 @@ impl std::fmt::Debug for RendererRuntimeInspectorResponseSender {
impl RendererRuntimeInspectorResponseSender {
pub fn new(call_id: i32, tx: oneshot::Sender<RendererRuntimeInspectorAsyncCompletion>) -> Self {
let channel = RendererRuntimeInspectorResponseChannel {
+ delivery: moli_page_types::RendererInspectorResponseDelivery::CommandReply,
state: Arc::new(Mutex::new(RendererRuntimeInspectorResponseChannelState {
next_lease_id: 2,
active_lease_id: Some(1),
+ open: true,
tx: Some(tx),
+ session_response_settlement_tx: None,
})),
};
Self {
call_id,
attachment_id: None,
destination: RendererRuntimeInspectorResponseDestination::CommandReply(
- RendererRuntimeInspectorCommandReplyDestination {
- lease_id: 1,
- channel,
- },
+ RendererRuntimeInspectorResponseLease::new(1, channel),
),
publication_boundary: RendererRuntimeInspectorResponsePublicationBoundary::Immediate,
}
@@ -3113,6 +3415,24 @@ impl RendererRuntimeInspectorResponseSender {
self.call_id
}
+ pub(crate) fn response_delivery(&self) -> moli_page_types::RendererInspectorResponseDelivery {
+ match self.destination {
+ RendererRuntimeInspectorResponseDestination::CommandReply(_) => {
+ moli_page_types::RendererInspectorResponseDelivery::CommandReply
+ }
+ RendererRuntimeInspectorResponseDestination::DevToolsSessionPending(_)
+ | RendererRuntimeInspectorResponseDestination::DevToolsSession { .. } => {
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession
+ }
+ }
+ }
+
+ pub(crate) fn take_session_response_settlement_receiver(
+ &self,
+ ) -> Option<oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>> {
+ self.destination.take_session_response_settlement_receiver()
+ }
+
pub(crate) fn renderer_agent_attachment_id(&self) -> Option<RendererAgentAttachmentId> {
self.attachment_id
}
@@ -3155,9 +3475,14 @@ impl RendererRuntimeInspectorResponseSender {
"a DevTools session response host must belong to the command attachment"
);
self.destination = match self.destination {
- RendererRuntimeInspectorResponseDestination::CommandReply(_)
- | RendererRuntimeInspectorResponseDestination::DevToolsSession(_) => {
- RendererRuntimeInspectorResponseDestination::DevToolsSession(host)
+ RendererRuntimeInspectorResponseDestination::DevToolsSessionPending(lease) => {
+ RendererRuntimeInspectorResponseDestination::DevToolsSession { lease, host }
+ }
+ RendererRuntimeInspectorResponseDestination::DevToolsSession { lease, host: _ } => {
+ RendererRuntimeInspectorResponseDestination::DevToolsSession { lease, host }
+ }
+ RendererRuntimeInspectorResponseDestination::CommandReply(_) => {
+ panic!("a command-reply response cannot be rebound to DevTools session output")
}
};
self
@@ -3189,7 +3514,7 @@ impl RendererRuntimeInspectorResponseSender {
};
match publication_boundary {
RendererRuntimeInspectorResponsePublicationBoundary::Immediate => {
- publication.commit(None)
+ publication.commit(None).map(|_| ())
}
RendererRuntimeInspectorResponsePublicationBoundary::PageOwner(owner_wake) => {
owner_wake.defer_runtime_inspector_response_publication(publication)
@@ -3207,21 +3532,46 @@ impl RendererRuntimeInspectorResponseSender {
else {
unreachable!("the failed send must return the submitted publication")
};
- publication.commit(None)
+ publication.commit(None).map(|_| ())
}
}
}
}
}
- fn finalize_output(
+ pub(crate) fn finalize_output(
self,
mut output: RendererRuntimeCommandOutput,
- ) -> RendererRuntimeCommandOutput {
+ ) -> RendererRuntimeCommandOutputSettlement {
if let Some(attachment_id) = self.attachment_id {
output.bind_renderer_agent_attachment(attachment_id);
}
- output
+ let Self {
+ call_id,
+ attachment_id: _,
+ destination,
+ publication_boundary: _,
+ } = self;
+ match destination {
+ RendererRuntimeInspectorResponseDestination::CommandReply(_) => {
+ RendererRuntimeCommandOutputSettlement::command_reply(output)
+ }
+ RendererRuntimeInspectorResponseDestination::DevToolsSessionPending(_) => panic!(
+ "a DevTools session response must bind its concrete output host before settlement"
+ ),
+ RendererRuntimeInspectorResponseDestination::DevToolsSession { lease, host } => {
+ RendererRuntimeCommandOutputSettlement::session_response(
+ RendererRuntimeInspectorResponsePublication {
+ call_id,
+ output,
+ destination: RendererRuntimeInspectorResponseDestination::DevToolsSession {
+ lease,
+ host,
+ },
+ },
+ )
+ }
+ }
}
}
@@ -3265,21 +3615,12 @@ mod renderer_runtime_inspector_response_channel_tests {
}
#[tokio::test]
- async fn retained_channel_prevents_old_sender_drop_from_canceling_frontend_receiver() {
- let (channel, mut rx) = RendererRuntimeInspectorResponseChannel::new();
- let old_sender = channel.activate_sender(1, None);
- drop(old_sender);
-
- assert!(matches!(
- rx.try_recv(),
- Err(tokio::sync::oneshot::error::TryRecvError::Empty)
- ));
+ async fn dropping_last_active_sender_closes_frontend_receiver() {
+ let (channel, rx) = RendererRuntimeInspectorResponseChannel::new();
+ drop(channel.activate_sender(1, None));
- channel
- .activate_sender(2, None)
- .send_output(output(2))
- .expect("replacement sender should retain completion ownership");
- assert_eq!(rx.await.unwrap().call_id, 2);
+ assert!(rx.await.is_err());
+ assert!(channel.try_activate_sender(2, None).is_none());
}
#[tokio::test]
@@ -3431,7 +3772,13 @@ mod renderer_runtime_inspector_response_channel_tests {
);
let (owner_wake_tx, mut owner_wake_rx) = tokio::sync::mpsc::unbounded_channel();
let owner_wake = RendererOwnerWakeSender::new(owner_wake_tx, token);
- let (channel, mut response_rx) = RendererRuntimeInspectorResponseChannel::new();
+ let (channel, response_rx) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(
+ response_rx.is_none(),
+ "session delivery must not allocate a legacy command-reply receiver"
+ );
channel
.activate_sender(7, Some(attachment_id))
@@ -3440,7 +3787,6 @@ mod renderer_runtime_inspector_response_channel_tests {
.send_output(output(7))
.expect("Page owner should accept the terminal session response");
- assert_eq!(response_rx.try_recv(), Err(TryRecvError::Empty));
assert!(
transport_rx.try_recv().is_err(),
"selecting session output must not publish before the Page owner boundary"
@@ -3485,10 +3831,262 @@ mod renderer_runtime_inspector_response_channel_tests {
panic!("session response must remain a protocol message");
};
assert_eq!(message.value()["id"], json!(7));
- assert_eq!(response_rx.try_recv(), Err(TryRecvError::Empty));
-
channel.cancel();
}
+
+ #[tokio::test]
+ async fn rotating_session_lease_rejects_stale_bound_sender_and_publishes_once() {
+ let old_stream =
+ RendererOutputStreamIdentity::new_page_for_protocol_test(PageId::new_for_testing(11));
+ let new_stream =
+ RendererOutputStreamIdentity::new_page_for_protocol_test(PageId::new_for_testing(12));
+ let (old_transport, mut old_rx) = crate::runtime::renderer_output_transport_channel();
+ let (new_transport, mut new_rx) = crate::runtime::renderer_output_transport_channel();
+ let old_journal = RendererTurnOutputJournal::new_with_transport(old_stream, old_transport);
+ let new_journal = RendererTurnOutputJournal::new_with_transport(new_stream, new_transport);
+ assert!(matches!(
+ old_rx.try_recv(),
+ Ok(RendererOutputTransportMessage::StreamControl(
+ RendererOutputStreamControl::Opened { stream }
+ )) if stream == old_stream
+ ));
+ assert!(matches!(
+ new_rx.try_recv(),
+ Ok(RendererOutputTransportMessage::StreamControl(
+ RendererOutputStreamControl::Opened { stream }
+ )) if stream == new_stream
+ ));
+
+ let agent = RendererDevToolsAgentToken::allocate();
+ let session = DevToolsSessionKey::Attached("SID-rotated-session".to_owned());
+ let old_attachment = RendererAgentAttachmentId::allocate();
+ let new_attachment = RendererAgentAttachmentId::allocate();
+ let (channel, receiver) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(receiver.is_none());
+ let old_sender = channel
+ .activate_sender(1, Some(old_attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session.clone(),
+ old_attachment,
+ old_journal,
+ ));
+ let settlement_rx = old_sender
+ .take_session_response_settlement_receiver()
+ .expect("the original route should own the frontend call settlement");
+ let new_sender = channel
+ .activate_sender(2, Some(new_attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ agent,
+ session,
+ new_attachment,
+ new_journal,
+ ));
+
+ assert!(
+ old_sender.send_output(output(1)).is_err(),
+ "rotating the response lease must invalidate a fully bound old session sender"
+ );
+ assert!(old_rx.try_recv().is_err());
+ assert!(
+ new_sender
+ .take_session_response_settlement_receiver()
+ .is_none(),
+ "a replay route must not replace the original frontend call waiter"
+ );
+ new_sender
+ .send_output(output(2))
+ .expect("the current bound session sender should publish");
+ let (_, response_succeeded) = settlement_rx
+ .await
+ .expect("the published session response should settle its waiter")
+ .into_parts();
+ assert!(response_succeeded);
+ assert!(matches!(
+ new_rx.recv().await,
+ Some(RendererOutputTransportMessage::Publication(_))
+ ));
+ assert!(
+ channel
+ .try_activate_sender(3, Some(new_attachment))
+ .is_none(),
+ "a published session response must close the terminal lease"
+ );
+ while let Ok(message) = new_rx.try_recv() {
+ assert!(
+ !matches!(message, RendererOutputTransportMessage::Publication(_)),
+ "settling the session lease must not publish a second response"
+ );
+ }
+ }
+
+ #[tokio::test]
+ async fn owner_failure_replaces_parked_session_result_with_exactly_one_error() {
+ let page_id = PageId::new_for_testing(21);
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(page_id);
+ let (transport, mut transport_rx) = crate::runtime::renderer_output_transport_channel();
+ let journal = RendererTurnOutputJournal::new_with_transport(stream, transport);
+ assert!(matches!(
+ transport_rx.try_recv(),
+ Ok(RendererOutputTransportMessage::StreamControl(
+ RendererOutputStreamControl::Opened { stream: opened }
+ )) if opened == stream
+ ));
+ let attachment = RendererAgentAttachmentId::allocate();
+ let (channel, receiver) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(receiver.is_none());
+ let sender = channel
+ .activate_sender(17, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ RendererDevToolsAgentToken::allocate(),
+ DevToolsSessionKey::Attached("SID-owner-error".to_owned()),
+ attachment,
+ journal,
+ ));
+ let stale_sender = sender.clone();
+ let (command_output, publication) = sender.finalize_output(output(17)).into_parts();
+ assert!(command_output.is_empty());
+ let publication =
+ publication.expect("session sender must produce a parked session publication");
+
+ let (_, response_succeeded) = publication
+ .commit_error("page state capture failed".to_owned(), None)
+ .expect("owner failure should publish through the terminal session sink")
+ .expect("session output should return its concrete settlement")
+ .into_parts();
+ assert!(!response_succeeded);
+ let RendererOutputTransportMessage::Publication(publication) = transport_rx
+ .recv()
+ .await
+ .expect("one owner error publication")
+ else {
+ panic!("owner error must publish a protocol observation");
+ };
+ let [record] = publication.records() else {
+ panic!("owner error must contain exactly one response record");
+ };
+ let RendererOutputItem::Observation(RendererProtocolObservation::RuntimeInspector(batch)) =
+ record.item()
+ else {
+ panic!("owner error must use the Runtime Inspector output stream");
+ };
+ let [RendererRuntimeInspectorMessage::Protocol(message)] = batch.messages.as_slice() else {
+ panic!("owner error must contain exactly one protocol response");
+ };
+ assert_eq!(message.value()["id"], json!(17));
+ assert_eq!(
+ message.value()["error"]["message"],
+ json!("page state capture failed")
+ );
+ assert!(
+ stale_sender.send_output(output(17)).is_err(),
+ "the settled session lease must reject a duplicate terminal response"
+ );
+ while let Ok(message) = transport_rx.try_recv() {
+ assert!(
+ !matches!(message, RendererOutputTransportMessage::Publication(_)),
+ "rejecting a stale sender must not publish a second response"
+ );
+ }
+ }
+
+ #[tokio::test]
+ async fn page_settlement_keeps_nonresponse_output_beside_session_response() {
+ let page_id = PageId::new_for_testing(22);
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(page_id);
+ let (transport, mut transport_rx) = crate::runtime::renderer_output_transport_channel();
+ let journal = RendererTurnOutputJournal::new_with_transport(stream, transport);
+ assert!(matches!(
+ transport_rx.try_recv(),
+ Ok(RendererOutputTransportMessage::StreamControl(
+ RendererOutputStreamControl::Opened { stream: opened }
+ )) if opened == stream
+ ));
+ let attachment = RendererAgentAttachmentId::allocate();
+ let (channel, receiver) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(receiver.is_none());
+ let sender = channel
+ .activate_sender(23, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ RendererDevToolsAgentToken::allocate(),
+ DevToolsSessionKey::Attached("SID-page-settlement".to_owned()),
+ attachment,
+ journal,
+ ));
+
+ let session_response = sender.finalize_output(output(23));
+ let nonresponse_output = RendererRuntimeCommandOutput::from_inspector_message(
+ RendererRuntimeInspectorMessage::protocol(json!({
+ "method": "Debugger.scriptParsed",
+ "params": { "scriptId": "before-response" },
+ })),
+ );
+ let mut accumulated = RendererRuntimeCommandOutputSettlement::default();
+ accumulated.append(session_response);
+ accumulated.append(RendererRuntimeCommandOutputSettlement::command_reply(
+ nonresponse_output,
+ ));
+ assert!(accumulated.has_session_response());
+
+ let (command_output, publication) = accumulated.into_parts();
+ let [RendererRuntimeInspectorMessage::Protocol(notification)] = command_output.messages()
+ else {
+ panic!("the Page settlement must retain its nonresponse output");
+ };
+ assert_eq!(
+ notification.value()["method"],
+ json!("Debugger.scriptParsed")
+ );
+ let (_, response_succeeded) = publication
+ .expect("the session response must remain parked beside Page output")
+ .commit(None)
+ .expect("the parked session response must publish")
+ .expect("session publication must report its concrete fence")
+ .into_parts();
+ assert!(response_succeeded);
+ assert!(matches!(
+ transport_rx.recv().await,
+ Some(RendererOutputTransportMessage::Publication(_))
+ ));
+ }
+
+ #[test]
+ #[should_panic(expected = "one Page command cannot settle multiple terminal session responses")]
+ fn page_settlement_rejects_two_terminal_session_responses() {
+ fn parked_session_response(
+ call_id: i32,
+ page_id: u64,
+ ) -> RendererRuntimeCommandOutputSettlement {
+ let stream = RendererOutputStreamIdentity::new_page_for_protocol_test(
+ PageId::new_for_testing(page_id),
+ );
+ let (transport, _transport_rx) = crate::runtime::renderer_output_transport_channel();
+ let attachment = RendererAgentAttachmentId::allocate();
+ let (channel, receiver) = RendererRuntimeInspectorResponseChannel::new_for_delivery(
+ moli_page_types::RendererInspectorResponseDelivery::DevToolsSession,
+ );
+ assert!(receiver.is_none());
+ channel
+ .activate_sender(call_id, Some(attachment))
+ .route_to_devtools_session_output(RendererDevToolsSessionOutputHost::new(
+ RendererDevToolsAgentToken::allocate(),
+ DevToolsSessionKey::Attached(format!("SID-duplicate-{call_id}")),
+ attachment,
+ RendererTurnOutputJournal::new_with_transport(stream, transport),
+ ))
+ .finalize_output(output(call_id))
+ }
+
+ let mut accumulated = RendererRuntimeCommandOutputSettlement::default();
+ accumulated.append(parked_session_response(24, 24));
+ accumulated.append(parked_session_response(25, 25));
+ }
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -4705,16 +5303,6 @@ impl RendererPageCommand {
}
}
- #[cfg(test)]
- pub(crate) fn inspector_first_dispatch_lifecycle(
- &self,
- ) -> Option<RendererInspectorFirstDispatchLifecycle> {
- match self {
- Self::Inspector(envelope) => Some(envelope.first_dispatch_lifecycle()),
- _ => None,
- }
- }
-
pub fn bind_inspector_attachment(&mut self, attachment: RendererAgentAttachmentId) {
if let Self::Inspector(envelope) = self {
envelope.bind_attachment(attachment);
@@ -4885,10 +5473,6 @@ mod renderer_inspector_command_envelope_tests {
assert_eq!(ticket.session(), &session);
assert_eq!(ticket.route(), route);
assert!(ticket.sequence() > 0);
- assert_eq!(
- command.inspector_first_dispatch_lifecycle(),
- Some(RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch)
- );
}
#[test]
diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs
index af363bb59..f56f47975 100644
--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs
@@ -1542,7 +1542,7 @@ pub(crate) struct PageVm {
pub(super) page_id: PageId,
pub(super) creation_id: u64,
pub(super) document_lifecycle: RendererDocumentLifecycleJournalHandle,
- pub(super) runtime_command_output: RendererRuntimeCommandOutput,
+ pub(super) runtime_command_settlement: super::RendererRuntimeCommandOutputSettlement,
pub(super) pending_runtime_command_output: Option<PageVmRuntimeCommandOutputScope>,
pub(super) next_runtime_command_output_scope_id: u64,
pub(super) vm: Option<ScriptVm>,
@@ -4095,8 +4095,13 @@ impl PageVm {
Ok(snapshot)
}
- pub(super) fn take_runtime_command_output(&mut self) -> RendererRuntimeCommandOutput {
- std::mem::take(&mut self.runtime_command_output)
+ pub(super) fn take_runtime_command_settlement(
+ &mut self,
+ ) -> (
+ RendererRuntimeCommandOutput,
+ Option<super::RendererRuntimeInspectorResponsePublication>,
+ ) {
+ std::mem::take(&mut self.runtime_command_settlement).into_parts()
}
fn refresh_document_url_from_location(&mut self) {
@@ -4256,7 +4261,7 @@ impl PageVm {
page_id,
creation_id,
document_lifecycle,
- runtime_command_output: RendererRuntimeCommandOutput::default(),
+ runtime_command_settlement: super::RendererRuntimeCommandOutputSettlement::default(),
pending_runtime_command_output: None,
next_runtime_command_output_scope_id: 1,
vm: Some(vm),
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs b/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
index 1cc7c320a..c212d7b57 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
@@ -2321,7 +2321,7 @@ async fn runtime_document_close_response_does_not_wait_for_replacement_lifecycle
let call_id = 710_220;
let (response_tx, mut response_rx) = tokio::sync::oneshot::channel();
let messages = page_vm
- .dispatch_runtime_protocol_message_for_inspector_session_with_deferred_response(
+ .dispatch_frontend_runtime_protocol_message_for_inspector_session_with_deferred_response(
None,
&serde_json::json!({
"id": call_id,
@@ -2378,7 +2378,11 @@ async fn runtime_document_close_response_does_not_wait_for_replacement_lifecycle
response_rx.try_recv(),
Err(tokio::sync::oneshot::error::TryRecvError::Closed)
));
- let output = page_vm.take_runtime_command_output();
+ let (output, session_response) = page_vm.take_runtime_command_settlement();
+ assert!(
+ session_response.is_none(),
+ "CommandReply delivery must not park a DevTools session response"
+ );
assert_eq!(
output
.protocol_response(call_id)
diff --git a/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs b/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs
index e9f3fcaef..cf9f2d129 100644
--- a/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs
+++ b/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs
@@ -187,12 +187,15 @@ impl RendererTurnOutputJournal {
/// A DevTools session response is a terminal renderer observation, not a
/// command-side acknowledgement. Admitting it through the same journal as
/// that session's notifications keeps their producer order without a
- /// second completion sequencer. `false` means the exact attachment stream
- /// was already closed before it could take ownership of the records.
- pub(crate) fn try_publish_records(
+ /// second completion sequencer. The returned fence names the terminal
+ /// batch itself so the command completion cannot release post-response
+ /// owner actions before protocol ingress admits that batch. `None` means
+ /// the exact attachment stream was already closed before it could take
+ /// ownership of the records.
+ pub(crate) fn try_publish_records_and_declare_fence(
&self,
records: impl IntoIterator<Item = PendingRendererOutputRecord>,
- ) -> bool {
+ ) -> Option<RendererOutputFence> {
let records = records.into_iter().collect::<Vec<_>>();
assert!(
!records.is_empty(),
@@ -200,11 +203,12 @@ impl RendererTurnOutputJournal {
);
let mut state = self.state.lock();
if state.closed {
- return false;
+ return None;
}
state.records.extend(records);
let publication = Self::settle_locked(&mut state)
.expect("newly appended renderer output records must settle");
+ let cursor = publication.cursor();
if let Some(transport) = state.transport.as_ref() {
// Admission failure means the protocol owner has retired or its
// bounded stream is terminal. The journal has nevertheless taken
@@ -214,7 +218,10 @@ impl RendererTurnOutputJournal {
} else {
state.deferred_publications.push(publication);
}
- true
+ Some(RendererOutputFence::declare(
+ cursor,
+ state.transport.clone(),
+ ))
}
fn settle_locked(
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 35e7139cb..d2fc036ea 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -1342,6 +1342,15 @@ impl ScriptVm {
)
}
+ pub(super) fn route_frontend_runtime_inspector_response(
+ &self,
+ inspector_session_id: Option<&str>,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<RendererRuntimeInspectorResponseSender> {
+ self.page_inspector
+ .route_frontend_response(inspector_session_id, response)
+ }
+
fn dispatch_internal_runtime_evaluate_protocol_message(
&mut self,
raw_json: &str,
@@ -1726,7 +1735,7 @@ impl ScriptVm {
outbound.begin_runtime_command_output(command_output);
}
if let Some(callback) = deferred_response {
- outbound.register_response_callback(callback);
+ outbound.register_frontend_response_callback(callback);
}
let _internal_response_capture = internal_dispatch_call_id
.map(|call_id| outbound.capture_internal_dispatch_response(call_id));
diff --git a/moli-renderer-v8/src/script_vm/inspector/agent.rs b/moli-renderer-v8/src/script_vm/inspector/agent.rs
index 98ae938a2..710351b7c 100644
--- a/moli-renderer-v8/src/script_vm/inspector/agent.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/agent.rs
@@ -301,6 +301,17 @@ impl RendererDevToolsAgent {
self.state.borrow().sessions.frontend_routes()
}
+ pub(super) fn frontend_outbound(
+ &self,
+ session_key: &DevToolsSessionKey,
+ ) -> Option<InspectorOutbound> {
+ self.state
+ .borrow()
+ .sessions
+ .frontend_session_and_outbound(session_key)
+ .map(|(_, outbound)| outbound)
+ }
+
pub(super) fn deactivate_all_routes(&self) {
self.state.borrow().sessions.deactivate_all();
}
diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rs
index c9975e14a..7533e9fb8 100644
--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs
@@ -33,9 +33,8 @@ pub(crate) use self::v8_backend::{
};
use crate::devtools::target::RendererDevToolsTargetHandle;
#[cfg(test)]
-use crate::runtime::{
- RendererRuntimeCommandOutputRecorder, RendererRuntimeInspectorResponseSender,
-};
+use crate::runtime::RendererRuntimeCommandOutputRecorder;
+use crate::runtime::RendererRuntimeInspectorResponseSender;
use crate::{
frame_owner_model::FrameRealmId,
protocol_types::RuntimeBindingRegistration,
@@ -44,8 +43,8 @@ use crate::{
};
use anyhow::Result;
use moli_page_types::{
- DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorSessionRestoreSnapshot,
- V8InspectorSessionState,
+ DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorResponseDelivery,
+ RendererInspectorSessionRestoreSnapshot, V8InspectorSessionState,
};
use serde_json::{Value, json};
use std::{cell::RefCell, collections::HashMap};
@@ -145,6 +144,22 @@ impl DocumentInspectorBinding {
}
}
+ pub(super) fn route_frontend_response(
+ &self,
+ inspector_session_id: Option<&str>,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<RendererRuntimeInspectorResponseSender> {
+ if response.response_delivery() == RendererInspectorResponseDelivery::CommandReply {
+ return Ok(response);
+ }
+ let session_key = inspector_session_key(inspector_session_id);
+ let outbound = self
+ .agent
+ .frontend_outbound(&session_key)
+ .ok_or_else(|| anyhow::anyhow!("Inspector frontend session is not available"))?;
+ Ok(outbound.route_frontend_response(response))
+ }
+
pub(super) fn v8_session_state(
&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 112b0aeb6..696964f86 100644
--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
@@ -416,30 +416,27 @@ impl InspectorOutbound {
pub(in crate::script_vm) fn register_frontend_response_callback(
&self,
callback: RendererRuntimeInspectorResponseSender,
- delivery: RendererInspectorResponseDelivery,
) {
- let callback = self.route_frontend_response(callback, delivery);
+ let callback = self.route_frontend_response(callback);
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(
+ /// Publishes a synchronous non-V8 agent response through the terminal
+ /// destination selected when the frontend call was registered.
+ pub(in crate::script_vm) fn publish_frontend_response(
&self,
callback: RendererRuntimeInspectorResponseSender,
message: Value,
) {
- let callback = self
- .route_frontend_response(callback, RendererInspectorResponseDelivery::DevToolsSession);
+ let callback = self.route_frontend_response(callback);
let _ = callback.send(message);
}
- fn route_frontend_response(
+ pub(in crate::script_vm) fn route_frontend_response(
&self,
callback: RendererRuntimeInspectorResponseSender,
- delivery: RendererInspectorResponseDelivery,
) -> RendererRuntimeInspectorResponseSender {
- match delivery {
+ match callback.response_delivery() {
RendererInspectorResponseDelivery::CommandReply => callback,
RendererInspectorResponseDelivery::DevToolsSession => {
let host = self
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 25d28bcf9..6678d074e 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -234,10 +234,14 @@ impl RendererInspectorSessionExecutorLocal {
self.dispatch_io_command_to_session(command, session);
}
- fn dispatch_main_command(&self, context_group_id: i32, command: RendererInspectorMainCommand) {
+ fn dispatch_main_command(
+ &self,
+ context_group_id: i32,
+ mut command: RendererInspectorMainCommand,
+ ) {
match command.nested_dispatch() {
RendererDevToolsMainNestedDispatch::PageAgent => {
- let first_dispatch = self.target.main_ref().first_dispatch_guard(&command);
+ let first_dispatch = self.target.main_ref().first_dispatch_guard(&mut command);
let (page_command, reply_tx) = command.into_nested_page_parts();
let result = dispatch_nested_main_page_command(page_command, first_dispatch)
.map(|output| RendererOwnerReply::AsyncPageCommandRan(Box::new(output)));
@@ -292,18 +296,19 @@ impl RendererInspectorSessionExecutorLocal {
fn dispatch_main_command_to_session(
&self,
- command: RendererInspectorMainCommand,
+ mut command: RendererInspectorMainCommand,
session: Option<RendererInspectorSessionRoute>,
) {
- let mut first_dispatch = self.target.main_ref().first_dispatch_guard(&command);
+ let mut first_dispatch = self.target.main_ref().first_dispatch_guard(&mut command);
let Some(session) = session else {
- let (_, _, response) = command.into_protocol_parts();
- send_inspector_dispatch_error(Some(response), "Inspector session is not available");
+ first_dispatch.reject("Inspector session is not available");
return;
};
let Some(v8_session) = session.session.upgrade() else {
let (_, _, response) = command.into_protocol_parts();
+ let response = session.outbound.route_frontend_response(response);
send_inspector_dispatch_error(Some(response), "Inspector session has been detached");
+ first_dispatch.release();
return;
};
let _command_dispatch = self.target.pause_ref().begin_command_dispatch(
@@ -312,11 +317,10 @@ impl RendererInspectorSessionExecutorLocal {
command.pause_effect(),
Some(command.response().call_id()),
);
- let response_delivery = command.inspector_response_delivery();
let (_, raw_json, response) = command.into_protocol_parts();
session
.outbound
- .register_frontend_response_callback(response, response_delivery);
+ .register_frontend_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.target.pause_ref().record_v8_state_update(
@@ -341,14 +345,12 @@ impl RendererInspectorSessionExecutorLocal {
};
if let Some(response) = response {
let Some(session) = session else {
- send_inspector_dispatch_error(
- Some(response),
- "Inspector session is not available",
- );
+ drop(response);
+ first_dispatch.reject("Inspector session is not available");
return;
};
let call_id = response.call_id();
- session.outbound.publish_devtools_session_response(
+ session.outbound.publish_frontend_response(
response,
json!({ "id": call_id, "result": result }),
);
@@ -366,7 +368,8 @@ impl RendererInspectorSessionExecutorLocal {
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");
+ drop(response);
+ first_dispatch.reject("Inspector session is not available");
return;
}
control.set_disabled(disabled);
@@ -375,7 +378,7 @@ impl RendererInspectorSessionExecutorLocal {
session
.expect("a checked frontend Emulation command must have a session")
.outbound
- .publish_devtools_session_response(
+ .publish_frontend_response(
response,
json!({ "id": call_id, "result": {} }),
);
@@ -386,17 +389,16 @@ impl RendererInspectorSessionExecutorLocal {
RendererDevToolsIoCommandKind::Inspector => {}
}
let Some(session) = session else {
- send_inspector_dispatch_error(
- command.take_response(),
- "Inspector session is not available",
- );
+ drop(command.take_response());
+ first_dispatch.reject("Inspector session is not available");
return;
};
let Some(v8_session) = session.session.upgrade() else {
- send_inspector_dispatch_error(
- command.take_response(),
- "Inspector session has been detached",
- );
+ let response = command
+ .take_response()
+ .map(|response| session.outbound.route_frontend_response(response));
+ send_inspector_dispatch_error(response, "Inspector session has been detached");
+ first_dispatch.release();
return;
};
let _command_dispatch = self.target.pause_ref().begin_command_dispatch(
@@ -405,11 +407,10 @@ impl RendererInspectorSessionExecutorLocal {
command.pause_effect(),
command.response().map(|response| response.call_id()),
);
- let response_delivery = command.response_delivery();
if let Some(response) = command.take_response() {
session
.outbound
- .register_frontend_response_callback(response, response_delivery);
+ .register_frontend_response_callback(response);
}
let _post_dispatch_wake = first_dispatch.release_for_dispatch();
v8_session.dispatch_protocol_message(v8::inspector::StringView::from(