Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.pyindex 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(sessionfor session in resumed_sessionsdiff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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();barriersdiff --git a/moli-protocol/src/domains/dom_debugger.rs b/moli-protocol/src/domains/dom_debugger.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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).awaitelse {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.rsindex 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.rsindex 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(¶ms.message)).await;+ Box::pin(conn.process_message_with_command_reply_turn_outcome_async(¶ms.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.rsindex 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.rsindex 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_targeasync 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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_lifecyclelet 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_lifecycleresponse_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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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 = selfdiff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex 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(