Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(renderer): own document replacement debugger lifecycle
ldm0c4d0cac89af3
diff --git a/moli-core/src/page/document_content_support.rs b/moli-core/src/page/document_content_support.rsindex 7c8292d43..8b8e3114e 100644--- a/moli-core/src/page/document_content_support.rs+++ b/moli-core/src/page/document_content_support.rs@@ -6,6 +6,16 @@ use super::{};impl Page {+ /// Captures this document for a later renderer prepare operation. The+ /// navigation's cancellation handle prevents abandoned work from starting+ /// replacement; capturing this input does not resume a paused document.+ pub fn document_replacement(+ &self,+ cancellation: moli_fetch::FetchCancelHandle,+ ) -> crate::runtime::RendererDocumentReplacement {+ self.handle.document_replacement(cancellation)+ }+pub fn start_set_document_content(&self,frame_id: String,diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex b744f3f7e..df6641c64 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -594,11 +594,6 @@ impl Page {self.handle.runtime_inspector_pause_active()}- #[doc(hidden)]- pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {- self.handle.renderer_devtools_target()- }-pub fn start_runtime_protocol_message_with_context_resolution(&self,action: String,diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rsindex 11b3a6187..c0ef0acd6 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -91,13 +91,12 @@ pub use moli_renderer_v8::{RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDevToolsTargetHandle,- RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,- RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,- RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,- RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,- RendererDocumentLifecycleWaiter, RendererDocumentNodeGeometry,- RendererDocumentSourcedSameDocumentNavigation,+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,+ RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,+ RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,+ RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,+ RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,+ RendererDocumentNodeGeometry, RendererDocumentSourcedSameDocumentNavigation,RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,RendererDocumentToken, RendererDomAttributeMutation, RendererDomAttributeMutationOutcome,RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListener,diff --git a/moli-core/src/runtime/mod.rs b/moli-core/src/runtime/mod.rsindex 3a5e635ed..1875e9032 100644--- a/moli-core/src/runtime/mod.rs+++ b/moli-core/src/runtime/mod.rs@@ -40,8 +40,8 @@ pub use fetch_deadline::{FetchDeadline, FetchReadinessTimeout, FetchTimeoutPhasepub use moli_renderer_v8::{DetachedParserScriptFetchContinuation, RendererBrowserContextRuntime,RendererBrowserContextRuntimeOwner, RendererBrowserContextRuntimeOwnerAccess,- RendererLifecycleDecider, RendererLifecycleDecision, RendererLifecycleSnapshot,- RendererPageReservationToken, RendererReservedServiceWorkerClient,+ RendererDocumentReplacement, RendererLifecycleDecider, RendererLifecycleDecision,+ RendererLifecycleSnapshot, RendererPageReservationToken, RendererReservedServiceWorkerClient,RendererServiceWorkerMainResourceFetch, RendererSharedWorkerRuntimeDiagnostics,};pub use navigation_engine::{diff --git a/moli-core/src/runtime/navigation_engine.rs b/moli-core/src/runtime/navigation_engine.rsindex 2bd6dd673..c96b3c891 100644--- a/moli-core/src/runtime/navigation_engine.rs+++ b/moli-core/src/runtime/navigation_engine.rs@@ -22,9 +22,9 @@ use moli_fetch::{use moli_page_types::{LayoutPolicy, OptionalResourceFetchMask};use moli_renderer_v8::{RendererBrowserContextRuntime, RendererBrowserContextRuntimeOwner,- RendererBrowserContextRuntimeOwnerAccess, RendererReservedServiceWorkerClient,- RendererServiceWorkerMainResourceFetch, RendererWebStorageHandles, SharedStorageBucketStore,- WeakIndexedDbManager,+ RendererBrowserContextRuntimeOwnerAccess, RendererDocumentReplacement,+ RendererReservedServiceWorkerClient, RendererServiceWorkerMainResourceFetch,+ RendererWebStorageHandles, SharedStorageBucketStore, WeakIndexedDbManager,network::{BrowserResourceRuntime, BrowserResourceRuntimeOwner, PageNetworkPolicy,navigation::{DocumentFetchContextSeed, NavigationResourceLoader},@@ -1710,6 +1710,7 @@ impl NavigationEngine {let prepared = self.prepare_streaming_raw_page_from_external_body_async(page_reservation,+ None,cookie_store,web_storage,indexed_db_manager,@@ -1750,6 +1751,7 @@ impl NavigationEngine {async fn prepare_streaming_raw_page_from_external_body_async(&mut self,page_reservation: moli_renderer_v8::RendererPageReservationToken,+ replacement: Option<RendererDocumentReplacement>,cookie_store: SharedBrowserCookieStore,web_storage: RendererWebStorageHandles,indexed_db_manager: Option<WeakIndexedDbManager>,@@ -1793,6 +1795,7 @@ impl NavigationEngine {.js_runtime.prepare_streaming_raw_document_from_external_body(page_reservation,+ replacement,requested_url,final_url,navigation_initiator_url,@@ -1961,6 +1964,7 @@ impl NavigationEngine {pub async fn prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(&mut self,page_reservation: moli_renderer_v8::RendererPageReservationToken,+ replacement: Option<RendererDocumentReplacement>,storage: NavigationPageStorageHandles,requested_url: Url,final_url: Url,@@ -1993,6 +1997,7 @@ impl NavigationEngine {storage.into_parts();self.prepare_streaming_raw_page_from_external_body_async(page_reservation,+ replacement,cookie_store,web_storage,indexed_db_manager,@@ -2099,6 +2104,7 @@ impl NavigationEngine {async fn prepare_document_page_from_response_options_best_effort_async(&mut self,page_reservation: moli_renderer_v8::RendererPageReservationToken,+ replacement: Option<RendererDocumentReplacement>,cookie_store: SharedBrowserCookieStore,web_storage: RendererWebStorageHandles,indexed_db_manager: Option<WeakIndexedDbManager>,@@ -2110,6 +2116,7 @@ impl NavigationEngine {ExternalRawDocumentBodyStream::from_bytes(options.response_body.into_bytes());self.prepare_streaming_raw_page_from_external_body_async(page_reservation,+ replacement,cookie_store,web_storage,indexed_db_manager,@@ -2156,6 +2163,7 @@ impl NavigationEngine {let prepared = self.prepare_document_page_from_response_options_best_effort_async(page_reservation,+ None,cookie_store,web_storage,indexed_db_manager,@@ -2172,6 +2180,7 @@ impl NavigationEngine {pub async fn prepare_document_page_from_response_with_storage_and_inspector_session_restores_async(&mut self,page_reservation: moli_renderer_v8::RendererPageReservationToken,+ replacement: Option<RendererDocumentReplacement>,storage: NavigationPageStorageHandles,requested_url: Url,final_url: Url,@@ -2201,6 +2210,7 @@ impl NavigationEngine {storage.into_parts();self.prepare_document_page_from_response_options_best_effort_async(page_reservation,+ replacement,cookie_store,web_storage,indexed_db_manager,diff --git a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rsindex 6b4f68bf6..b462404e8 100644--- a/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs+++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs@@ -331,22 +331,43 @@ async fn assert_delayed_navigation_while_paused(supersede: bool) {#[tokio::test]async fn navigation_cancellation_at_request_stage_preserves_the_paused_document_and_debugger() {- assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel).await;+ assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel, None).await;}#[tokio::test]async fn navigation_cancellation_at_response_stage_preserves_the_paused_document_and_debugger() {- assert_intercepted_navigation_while_paused("Response", InterceptionAction::Cancel).await;+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Cancel, None).await;}#[tokio::test]async fn navigation_continues_an_intercepted_response_while_debugger_is_paused() {- assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue).await;+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue, None)+ .await;}#[tokio::test]async fn navigation_fulfills_an_intercepted_response_while_debugger_is_paused() {- assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill).await;+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill, None).await;+}++#[tokio::test]+async fn stale_response_continuation_preserves_the_paused_document_and_debugger() {+ assert_intercepted_navigation_while_paused(+ "Response",+ InterceptionAction::Cancel,+ Some(InterceptionAction::Continue),+ )+ .await;+}++#[tokio::test]+async fn stale_response_fulfillment_preserves_the_paused_document_and_debugger() {+ assert_intercepted_navigation_while_paused(+ "Response",+ InterceptionAction::Cancel,+ Some(InterceptionAction::Fulfill),+ )+ .await;}#[derive(Clone, Copy)]@@ -356,9 +377,31 @@ enum InterceptionAction {Fulfill,}+impl InterceptionAction {+ fn command(self, request_id: serde_json::Value) -> (&'static str, serde_json::Value) {+ match self {+ Self::Cancel => (+ "Fetch.failRequest",+ json!({"requestId": request_id, "errorReason": "Aborted"}),+ ),+ Self::Continue => ("Fetch.continueResponse", json!({"requestId": request_id})),+ Self::Fulfill => (+ "Fetch.fulfillRequest",+ json!({+ "requestId": request_id,+ "responseCode": 200,+ "responseHeaders": [{"name": "Content-Type", "value": "text/html"}],+ "body": "PHRpdGxlPmZ1bGZpbGxlZDwvdGl0bGU+"+ }),+ ),+ }+ }+}+async fn assert_intercepted_navigation_while_paused(request_stage: &str,action: InterceptionAction,+ stale_response: Option<InterceptionAction>,) {let (fixture_addr, fixture) = spawn_dedicated_fixture_server(Router::new().route(@@ -413,32 +456,49 @@ async fn assert_intercepted_navigation_while_paused(message["method"] == "Fetch.requestPaused"}).await;- let request_id = intercepted+ let mut request_id = intercepted.iter().find(|message| message["method"] == "Fetch.requestPaused").unwrap()["params"]["requestId"].clone();- let (method, params) = match action {- InterceptionAction::Cancel => (- "Fetch.failRequest",- json!({"requestId": request_id, "errorReason": "Aborted"}),- ),- InterceptionAction::Continue => {- ("Fetch.continueResponse", json!({"requestId": request_id}))- }- InterceptionAction::Fulfill => (- "Fetch.fulfillRequest",- json!({- "requestId": request_id,- "responseCode": 200,- "responseHeaders": [{"name": "Content-Type", "value": "text/html"}],- "body": "PHRpdGxlPmZ1bGZpbGxlZDwvdGl0bGU+"- }),- ),+ let navigation_id = if let Some(stale_action) = stale_response {+ send_cdp_command_without_wait(+ &mut socket,+ 20,+ "Page.navigate",+ Some(&session_id),+ json!({"url": format!("http://{fixture_addr}/?replacement")}),+ )+ .await;+ let replacement = recv_until_match(&mut socket, |message| {+ message["method"] == "Fetch.requestPaused"+ })+ .await;+ let replacement_id = replacement+ .iter()+ .find(|message| message["method"] == "Fetch.requestPaused")+ .unwrap()["params"]["requestId"]+ .clone();+ assert_ne!(request_id, replacement_id);+ let (method, params) = stale_action.command(request_id);+ let stale = send_cdp_command(&mut socket, 21, method, Some(&session_id), params).await;+ assert!(+ stale+ .iter()+ .any(|message| message["id"] == 21 && message.get("error").is_none())+ );+ request_id = replacement_id;+ 20+ } else {+ 9};+ let (method, params) = action.command(request_id);let mut completed = send_cdp_command(&mut socket, 10, method, Some(&session_id), params).await;- if !completed.iter().any(|message| message["id"] == 9) {- completed.extend(recv_until_id(&mut socket, 9).await);+ if !completed+ .iter()+ .any(|message| message["id"] == navigation_id)+ {+ completed.extend(recv_until_id(&mut socket, navigation_id).await);}assert!(completed@@ -471,7 +531,7 @@ async fn assert_intercepted_navigation_while_paused(assert!(completed.iter()- .any(|message| message["id"] == 9 && message.get("error").is_none())+ .any(|message| message["id"] == navigation_id && message.get("error").is_none()));if !completed.iter()diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 8fedb47d1..4dda1e1a6 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -2830,12 +2830,7 @@ impl CdpConnection {stage = "materialized_completion_drain_start",);}- let is_current = completion.is_current_for_connection(self);let (token, state, navigation) = completion.into_parts();- if !is_current {- crate::domains::page::push_superseded_navigation_result(out, &state);- return;- }crate::domains::page::complete_materialized_navigation_into_buffer_async(self,out,diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex 5a3444f81..7b2697428 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -181,16 +181,10 @@ pub(crate) struct TargetNavigationLoadInputs {pub(crate) permission_overrides: Vec<moli_core::page::PermissionOverrideRegistration>,main_document_commit_seed: Option<RendererMainDocumentCommitSeed>,session_history_position: Option<moli_session_history::SessionHistoryPosition>,- renderer_navigation: Option<(moli_core::page::RendererDevToolsTargetHandle, u64)>,+ pub(crate) document_replacement: Option<moli_core::runtime::RendererDocumentReplacement>,}impl TargetNavigationLoadInputs {- pub(crate) fn prepare_to_replace_document(&self) {- if let Some((target, request_id)) = &self.renderer_navigation {- target.navigation_response_ready(*request_id);- }- }-pub(crate) fn with_main_document_commit_seed(mut self,seed: RendererMainDocumentCommitSeed,@@ -353,7 +347,7 @@ impl TargetNavigationLoadInputs {.navigation_history_state.position_after_navigation(),),- renderer_navigation: target.runtime_slot().page_slot().renderer_navigation(),+ document_replacement: None,}}@@ -420,7 +414,7 @@ impl TargetNavigationLoadInputs {permission_overrides: Vec::new(),main_document_commit_seed: None,session_history_position: None,- renderer_navigation: None,+ document_replacement: None,}}diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rsindex 9065ce5fa..9aa4adc0e 100644--- a/moli-protocol/src/conn/fetch_support.rs+++ b/moli-protocol/src/conn/fetch_support.rs@@ -1152,7 +1152,13 @@ impl PausedDocumentTransfer {} => {let navigation_state = navigation.clone();let navigation = body- .continue_navigation_async(conn, &navigation, response_code, response_headers)+ .continue_navigation_async(+ conn,+ document_navigation_token.as_ref(),+ &navigation,+ response_code,+ response_headers,+ ).await;Ok((document_navigation_token, navigation_state, navigation))}@@ -1185,6 +1191,7 @@ impl PausedDocumentTransfer {let navigation_state = navigation.clone();let navigation = conn.build_navigation_from_buffered_body_source_for_navigation_async(+ document_navigation_token.as_ref(),&navigation,navigation.requested_url.clone(),response_code,@@ -1316,6 +1323,7 @@ impl ActiveDocumentBodyStreamState {let final_url = self.response.final_url.clone();let navigation = conn.build_navigation_from_buffered_body_source_for_navigation_async(+ self.document_navigation_token.as_ref(),&self.navigation,final_url,response_code,@@ -1490,6 +1498,7 @@ impl DocumentBodySource {pub(crate) async fn continue_navigation_async(self,conn: &mut CdpConnection,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,response_code: Option<u16>,response_headers: Vec<(String, Vec<u8>)>,@@ -1503,6 +1512,7 @@ impl DocumentBodySource {} => {if !has_response_override {conn.build_navigation_from_buffered_raw_response_for_navigation_async(+ token,navigation,NetworkFetchResult::with_observation_journal(response,@@ -1521,6 +1531,7 @@ impl DocumentBodySource {.expect("RawResponse body should remain materialized at the response override boundary");let body = CapturedBody::from_bytes(body);conn.build_navigation_from_buffered_body_source_for_navigation_async(+ token,navigation,final_url,response_code.unwrap_or(status),@@ -1544,6 +1555,7 @@ impl DocumentBodySource {..} => {conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(+ token,navigation,NetworkFetchResult::with_observation_journal(response,@@ -1564,6 +1576,7 @@ impl DocumentBodySource {} => {if !has_response_override {conn.build_navigation_from_captured_raw_response_for_navigation_async(+ token,navigation,head,body,@@ -1577,6 +1590,7 @@ impl DocumentBodySource {let final_url = head.final_url.clone();let request_cookie_report = head.request_cookie_report.clone();conn.build_navigation_from_buffered_body_source_for_navigation_async(+ token,navigation,final_url,response_code.unwrap_or(status),diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rsindex a20b57f07..1cfc9324e 100644--- a/moli-protocol/src/conn/runtime_load.rs+++ b/moli-protocol/src/conn/runtime_load.rs@@ -1298,7 +1298,6 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(None};- load_inputs.prepare_to_replace_document();if response_headers_indicate_xml_document(&response_headers) {let redirected = response.redirected;let mut body_writer = CapturedBodyWriter::default();@@ -1330,6 +1329,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(let prepared_page = engine.prepare_document_page_from_response_with_storage_and_inspector_session_restores_async(page_reservation,+ load_inputs.document_replacement.clone(),page_storage.into_navigation_storage(),requested_url.clone(),final_url.clone(),@@ -1399,6 +1399,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(let prepared_future = engine.prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(page_reservation,+ load_inputs.document_replacement.clone(),page_storage.into_navigation_storage(),requested_url.clone(),final_url.clone(),@@ -1477,6 +1478,30 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(impl CdpConnection {fn navigation_load_inputs_for_navigation(+ &self,+ token: Option<&DocumentNavigationToken>,+ navigation: &NavigationDispatchState,+ ) -> anyhow::Result<TargetNavigationLoadInputs> {+ let token = token+ .filter(|token| {+ token.target_id == navigation.frame_id+ && token.loader_id == navigation.loader_id+ && self.accepts_pending_document_navigation_for_owner(&navigation.owner, token)+ })+ .ok_or_else(|| anyhow::anyhow!(moli_fetch::NET_ERR_ABORTED_ERROR_TEXT))?;+ let mut inputs = self.navigation_request_load_inputs(navigation);+ inputs.document_replacement = self+ .runtime_session_owner_slot_for_owner(&navigation.owner)+ .ok()+ .and_then(|slot| {+ let page_slot = slot.page_slot();+ let cancellation = page_slot.document_navigation_cancellation_handle(token)?;+ Some(page_slot.loaded_page()?.document_replacement(cancellation))+ });+ Ok(inputs)+ }++ fn navigation_request_load_inputs(&self,navigation: &NavigationDispatchState,) -> TargetNavigationLoadInputs {@@ -2093,12 +2118,13 @@ impl CdpConnection {pub(crate) async fn load_navigation_request_via_runtime_with_network_events_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,body_progress_source: MainDocumentBodyProgressSource,) -> anyhow::Result<NavigationLoadOutcome> {self.load_navigation_request_via_runtime_with_network_events_and_load_inputs_async(&navigation.owner,- self.navigation_load_inputs_for_navigation(navigation),+ self.navigation_load_inputs_for_navigation(token, navigation)?,&navigation.request_method,navigation.requested_url.as_str(),navigation.clone_request_body_bytes(),@@ -2111,6 +2137,7 @@ impl CdpConnection {pub(crate) async fn prepare_navigation_load_error_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,error: anyhow::Error,) -> anyhow::Result<NavigationLoadOutcome> {@@ -2118,7 +2145,7 @@ impl CdpConnection {return Err(error);};- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;let mut engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);let page_reservation =self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);@@ -2245,7 +2272,9 @@ impl CdpConnection {early_result: Option<BackgroundNavigationEarlyResult>,) -> Option<BackgroundNavigationLoadJob> {let cancellation = self.document_navigation_cancellation_handle(token)?;- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self+ .navigation_load_inputs_for_navigation(Some(token), navigation)+ .ok()?;// Ensure the target's resident browser resource runtime exists before// cloning its engine handle. The job shares the target Page policy and// retains this exact transport/cache owner for the captured navigation.@@ -2288,20 +2317,28 @@ impl CdpConnection {pub(crate) fn background_streaming_response_navigation_load_job_for_navigation(&mut self,+ token: &DocumentNavigationToken,navigation: &NavigationDispatchState,response: StreamingRawResponse,network_observation_journal: NetworkObservationJournal,response_code: Option<u16>,response_headers_override: Vec<(String, Vec<u8>)>,body_progress_source: MainDocumentBodyProgressSource,- ) -> BackgroundStreamingResponseNavigationLoadJob {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ ) -> Option<BackgroundStreamingResponseNavigationLoadJob> {+ // Reject stale work before reserving a renderer Page or arming completion.+ // Dropping the rejected response cancels only its own transport.+ let load_inputs = self+ .navigation_load_inputs_for_navigation(Some(token), navigation)+ .ok()?;+ if !self.arm_background_navigation_completion(token, Some(response.cancellation_handle())) {+ return None;+ }let shared_resource_runtime =self.shared_resource_runtime_for_navigation_load_inputs(&load_inputs);let engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);let page_reservation =self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);- BackgroundStreamingResponseNavigationLoadJob {+ Some(BackgroundStreamingResponseNavigationLoadJob {engine,page_reservation,load_inputs,@@ -2314,7 +2351,7 @@ impl CdpConnection {response_headers_override,body_progress_source,shared_resource_runtime,- }+ })}/// Reserves and binds the exact future Page before detached navigation work@@ -2639,6 +2676,7 @@ impl CdpConnection {pub(crate) async fn build_navigation_from_buffered_body_source_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,final_url: Url,response_status: u16,@@ -2648,7 +2686,7 @@ impl CdpConnection {network_observation_journal: NetworkObservationJournal,body_progress_source: MainDocumentBodyProgressSource,) -> anyhow::Result<NavigationLoadOutcome> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;self.build_navigation_from_buffered_body_source_with_load_inputs_async(&navigation.owner,&load_inputs,@@ -2849,7 +2887,7 @@ impl CdpConnection {navigation: &NavigationDispatchState,auth: SubresourceAuthCredentials,) -> anyhow::Result<NetworkFetchResult<RawResponse>> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_request_load_inputs(navigation);let method = &navigation.request_method;let raw_url = navigation.requested_url.as_str();let body = navigation.clone_request_body_bytes();@@ -2916,7 +2954,7 @@ impl CdpConnection {navigation: &NavigationDispatchState,auth: Option<SubresourceAuthCredentials>,) -> anyhow::Result<NetworkFetchResult<StreamingRawResponse>> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_request_load_inputs(navigation);self.fetch_navigation_streaming_raw_response_with_load_inputs_async(&load_inputs,&navigation.request_method,@@ -3149,10 +3187,11 @@ impl CdpConnection {pub(crate) async fn build_navigation_from_buffered_raw_response_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,response: NetworkFetchResult<RawResponse>,) -> anyhow::Result<NavigationLoadOutcome> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;self.build_navigation_from_buffered_raw_response_with_load_inputs_async(&navigation.owner,&load_inputs,@@ -3204,13 +3243,14 @@ impl CdpConnection {pub(crate) async fn build_navigation_from_captured_raw_response_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,head: ResponseHead,body: CapturedBody,network_observation_journal: NetworkObservationJournal,body_progress_source: MainDocumentBodyProgressSource,) -> anyhow::Result<NavigationLoadOutcome> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;self.build_navigation_from_captured_raw_response_with_load_inputs_async(&navigation.owner,&load_inputs,@@ -3343,11 +3383,12 @@ impl CdpConnection {pub(crate) async fn build_navigation_from_streaming_raw_response_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,response: NetworkFetchResult<StreamingRawResponse>,body_progress_source: MainDocumentBodyProgressSource,) -> anyhow::Result<NavigationLoadOutcome> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;self.build_navigation_from_streaming_raw_response_with_load_inputs_async(&navigation.owner,&load_inputs,@@ -3364,13 +3405,14 @@ impl CdpConnection {pub(crate) async fn build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(&mut self,+ token: Option<&DocumentNavigationToken>,navigation: &NavigationDispatchState,response: NetworkFetchResult<StreamingRawResponse>,response_code: Option<u16>,response_headers_override: Vec<(String, Vec<u8>)>,body_progress_source: MainDocumentBodyProgressSource,) -> anyhow::Result<NavigationLoadOutcome> {- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);+ let load_inputs = self.navigation_load_inputs_for_navigation(token, navigation)?;self.build_navigation_from_streaming_raw_response_with_load_inputs_async(&navigation.owner,&load_inputs,@@ -3598,7 +3640,6 @@ async fn prepare_captured_document_response_with_engine_async(synthetic_body: bool,reply_boundary: RendererReplyBoundary,) -> anyhow::Result<ResponseCommitReady> {- load_inputs.prepare_to_replace_document();let network_extra_info_available = !network_observation_journal.is_empty();body_progress_source.emit_response_metadata(&request_method,@@ -3656,6 +3697,7 @@ async fn prepare_captured_document_response_with_engine_async(let prepared_future = engine.prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(page_reservation,+ load_inputs.document_replacement.clone(),page_storage.into_navigation_storage(),requested_url.clone(),final_url.clone(),diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rsindex f1fd8bae8..163b7770f 100644--- a/moli-protocol/src/conn/state/attachment_identity.rs+++ b/moli-protocol/src/conn/state/attachment_identity.rs@@ -36,10 +36,6 @@ impl TargetPageAttachmentId {pub(crate) struct NavigationRequestId(NonZeroU64);impl NavigationRequestId {- pub(crate) fn get(self) -> u64 {- self.0.get()- }-pub(crate) fn allocate() -> Self {Self(allocate_nonzero_u64(&NEXT_NAVIGATION_REQUEST_ID,diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rsindex c9e3765a2..31d323344 100644--- a/moli-protocol/src/conn/state/page_slot.rs+++ b/moli-protocol/src/conn/state/page_slot.rs@@ -84,24 +84,16 @@ pub(crate) struct PendingNavigationRequest {cancellation_handles: Vec<moli_fetch::FetchCancelHandle>,background_completion_pending: bool,committed: bool,- renderer_target: Option<moli_core::page::RendererDevToolsTargetHandle>,}impl PendingNavigationRequest {- fn new(- token: DocumentNavigationToken,- renderer_target: Option<moli_core::page::RendererDevToolsTargetHandle>,- ) -> Self {- if let Some(target) = &renderer_target {- target.navigation_started(token.request_id.get());- }+ fn new(token: DocumentNavigationToken) -> Self {Self {token,page_attachment_id: TargetPageAttachmentId::allocate(),cancellation_handles: vec![moli_fetch::FetchCancelHandle::new()],background_completion_pending: false,committed: false,- renderer_target,}}@@ -135,14 +127,7 @@ impl PendingNavigationRequest {self.cancellation_handles.clear();}- fn finish_renderer_navigation(&mut self) {- if let Some(target) = self.renderer_target.take() {- target.navigation_finished(self.token.request_id.get());- }- }-fn cancel(&mut self) {- self.finish_renderer_navigation();for cancellation in self.cancellation_handles.drain(..) {cancellation.cancel();}@@ -683,24 +668,10 @@ impl TargetPageSlot {};self.pending_renderer_page = None;self.cancel_pending_document_navigation();- let renderer_target = self.loaded_page().map(Page::renderer_devtools_target);- self.pending_navigation_request = Some(PendingNavigationRequest::new(- token.clone(),- renderer_target,- ));+ self.pending_navigation_request = Some(PendingNavigationRequest::new(token.clone()));token}- pub(crate) fn renderer_navigation(- &self,- ) -> Option<(moli_core::page::RendererDevToolsTargetHandle, u64)> {- let request = self.pending_navigation_request.as_ref()?;- Some((- request.renderer_target.clone()?,- request.token.request_id.get(),- ))- }-fn cancel_pending_document_navigation(&mut self) {if let Some(mut request) = self.pending_navigation_request.take() {request.cancel();@@ -864,7 +835,6 @@ impl TargetPageSlot {};self.committed_document_navigation = Some(token.clone());request.committed = true;- request.finish_renderer_navigation();if !request.background_completion_pending {request.retire_without_cancellation();self.pending_navigation_request = None;diff --git a/moli-protocol/src/conn/tests/mod.rs b/moli-protocol/src/conn/tests/mod.rsindex 55d053d9a..5ac234020 100644--- a/moli-protocol/src/conn/tests/mod.rs+++ b/moli-protocol/src/conn/tests/mod.rs@@ -1568,18 +1568,32 @@ fn navigation_background_event_sender_preserves_typed_sidecar_for_current_token(#[tokio::test]async fn materialized_navigation_completion_drops_stale_token() {+ assert_stale_completion_retires_renderer_suspension(false).await;+}++#[tokio::test]+async fn stale_navigation_completion_releases_renderer_after_current_navigation_finishes() {+ assert_stale_completion_retires_renderer_suspension(true).await;+}++async fn assert_stale_completion_retires_renderer_suspension(finish_current_first: bool) {let mut conn = CdpConnection::new();let mut browser_context = BrowserContext::new("CTX-nav".to_owned());browser_context.set_active_target_id("TID-nav");let stale = browser_context.start_document_navigation_for_active_target("LOADER-1".to_owned()).expect("active target should produce stale token");- let _current = browser_context+ let current = browser_context.start_document_navigation_for_active_target("LOADER-2".to_owned()).expect("active target should produce current token");conn.install_browser_context_fixture_for_test(browser_context);let state =materialized_navigation_test_state(Some(7), "LOADER-1", "https://example.test/stale");+ let owner = state.owner.clone();+ if finish_current_first {+ conn.finish_renderer_document_navigation_for_owner(&owner, ¤t)+ .unwrap();+ }let navigation =MaterializedNavigationLoadOutcome::Failed(MaterializedFailedDocumentProgress {error_text: "stale navigation should not emit".to_owned(),@@ -1616,6 +1630,13 @@ async fn materialized_navigation_completion_drops_stale_token() {reply.get("method").is_none(),"stale completion must emit a command reply, not an event");+ assert!(conn.accepts_pending_document_navigation_for_owner(&owner, ¤t));+ if !finish_current_first {+ assert!(conn.renderer_document_navigation_is_suspended_for_session_owner(None));+ conn.finish_renderer_document_navigation_for_owner(&owner, ¤t)+ .unwrap();+ }+ assert!(!conn.renderer_document_navigation_is_suspended_for_session_owner(None));}#[tokio::test]diff --git a/moli-protocol/src/conn/tests/navigation_error.rs b/moli-protocol/src/conn/tests/navigation_error.rsindex 7e85b99f1..f6bf27262 100644--- a/moli-protocol/src/conn/tests/navigation_error.rs+++ b/moli-protocol/src/conn/tests/navigation_error.rs@@ -1,7 +1,7 @@use super::*;use crate::conn::{- CommandOwnerScope, NavigationLoadOutcome, NavigationNetworkError, NavigationNetworkErrorKind,- NavigationRequestLoadPolicy,+ CommandOwnerScope, DocumentNavigationToken, NavigationLoadOutcome, NavigationNetworkError,+ NavigationNetworkErrorKind, NavigationRequestLoadPolicy,};use moli_core::page::{SubresourceAuthCredentials, SubresourceAuthScheme, SubresourceAuthTarget};@@ -45,7 +45,7 @@ fn failing_streamed_document(#[tokio::test]async fn fetch_body_materialization_preserves_error_type_and_request_identity() {- let (_ctx, navigation) = navigation_fixture();+ let (_ctx, _token, navigation) = navigation_fixture();let (error, body) = failing_streamed_document(&navigation).materialize_body_limited_async(1024).await@@ -75,7 +75,7 @@ async fn fetch_body_materialization_preserves_error_type_and_request_identity()#[tokio::test]async fn fetch_body_stream_read_preserves_error_type_and_paused_transfer() {- let (_ctx, navigation) = navigation_fixture();+ let (_ctx, _token, navigation) = navigation_fixture();let body = failing_streamed_document(&navigation);let transfer = crate::conn::PausedDocumentTransfer::pending("fetch-typed-error".to_owned(),@@ -102,12 +102,16 @@ async fn fetch_body_stream_read_preserves_error_type_and_paused_transfer() {assert!(format!("{error:#}").contains("failed to read page body from stream"));}-fn navigation_fixture() -> (TestContext, NavigationDispatchState) {+fn navigation_fixture() -> (+ TestContext,+ DocumentNavigationToken,+ NavigationDispatchState,+) {let mut ctx = TestContext::new();let mut browser_context = BrowserContext::new("BID-1".to_owned());browser_context.set_active_target_id("TID-1");browser_context.attach_active_session("SID-1");- browser_context+ let token = browser_context.start_document_navigation_for_active_target("LID-test".to_owned()).expect("fixture navigation should start");ctx.conn@@ -134,12 +138,137 @@ fn navigation_fixture() -> (TestContext, NavigationDispatchState) {timestamp: 0.0,source_document_security: Default::default(),};- (ctx, navigation)+ (ctx, token, navigation)+}++fn streaming_response_job(+ conn: &mut CdpConnection,+ token: &DocumentNavigationToken,+ navigation: &NavigationDispatchState,+) -> (+ Option<crate::conn::runtime_load::BackgroundStreamingResponseNavigationLoadJob>,+ moli_fetch::FetchCancelHandle,+) {+ let crate::conn::DocumentBodySource::StreamingRaw { response, .. } =+ failing_streamed_document(navigation)+ else {+ unreachable!()+ };+ let cancellation = response.cancellation_handle();+ let job = conn.background_streaming_response_navigation_load_job_for_navigation(+ token,+ navigation,+ response,+ Default::default(),+ None,+ Vec::new(),+ Default::default(),+ );+ (job, cancellation)+}++#[tokio::test]+async fn document_navigation_cancellation_requires_the_exact_pending_token() {+ let (mut ctx, _, _) = navigation_fixture();+ ctx.install_navigation_fixture_for_session_owner("about:blank", Some("SID-1"))+ .await;+ let slot = ctx+ .conn+ .browser_context+ .as_mut()+ .unwrap()+ .active_page_target_mut()+ .runtime_slot+ .page_slot_mut();+ let first = slot.start_document_navigation("TID-1".to_owned(), "LID-test".to_owned());+ let first_cancellation = slot+ .document_navigation_cancellation_handle(&first)+ .unwrap();+ assert!(!first_cancellation.is_cancelled());+ let current = slot.start_document_navigation("TID-1".to_owned(), "LID-test".to_owned());+ assert!(first_cancellation.is_cancelled());++ for mismatch in [+ first,+ DocumentNavigationToken {+ target_id: "other target".to_owned(),+ ..current.clone()+ },+ DocumentNavigationToken {+ loader_id: "other loader".to_owned(),+ ..current.clone()+ },+ ] {+ assert!(+ slot.document_navigation_cancellation_handle(&mismatch)+ .is_none()+ );+ }+ let current_cancellation = slot+ .document_navigation_cancellation_handle(¤t)+ .unwrap();+ assert!(!current_cancellation.is_cancelled());+ assert!(slot.commit_pending_document_navigation_if_matches(¤t));+ assert!(+ slot.document_navigation_cancellation_handle(¤t)+ .is_none()+ );+ assert!(!current_cancellation.is_cancelled());+}++#[tokio::test]+async fn superseded_streaming_response_cannot_arm_the_current_navigation() {+ let (mut ctx, stale, navigation) = navigation_fixture();+ // Even reusing the target, loader and URL must not reuse a request's authority.+ let current = ctx+ .conn+ .browser_context+ .as_mut()+ .unwrap()+ .start_document_navigation_for_active_target(navigation.loader_id.clone())+ .unwrap();+ let current_cancellation = ctx+ .conn+ .document_navigation_cancellation_handle(¤t)+ .unwrap();+ assert_ne!(stale.request_id, current.request_id);++ let (job, stale_cancellation) = streaming_response_job(&mut ctx.conn, &stale, &navigation);+ assert!(+ job.is_none(),+ "stale responses must not create renderer preparation jobs"+ );+ assert!(stale_cancellation.is_cancelled());+ assert!(!current_cancellation.is_cancelled());+ assert!(!ctx.conn.has_inflight_background_navigation());++ let (job, _) = streaming_response_job(&mut ctx.conn, ¤t, &navigation);+ assert!(+ job.is_some(),+ "the matching response must still be accepted"+ );+ assert!(ctx.conn.has_inflight_background_navigation());+}++#[tokio::test]+async fn duplicate_streaming_response_does_not_cancel_the_armed_navigation() {+ let (mut ctx, token, navigation) = navigation_fixture();+ let (first, first_cancellation) = streaming_response_job(&mut ctx.conn, &token, &navigation);+ assert!(first.is_some());+ let (duplicate, duplicate_cancellation) =+ streaming_response_job(&mut ctx.conn, &token, &navigation);+ assert!(+ duplicate.is_none(),+ "an already armed request must not spawn another job"+ );+ assert!(duplicate_cancellation.is_cancelled());+ assert!(!first_cancellation.is_cancelled());+ assert!(ctx.conn.has_inflight_background_navigation());}#[tokio::test(flavor = "multi_thread")]async fn offline_navigation_loaders_preserve_typed_error_causes_through_context() {- let (mut ctx, mut navigation) = navigation_fixture();+ let (mut ctx, token, mut navigation) = navigation_fixture();navigation.request_method = "POST".to_owned();navigation.request_headers =moli_fetch::RequestHeaders::from_bytes(vec![("x-request".to_owned(), vec![0xe9, 0xff])]);@@ -161,6 +290,7 @@ async fn offline_navigation_loaders_preserve_typed_error_causes_through_context(let errors = [ctx.conn.load_navigation_request_via_runtime_with_network_events_for_navigation_async(+ Some(&token),&navigation,Default::default(),)@@ -211,7 +341,7 @@ async fn offline_navigation_loaders_preserve_typed_error_causes_through_context(#[tokio::test(flavor = "multi_thread")]async fn navigation_error_document_uses_typed_failure_request_after_context() {- let (mut ctx, navigation) = navigation_fixture();+ let (mut ctx, token, navigation) = navigation_fixture();let unreachable_url = Url::parse("https://overridden.example/unreachable").unwrap();let request_headers = vec![("x-request".to_owned(), "overridden-request".to_owned())];let error = anyhow::Error::new(NavigationNetworkError {@@ -224,7 +354,7 @@ async fn navigation_error_document_uses_typed_failure_request_after_context() {.context("failed to continue intercepted navigation");let outcome = ctx.conn- .prepare_navigation_load_error_for_navigation_async(&navigation, error)+ .prepare_navigation_load_error_for_navigation_async(Some(&token), &navigation, error).await.expect("typed network failure should prepare an error document");let NavigationLoadOutcome::ResponseCommitReady(prepared) = outcome else {@@ -247,7 +377,7 @@ async fn navigation_error_document_uses_typed_failure_request_after_context() {#[tokio::test(flavor = "multi_thread")]async fn navigation_error_boundary_does_not_classify_display_text_as_network_failure() {- let (mut ctx, navigation) = navigation_fixture();+ let (mut ctx, token, navigation) = navigation_fixture();for error in [anyhow::anyhow!(OFFLINE_ERROR_TEXT),anyhow::anyhow!(OFFLINE_ERROR_TEXT)@@ -257,7 +387,7 @@ async fn navigation_error_boundary_does_not_classify_display_text_as_network_failet expected_chain = format!("{error:#}");let error = ctx.conn- .prepare_navigation_load_error_for_navigation_async(&navigation, error)+ .prepare_navigation_load_error_for_navigation_async(Some(&token), &navigation, error).await.expect_err("a matching display string must remain a non-network error");assert!(error.downcast_ref::<NavigationNetworkError>().is_none());diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rsindex 4141f8cfc..aa9247ee7 100644--- a/moli-protocol/src/conn/tests/resource_runtime.rs+++ b/moli-protocol/src/conn/tests/resource_runtime.rs@@ -91,7 +91,7 @@ async fn buffered_navigation_for_inactive_session_retains_its_target_engine() {target_context.set_active_target_id("TID-target");target_context.attach_active_session("SID-target");target_context.begin_active_target_initial_empty_document("about:blank".to_owned());- target_context+ let token = target_context.start_document_navigation_for_active_target("LOADER-target".to_owned()).expect("target should accept its synthetic navigation");conn.push_inactive_browser_context_fixture_for_test(target_context);@@ -128,6 +128,7 @@ async fn buffered_navigation_for_inactive_session_retains_its_target_engine() {let outcome = conn.build_navigation_from_buffered_body_source_for_navigation_async(+ Some(&token),&navigation,requested_url,200,diff --git a/moli-protocol/src/domains/fetch/commands.rs b/moli-protocol/src/domains/fetch/commands.rsindex 1c5887273..6a4d2bce4 100644--- a/moli-protocol/src/domains/fetch/commands.rs+++ b/moli-protocol/src/domains/fetch/commands.rs@@ -1199,6 +1199,7 @@ pub(super) async fn complete_fulfill_request_command_async(let navigation_state = pending.navigation;let navigation = conn.build_navigation_from_buffered_body_source_for_navigation_async(+ token.as_ref(),&navigation_state,navigation_state.requested_url.clone(),response_code,@@ -1873,16 +1874,28 @@ fn continue_streaming_document_response_in_background(network_observation_journal,body_progress_source,} = pending;- let cancellation = response.cancellation_handle();- let job = conn.background_streaming_response_navigation_load_job_for_navigation(+ let Some(job) = conn.background_streaming_response_navigation_load_job_for_navigation(+ &document_navigation_token,&navigation,response,network_observation_journal,response_code,response_headers,body_progress_source,- );- conn.arm_background_navigation_completion(&document_navigation_token, Some(cancellation));+ ) else {+ // An already-armed current request keeps its original completion.+ if !conn.accepts_pending_document_navigation_for_owner(+ &navigation.owner,+ &document_navigation_token,+ ) {+ let _ = sender.send(page::BackgroundNavigationCompletion::new(+ document_navigation_token,+ navigation,+ Err(anyhow::anyhow!(moli_fetch::NET_ERR_ABORTED_ERROR_TEXT)),+ ));+ }+ return;+ };tokio::task::spawn_local(async move {let body_completion_sink = BackgroundNavigationBodyCompletionSink::new(sender.clone(),diff --git a/moli-protocol/src/domains/fetch/navigation.rs b/moli-protocol/src/domains/fetch/navigation.rsindex 9127d0740..a6ec8df84 100644--- a/moli-protocol/src/domains/fetch/navigation.rs+++ b/moli-protocol/src/domains/fetch/navigation.rs@@ -170,6 +170,7 @@ pub(crate) async fn load_or_pause_navigation_for_auth_into_buffer_async(} else {let navigation = conn.build_navigation_from_buffered_raw_response_for_navigation_async(+ pending.document_navigation_token.as_ref(),&pending.navigation,response,)@@ -224,6 +225,7 @@ pub(crate) async fn load_or_pause_navigation_for_auth_into_buffer_async(let navigation = conn.load_navigation_request_via_runtime_with_network_events_for_navigation_async(+ pending.document_navigation_token.as_ref(),&pending.navigation,network::MainDocumentBodyProgressSource::default(),)@@ -324,6 +326,7 @@ pub(super) async fn cancel_navigation_auth_as_background_events_async(pending.intercept_response = false;let navigation = conn.build_navigation_from_buffered_raw_response_for_navigation_async(+ pending.document_navigation_token.as_ref(),&pending.navigation,response,)@@ -410,6 +413,7 @@ async fn complete_pending_fetch_navigation_result_into_buffer_async(let navigation = match navigation {Err(error) => {Box::pin(conn.prepare_navigation_load_error_for_navigation_async(+ token.as_ref(),&navigation_state,error.context("failed to continue intercepted navigation"),))@@ -482,6 +486,7 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(if response_headers_indicate_attachment_download(&response_head.headers) {let navigation = conn.build_navigation_from_streaming_raw_response_for_navigation_async(+ pending.document_navigation_token.as_ref(),&pending.navigation,response,network::MainDocumentBodyProgressSource::default(),@@ -495,6 +500,7 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(if !prepare_navigation_response_stage(conn, &mut pending, &response_head.final_url) {let navigation = conn.build_navigation_from_streaming_raw_response_for_navigation_async(+ pending.document_navigation_token.as_ref(),&pending.navigation,response,network::MainDocumentBodyProgressSource::default(),diff --git a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rsindex a45cf0a97..47d5972d4 100644--- a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs+++ b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs@@ -840,6 +840,15 @@ async fn fulfill_request_commit_uses_configuration_added_while_paused_before_aut#[tokio::test(flavor = "multi_thread")]async fn interleaved_response_heads_only_commit_the_current_response() {+ assert_interleaved_response_heads(false).await;+}++#[tokio::test(flavor = "multi_thread")]+async fn interleaved_response_heads_preserve_the_current_debugger_pause() {+ assert_interleaved_response_heads(true).await;+}++async fn assert_interleaved_response_heads(pause_old_document: bool) {async fn first() -> impl IntoResponse {([(CONTENT_TYPE.as_str(), "text/html")],@@ -874,6 +883,21 @@ async fn interleaved_response_heads_only_commit_the_current_response() {.enable_primary_network_events();ctx.conn.install_browser_context_fixture_for_test(bc);+ if pause_old_document {+ ctx.install_navigation_fixture_for_session_owner(+ "data:text/html,<title>old document</title>",+ Some("SID-1"),+ )+ .await;+ ctx.process_async(json!({+ "id": 360,+ "method": "Debugger.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.sent.clear();+ }+ctx.process_async(json!({"id": 364,"method": "Fetch.enable",@@ -889,6 +913,23 @@ async fn interleaved_response_heads_only_commit_the_current_response() {.await;ctx.expect_result(364, json!({}), Some("SID-1"));+ if pause_old_document {+ ctx.process_async(json!({+ "id": 361,+ "method": "Runtime.evaluate",+ "sessionId": "SID-1",+ "params": {+ "expression": "setTimeout(() => { debugger; globalThis.resumedNormally = true; }, 0)"+ }+ }))+ .await;+ ctx.wait_for_scheduler_message("old document debugger pause", |message| {+ message["method"] == "Debugger.paused"+ })+ .await;+ ctx.sent.clear();+ }+ctx.process_async(json!({"id": 365,"method": "Page.navigate",@@ -947,11 +988,8 @@ async fn interleaved_response_heads_only_commit_the_current_response() {.await;ctx.expect_result(367, json!({}), Some("SID-1"));let superseded = take_response_by_id(&mut ctx, 365);- assert_eq!(superseded["error"]["code"], -32000);- assert_eq!(- superseded["error"]["message"],- "renderer channel navigation was superseded by a newer navigation"- );+ assert!(superseded.get("error").is_none());+ assert_eq!(superseded["result"]["errorText"], "net::ERR_ABORTED");assert_eq!(ctx.conn.browser_context.as_ref().and_then(|bc| bc.active_page_target()@@ -961,6 +999,55 @@ async fn interleaved_response_heads_only_commit_the_current_response() {"a superseded response head must not switch the renderer channel");+ if pause_old_document {+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .unwrap()+ .loaded_page()+ .unwrap()+ .runtime_inspector_pause_active(),+ "continuing stale A must not terminate the old document while B is intercepted"+ );+ ctx.process_async(json!({+ "id": 368,+ "method": "Fetch.failRequest",+ "sessionId": "SID-1",+ "params": { "requestId": second_request_id, "errorReason": "Aborted" }+ }))+ .await;+ ctx.expect_result(368, json!({}), Some("SID-1"));+ ctx.process_async(json!({+ "id": 369,+ "method": "Debugger.resume",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(369, json!({}), Some("SID-1"));+ ctx.process_async(json!({+ "id": 370,+ "method": "Runtime.evaluate",+ "sessionId": "SID-1",+ "params": {+ "expression": "document.title + ':' + globalThis.resumedNormally",+ "returnByValue": true+ }+ }))+ .await;+ assert_eq!(+ take_response_by_id(&mut ctx, 370)["result"]["result"]["value"],+ "old document:true"+ );+ assert!(+ !ctx.sent+ .iter()+ .any(|message| message["method"] == "Page.frameNavigated")+ );+ server.abort();+ return;+ }+ctx.process_async(json!({"id": 368,"method": "Fetch.continueResponse",diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rsindex 2e50aba8b..a1478aeb8 100644--- a/moli-protocol/src/domains/page/navigation.rs+++ b/moli-protocol/src/domains/page/navigation.rs@@ -403,10 +403,6 @@ impl MaterializedNavigationCompletion {}}- pub(crate) fn is_current_for_connection(&self, conn: &CdpConnection) -> bool {- conn.accepts_pending_document_navigation_for_owner(&self.state.owner, &self.token)- }-pub(crate) fn requested_url(&self) -> &str {self.state.requested_url.as_str()}@@ -3219,6 +3215,13 @@ pub(crate) async fn complete_materialized_navigation_into_buffer_async(navigation: network::MaterializedNavigationLoadOutcome,command_context: &mut crate::conn::CommandDispatchContext,) {+ if !conn.accepts_pending_document_navigation_for_owner(&state.owner, &token) {+ push_superseded_navigation_result(out, &state);+ // A stale response cannot commit or alter the current navigation, but+ // its exact renderer-channel suspension still needs to be retired.+ finish_renderer_navigation_into_buffer_async(conn, out, &state.owner, &token).await;+ return;+ }complete_materialized_navigation_into_buffer_inner_async(conn,out,@@ -3239,7 +3242,6 @@ async fn complete_materialized_navigation_into_buffer_inner_async(command_context: &mut crate::conn::CommandDispatchContext,) {let navigation_owner = state.owner.clone();- let navigation_session_id = navigation_owner.session_id().map(str::to_owned);let navigation_loader_id = state.loader_id.clone();match navigation {network::MaterializedNavigationLoadOutcome::ResponseCommitReady(navigation) => {@@ -3354,11 +3356,25 @@ async fn complete_materialized_navigation_into_buffer_inner_async(.emit_navigation_error_into_buffer(out, &error_text);}}+ finish_renderer_navigation_into_buffer_async(conn, out, &navigation_owner, &token).await;+ conn.clear_pending_document_navigation_for_owner_if_loader_matches(+ &navigation_owner,+ &navigation_loader_id,+ );+}++async fn finish_renderer_navigation_into_buffer_async(+ conn: &mut CdpConnection,+ out: &mut CommandOutputBuffer,+ owner: &CommandOwnerScope,+ token: &DocumentNavigationToken,+) {+ let navigation_session_id = owner.session_id().map(str::to_owned);let primary_protocol_session_id = conn- .runtime_session_owner_primary_session_id_for_owner(&navigation_owner)+ .runtime_session_owner_primary_session_id_for_owner(owner).or_else(|| navigation_session_id.clone());let (routed_renderer_output, renderer_call_replacements) = conn- .finish_renderer_document_navigation_for_owner(&navigation_owner, &token)+ .finish_renderer_document_navigation_for_owner(owner, token).map(|finish| (finish.released_output, finish.renderer_call_replacements)).unwrap_or_default();if !routed_renderer_output.is_empty() {@@ -3390,10 +3406,6 @@ async fn complete_materialized_navigation_into_buffer_inner_async(),}}- conn.clear_pending_document_navigation_for_owner_if_loader_matches(- &navigation_owner,- &navigation_loader_id,- );}fn push_navigation_commit_error(diff --git a/moli-renderer-v8/src/devtools/pause/loop_state.rs b/moli-renderer-v8/src/devtools/pause/loop_state.rsindex ff13b5af8..fe7ff1916 100644--- a/moli-renderer-v8/src/devtools/pause/loop_state.rs+++ b/moli-renderer-v8/src/devtools/pause/loop_state.rs@@ -21,7 +21,7 @@ pub(crate) enum RendererInspectorPauseLoopPolicy {#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub(crate) enum RendererInspectorPauseExitReason {Resumed,- Navigation,+ DocumentReplacement,SessionDetached,TargetClosed,}diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rsindex 58d1fe754..6159643be 100644--- a/moli-renderer-v8/src/devtools/pause/mod.rs+++ b/moli-renderer-v8/src/devtools/pause/mod.rs@@ -24,7 +24,6 @@ use crate::runtime::{mod causality;mod loop_state;-mod navigation;use causality::{RendererInspectorPauseCommandDispatch, RendererInspectorPauseCommandTransition,@@ -35,7 +34,6 @@ pub(crate) use causality::{};use loop_state::RendererInspectorPausePhase;pub(crate) use loop_state::{RendererInspectorPauseExitReason, RendererInspectorPauseLoopPolicy};-use navigation::RendererProvisionalLoad;#[derive(Clone)]pub(crate) struct RendererInspectorPauseBridge {@@ -58,7 +56,7 @@ struct RendererInspectorPauseBridgeState {pause_loop_policy: RendererInspectorPauseLoopPolicy,quit_requested: bool,session_detach_arms: usize,- provisional_load: Option<RendererProvisionalLoad>,+ document_replacements: usize,target_closed: bool,pending_prefaces: VecDeque<RendererInspectorPausePreface>,paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,@@ -128,7 +126,7 @@ impl RendererInspectorPauseBridge {pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo,quit_requested: false,session_detach_arms: 0,- provisional_load: None,+ document_replacements: 0,target_closed: false,pending_prefaces: VecDeque::new(),paused_sessions_awaiting_resumed: HashSet::new(),@@ -151,7 +149,7 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {.field("pause_loop_policy", &state.pause_loop_policy).field("quit_requested", &state.quit_requested).field("session_detach_arms", &state.session_detach_arms)- .field("provisional_load", &state.provisional_load)+ .field("document_replacements", &state.document_replacements).field("target_closed", &state.target_closed).field("pending_prefaces", &state.pending_prefaces.len()).field(@@ -364,6 +362,24 @@ impl RendererInspectorPauseBridge {Some(state.pause_loop_policy)}+ pub(crate) fn begin_document_replacement(&self) -> bool {+ let mut state = self.shared.state.lock();+ if state.target_closed {+ return false;+ }+ state.document_replacements += 1;+ self.shared.pause_loop_wake.notify_all();+ true+ }++ pub(crate) fn finish_document_replacement(&self) {+ let mut state = self.shared.state.lock();+ state.document_replacements = state+ .document_replacements+ .checked_sub(1)+ .expect("document replacement scope must be balanced");+ }+pub(crate) fn wait_for_pause_work<T>(&self,mut claim: impl FnMut() -> Option<T>,@@ -373,11 +389,8 @@ impl RendererInspectorPauseBridge {if state.target_closed {return Err(RendererInspectorPauseExitReason::TargetClosed);}- if matches!(- state.provisional_load,- Some(RendererProvisionalLoad::ReplacingDocument(_))- ) {- return Err(RendererInspectorPauseExitReason::Navigation);+ if state.document_replacements != 0 {+ return Err(RendererInspectorPauseExitReason::DocumentReplacement);}if state.session_detach_arms != 0 {return Err(RendererInspectorPauseExitReason::SessionDetached);diff --git a/moli-renderer-v8/src/devtools/pause/navigation.rs b/moli-renderer-v8/src/devtools/pause/navigation.rsdeleted file mode 100644index 07fcbc6aa..000000000--- a/moli-renderer-v8/src/devtools/pause/navigation.rs+++ /dev/null@@ -1,206 +0,0 @@-#[derive(Clone, Copy, Debug, Eq, PartialEq)]-pub(super) enum RendererProvisionalLoad {- WaitingForResponse(u64),- ReplacingDocument(u64),-}--impl RendererProvisionalLoad {- fn request_id(self) -> u64 {- match self {- Self::WaitingForResponse(id) | Self::ReplacingDocument(id) => id,- }- }-}--impl crate::devtools::target::RendererDevToolsTargetHandle {- /// Records the current navigation without disturbing a paused document.- /// The caller owns one current request and supplies its unique identity.- pub fn navigation_started(&self, request_id: u64) {- let mut state = self.pause_ref().shared.state.lock();- if !state.target_closed- && state- .provisional_load- .is_none_or(|load| load.request_id() != request_id)- {- state.provisional_load = Some(RendererProvisionalLoad::WaitingForResponse(request_id));- }- }-- /// Unblocks the old document only when this response will replace it.- /// A canceled or superseded load job cannot reactivate this policy.- pub fn navigation_response_ready(&self, request_id: u64) {- let pause = self.pause_ref();- let mut state = pause.shared.state.lock();- if !state.target_closed- && state.provisional_load- == Some(RendererProvisionalLoad::WaitingForResponse(request_id))- {- state.provisional_load = Some(RendererProvisionalLoad::ReplacingDocument(request_id));- pause.shared.pause_loop_wake.notify_all();- }- }-- /// Ends the matching provisional load at commit or cancellation. Retained- /// target handles have no effect on this document's debugger policy.- pub fn navigation_finished(&self, request_id: u64) {- let mut state = self.pause_ref().shared.state.lock();- if state- .provisional_load- .is_some_and(|load| load.request_id() == request_id)- {- state.provisional_load = None;- }- }-}--#[cfg(test)]-mod tests {- use super::super::{RendererInspectorPauseBridge, RendererInspectorPauseExitReason};- use crate::devtools::{- ingress::{io::RendererInspectorIoIngress, main::RendererInspectorMainIngress},- route::RendererInspectorSessionExecutorRouteId,- target::RendererDevToolsTargetHandle,- };-- fn target() -> RendererDevToolsTargetHandle {- let pause = RendererInspectorPauseBridge::default();- let main = RendererInspectorMainIngress::new(- RendererInspectorSessionExecutorRouteId::new(1),- pause.pause_loop_wake(),- );- let io = RendererInspectorIoIngress::new(pause.pause_loop_wake(), None);- RendererDevToolsTargetHandle::new(pause, main, io)- }-- fn assert_debugging_enabled(target: &RendererDevToolsTargetHandle) {- assert_eq!(target.pause_ref().wait_for_pause_work(|| Some(42)), Ok(42));- }-- fn assert_navigation_exit(target: &RendererDevToolsTargetHandle) {- assert_eq!(- target.pause_ref().wait_for_pause_work(|| Some(42)),- Err(RendererInspectorPauseExitReason::Navigation)- );- }-- #[test]- fn navigation_waits_for_response_and_duplicate_notifications_are_idempotent() {- let target = target();- assert_debugging_enabled(&target);- target.navigation_started(1);- assert_debugging_enabled(&target);- target.navigation_response_ready(1);- assert_navigation_exit(&target);- target.navigation_response_ready(1);- target.navigation_started(1);- assert_navigation_exit(&target);- target.navigation_finished(1);- target.navigation_finished(1);- assert_debugging_enabled(&target);- }-- #[test]- fn canceled_load_job_cannot_reactivate_pauses_even_with_a_retained_handle() {- for response_ready in [false, true] {- let target = target();- let job = target.clone();- target.navigation_started(1);- if response_ready {- job.navigation_response_ready(1);- }- target.navigation_finished(1);- assert_debugging_enabled(&job);- job.navigation_response_ready(1);- assert_debugging_enabled(&target);- }- }-- #[test]- fn superseded_response_and_completion_cannot_change_the_current_navigation() {- let target = target();- target.navigation_started(1);- target.navigation_response_ready(1);- target.navigation_started(2);- target.navigation_response_ready(1);- assert_debugging_enabled(&target);- target.navigation_response_ready(2);- target.navigation_finished(1);- assert_navigation_exit(&target);- target.navigation_finished(2);- assert_debugging_enabled(&target);- }-- #[test]- fn navigation_policy_is_document_local_and_handle_drop_does_not_finish_it() {- let first = target();- let second = target();- first.navigation_started(1);- first.navigation_response_ready(1);- drop(first.clone());- assert_navigation_exit(&first);- assert_debugging_enabled(&second);- second.navigation_finished(1);- assert_navigation_exit(&first);- }-- #[test]- fn pause_exit_reason_is_preserved_after_navigation_completion() {- let target = target();- target.navigation_started(1);- target.navigation_response_ready(1);- let reason = target.pause_ref().wait_for_pause_work(|| Some(42));- target.navigation_finished(1);- assert_eq!(reason, Err(RendererInspectorPauseExitReason::Navigation));- assert_debugging_enabled(&target);- }-- #[test]- fn closing_target_takes_precedence_and_late_notifications_cannot_reopen_it() {- let target = target();- target.navigation_started(1);- target.navigation_response_ready(1);- target.pause_ref().close_target();- target.navigation_finished(1);- target.navigation_started(2);- target.navigation_response_ready(2);- assert_eq!(- target.pause_ref().wait_for_pause_work(|| Some(42)),- Err(RendererInspectorPauseExitReason::TargetClosed)- );- }-- #[test]- fn response_ready_wakes_the_pause_loop_and_covers_later_pauses() {- let target = target();- target.navigation_started(1);- let pause = target.pause();- let (waiting_tx, waiting_rx) = std::sync::mpsc::channel();- let (exited_tx, exited_rx) = std::sync::mpsc::channel();- let waiter = std::thread::spawn(move || {- let mut waiting_tx = Some(waiting_tx);- exited_tx- .send(pause.wait_for_pause_work(|| {- if let Some(waiting_tx) = waiting_tx.take() {- waiting_tx.send(()).unwrap();- }- None::<()>- }))- .unwrap();- });- let waiting = waiting_rx.recv_timeout(std::time::Duration::from_secs(30));- target.navigation_response_ready(1);- let exited = exited_rx.recv_timeout(std::time::Duration::from_secs(30));- if exited.is_err() {- target.pause_ref().close_target();- }- waiter.join().unwrap();- waiting.expect("waiter must enter the pause wait before response readiness");- assert_eq!(- exited.expect("response readiness must wake the pause loop"),- Err(RendererInspectorPauseExitReason::Navigation)- );- assert_navigation_exit(&target);- target.navigation_finished(1);- assert_debugging_enabled(&target);- }-}diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex 44e250da4..4f6db92af 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -234,20 +234,19 @@ pub use runtime::{RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,- RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDevToolsTargetHandle,- RendererDocumentBoxModel, RendererDocumentChildNodeSnapshotEvent,- RendererDocumentChildNodeSnapshotEvents, RendererDocumentChildNodeSnapshots,- RendererDocumentCommitPermit, RendererDocumentFrontendNodeIdsResolution,- RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,- RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,- RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,- RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,- RendererDocumentLifecycleWaiter, RendererDocumentNodeAttributesResolution,- RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,- RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,- RendererDocumentNodeTextResolution, RendererDocumentOptions, RendererDocumentQuerySelectorNode,- RendererDocumentQuerySelectorResolution,- RendererDocumentQuerySelectorWithChildNodeSnapshotEvents,+ RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,+ RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,+ RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,+ RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,+ RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,+ RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,+ RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,+ RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,+ RendererDocumentNodeAttributesResolution, RendererDocumentNodeClientRect,+ RendererDocumentNodeGeometry, RendererDocumentNodePropertyResolution,+ RendererDocumentNodeReference, RendererDocumentNodeTextResolution, RendererDocumentOptions,+ RendererDocumentQuerySelectorNode, RendererDocumentQuerySelectorResolution,+ RendererDocumentQuerySelectorWithChildNodeSnapshotEvents, RendererDocumentReplacement,RendererDocumentSourcedSameDocumentNavigation,RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,RendererDocumentTitleChanged, RendererDocumentToken, RendererDomAttributeMutation,diff --git a/moli-renderer-v8/src/runtime/document_replacement.rs b/moli-renderer-v8/src/runtime/document_replacement.rsnew file mode 100644index 000000000..42ff84356--- /dev/null+++ b/moli-renderer-v8/src/runtime/document_replacement.rs@@ -0,0 +1,53 @@+//! The old document's part of preparing a replacement document.+//!+//! Capturing a replacement is inert. The renderer preparation boundary starts+//! the scope before queuing owner work, since the owner may be inside V8's pause+//! loop. Prepared-document ownership keeps it alive until commit or cancellation.++use std::sync::Arc;++use crate::devtools::pause::RendererInspectorPauseBridge;++#[derive(Clone, Debug)]+pub struct RendererDocumentReplacement {+ pause: RendererInspectorPauseBridge,+ cancellation: moli_fetch::FetchCancelHandle,+}++impl RendererDocumentReplacement {+ pub(super) fn new(+ pause: RendererInspectorPauseBridge,+ cancellation: moli_fetch::FetchCancelHandle,+ ) -> Self {+ Self {+ pause,+ cancellation,+ }+ }++ pub(super) fn begin(self) -> anyhow::Result<Arc<RendererDocumentReplacementScope>> {+ anyhow::ensure!(+ !self.cancellation.is_cancelled() && self.pause.begin_document_replacement(),+ moli_fetch::NET_ERR_ABORTED_ERROR_TEXT,+ );+ Ok(Arc::new(RendererDocumentReplacementScope {+ pause: self.pause,+ }))+ }+}++/// Owned by the prepare command and its returned handle, not by protocol or by+/// clones of the inert replacement input. Overlapping prepares for one old+/// document remain independent; completing either one must not release the other.+pub(crate) struct RendererDocumentReplacementScope {+ pause: RendererInspectorPauseBridge,+}++impl Drop for RendererDocumentReplacementScope {+ fn drop(&mut self) {+ self.pause.finish_document_replacement();+ }+}++#[cfg(test)]+mod tests;diff --git a/moli-renderer-v8/src/runtime/document_replacement/tests.rs b/moli-renderer-v8/src/runtime/document_replacement/tests.rsnew file mode 100644index 000000000..40a930638--- /dev/null+++ b/moli-renderer-v8/src/runtime/document_replacement/tests.rs@@ -0,0 +1,344 @@+use super::*;+use crate::devtools::pause::RendererInspectorPauseExitReason;++fn replacement(pause: &RendererInspectorPauseBridge) -> RendererDocumentReplacement {+ RendererDocumentReplacement::new(pause.clone(), moli_fetch::FetchCancelHandle::new())+}++fn assert_debugging_enabled(pause: &RendererInspectorPauseBridge) {+ assert_eq!(pause.wait_for_pause_work(|| Some(42)), Ok(42));+}++fn assert_replacement_exit(pause: &RendererInspectorPauseBridge) {+ assert_eq!(+ pause.wait_for_pause_work(|| Some(42)),+ Err(RendererInspectorPauseExitReason::DocumentReplacement)+ );+}++#[test]+fn capturing_and_dropping_replacement_inputs_never_disturbs_the_old_document() {+ let pause = RendererInspectorPauseBridge::default();+ let input = replacement(&pause);+ assert_debugging_enabled(&pause);+ drop(input.clone());+ assert_debugging_enabled(&pause);+ drop(input);+ assert_debugging_enabled(&pause);+}++#[test]+fn canceled_input_cannot_start_replacement_even_if_captured_before_cancellation() {+ let pause = RendererInspectorPauseBridge::default();+ let input = replacement(&pause);+ let retained = input.clone();+ input.cancellation.cancel();+ assert!(input.begin().is_err());+ assert!(retained.begin().is_err());+ assert_debugging_enabled(&pause);+}++#[test]+fn scope_drop_restores_debugging_without_waiting_for_retained_inputs() {+ let pause = RendererInspectorPauseBridge::default();+ let input = replacement(&pause);+ let scope = input.clone().begin().unwrap();+ assert_replacement_exit(&pause);+ drop(scope);+ assert_debugging_enabled(&pause);+ drop(input);+ assert_debugging_enabled(&pause);+}++#[test]+fn command_and_prepared_handle_share_one_scope_until_both_release_it() {+ let pause = RendererInspectorPauseBridge::default();+ let command = replacement(&pause).begin().unwrap();+ let handle = Arc::clone(&command);+ drop(command);+ assert_replacement_exit(&pause);+ drop(handle);+ assert_debugging_enabled(&pause);+}++#[test]+fn overlapping_preparations_cannot_finish_each_others_scope() {+ for finish_first in [true, false] {+ let pause = RendererInspectorPauseBridge::default();+ let first = replacement(&pause).begin().unwrap();+ let second = replacement(&pause).begin().unwrap();+ let (finished, pending) = if finish_first {+ (first, second)+ } else {+ (second, first)+ };+ drop(finished);+ assert_replacement_exit(&pause);+ drop(pending);+ assert_debugging_enabled(&pause);+ }+}++#[test]+fn replacement_is_document_local() {+ let first = RendererInspectorPauseBridge::default();+ let second = RendererInspectorPauseBridge::default();+ let scope = replacement(&first).begin().unwrap();+ assert_replacement_exit(&first);+ assert_debugging_enabled(&second);+ drop(scope);+ assert_debugging_enabled(&first);+}++#[test]+fn observed_exit_reason_survives_the_end_of_replacement() {+ let pause = RendererInspectorPauseBridge::default();+ let scope = replacement(&pause).begin().unwrap();+ let reason = pause.wait_for_pause_work(|| Some(42));+ drop(scope);+ assert_eq!(+ reason,+ Err(RendererInspectorPauseExitReason::DocumentReplacement)+ );+ assert_debugging_enabled(&pause);+}++#[test]+fn target_closure_takes_precedence_and_prevents_new_replacement() {+ let pause = RendererInspectorPauseBridge::default();+ let scope = replacement(&pause).begin().unwrap();+ pause.close_target();+ assert!(replacement(&pause).begin().is_err());+ drop(scope);+ assert_eq!(+ pause.wait_for_pause_work(|| Some(42)),+ Err(RendererInspectorPauseExitReason::TargetClosed)+ );+}++#[test]+fn preparation_wakes_the_pause_loop_and_covers_repeated_pauses() {+ let pause = RendererInspectorPauseBridge::default();+ let waiter_pause = pause.clone();+ let (waiting_tx, waiting_rx) = std::sync::mpsc::channel();+ let (exited_tx, exited_rx) = std::sync::mpsc::channel();+ let waiter = std::thread::spawn(move || {+ let mut waiting_tx = Some(waiting_tx);+ exited_tx+ .send(waiter_pause.wait_for_pause_work(|| {+ if let Some(tx) = waiting_tx.take() {+ tx.send(()).unwrap();+ }+ None::<()>+ }))+ .unwrap();+ });+ let waiting = waiting_rx.recv_timeout(std::time::Duration::from_secs(30));+ let scope = replacement(&pause).begin().unwrap();+ let exited = exited_rx.recv_timeout(std::time::Duration::from_secs(30));+ if exited.is_err() {+ pause.close_target();+ }+ waiter.join().unwrap();+ waiting.expect("waiter must reach the pause loop before document preparation");+ assert_eq!(+ exited.expect("document preparation must wake the pause loop"),+ Err(RendererInspectorPauseExitReason::DocumentReplacement)+ );+ assert_replacement_exit(&pause);+ assert_replacement_exit(&pause);+ drop(scope);+ assert_debugging_enabled(&pause);+}++async fn prepare(+ runtime: &crate::JsRuntime,+ reservation: crate::RendererPageReservationToken,+ replacement: Option<RendererDocumentReplacement>,+) -> anyhow::Result<crate::PreparedRendererDocument> {+ let loader = crate::network::ResourceRequestClient::new(&moli_fetch::FetchConfig::default())?;+ let url = url::Url::parse("https://replacement.test/").unwrap();+ tokio::time::timeout(+ std::time::Duration::from_secs(30),+ runtime.prepare_streaming_raw_document_from_external_body(+ reservation,+ replacement,+ url.clone(),+ url,+ None,+ false,+ 0,+ Vec::new(),+ 200,+ vec![("content-type".to_owned(), b"text/html".to_vec())],+ &loader,+ crate::RendererWebStorageHandles::ephemeral(),+ crate::ExternalRawDocumentBodyStream::from_bytes(+ b"<!doctype html><title>new</title>".to_vec(),+ ),+ false,+ crate::PageVmInitStage::Load,+ crate::RendererReplyBoundary::Stage,+ crate::RendererTopLevelNavigationDispatch::FollowInStandaloneAdapter,+ crate::RendererNavigationReplyPolicy::FollowBeforeReply,+ None,+ None,+ crate::RendererDocumentOptions::default(),+ ),+ )+ .await?+}++async fn owner_barrier(runtime: &crate::JsRuntime) {+ let pending = runtime.enqueue_owner_command_probe_for_testing().unwrap();+ tokio::time::timeout(std::time::Duration::from_secs(30), pending)+ .await+ .unwrap()+ .unwrap()+ .unwrap();+}++#[tokio::test]+async fn renderer_prepare_keeps_scope_until_cancel_or_commit() {+ let runtime = crate::JsRuntime::initialize();+ let pause = RendererInspectorPauseBridge::default();+ for commit in [false, true] {+ let input = replacement(&pause);+ let prepared = prepare(+ &runtime,+ runtime.reserve_page_for_creation(),+ Some(input.clone()),+ )+ .await+ .unwrap();+ assert_replacement_exit(&pause);+ if commit {+ let permit = prepared.issue_commit_permit();+ let (mut page, _, _, _, _) = prepared.commit(permit).await.unwrap();+ page.close_async().await.unwrap();+ } else {+ prepared.cancel().await.unwrap();+ }+ assert_debugging_enabled(&pause);+ drop(input);+ }+}++#[tokio::test]+async fn canceled_replacement_is_rejected_before_renderer_admission() {+ let runtime = crate::JsRuntime::initialize();+ let (output_tx, mut output_rx) = crate::runtime::renderer_output_transport_channel();+ runtime.set_renderer_output_transport_sender(output_tx);+ let reservation = runtime.reserve_page_for_creation();+ let pause = RendererInspectorPauseBridge::default();+ let input = replacement(&pause);+ input.cancellation.cancel();+ let result = prepare(&runtime, reservation, Some(input)).await;+ assert!(+ matches!(result, Err(error) if error.to_string() == moli_fetch::NET_ERR_ABORTED_ERROR_TEXT)+ );+ assert_debugging_enabled(&pause);+ assert!(matches!(+ output_rx.try_recv(),+ Ok(crate::runtime::RendererOutputTransportMessage::PageReservationReleased {+ owner_local_host_id, page_id,+ }) if owner_local_host_id == reservation.local_host_id() && page_id == reservation.page_id()+ ));+ assert!(matches!(+ output_rx.try_recv(),+ Err(tokio::sync::mpsc::error::TryRecvError::Empty)+ ));+ assert_eq!(+ runtime+ .document_isolate_accounting_for_diagnostics()+ .created,+ 0+ );+}++#[tokio::test]+async fn failed_renderer_prepare_releases_scope() {+ let runtime = crate::JsRuntime::initialize();+ let other_runtime = crate::JsRuntime::initialize();+ let pause = RendererInspectorPauseBridge::default();+ let result = prepare(+ &runtime,+ other_runtime.reserve_page_for_creation(),+ Some(replacement(&pause)),+ )+ .await;+ assert!(+ result.is_err(),+ "another owner's reservation must be rejected"+ );+ assert_debugging_enabled(&pause);+}++#[tokio::test]+async fn rejected_renderer_command_releases_scope() {+ let runtime = crate::JsRuntime::initialize();+ let pause = RendererInspectorPauseBridge::default();+ runtime.close_owner_command_admission_for_testing();+ assert!(+ prepare(+ &runtime,+ runtime.reserve_page_for_creation(),+ Some(replacement(&pause))+ )+ .await+ .is_err()+ );+ assert_debugging_enabled(&pause);+}++#[tokio::test]+async fn dropping_prepared_handle_retires_owner_scope() {+ let runtime = crate::JsRuntime::initialize();+ let pause = RendererInspectorPauseBridge::default();+ let prepared = prepare(+ &runtime,+ runtime.reserve_page_for_creation(),+ Some(replacement(&pause)),+ )+ .await+ .unwrap();+ assert_replacement_exit(&pause);+ drop(prepared);+ owner_barrier(&runtime).await;+ assert_debugging_enabled(&pause);+ assert_eq!(+ runtime+ .document_isolate_accounting_for_diagnostics()+ .reserved,+ 0+ );+}++#[tokio::test]+async fn dropping_inflight_prepare_retires_queued_document_and_scope() {+ let runtime = crate::JsRuntime::initialize();+ let pause = RendererInspectorPauseBridge::default();+ let (entered, release) = runtime.install_owner_command_dispatch_gate_for_testing();+ let mut pending = Box::pin(prepare(+ &runtime,+ runtime.reserve_page_for_creation(),+ Some(replacement(&pause)),+ ));+ assert!(futures_util::poll!(&mut pending).is_pending());+ let reached_gate = entered.recv_timeout(std::time::Duration::from_secs(30));+ assert_replacement_exit(&pause);+ drop(pending);+ // The queued command still owns the scope until owner-side cancellation.+ assert_replacement_exit(&pause);+ let released = release.send(());+ reached_gate.unwrap();+ released.unwrap();+ owner_barrier(&runtime).await;+ assert_debugging_enabled(&pause);+ assert_eq!(+ runtime+ .document_isolate_accounting_for_diagnostics()+ .reserved,+ 0+ );+}diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex c22ab7d22..7d823993c 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -44,6 +44,7 @@ mod access;mod browser_context_runtime;mod document_lifecycle;mod document_lifecycle_turn;+mod document_replacement;mod javascript_dialog;mod lifecycle_decision;mod main_document_ready_gate;@@ -54,6 +55,7 @@ mod owner_deadline_index;mod owner_local;mod owner_local_store;mod owner_maintenance;+pub use document_replacement::RendererDocumentReplacement;mod page;mod page_commands;mod page_context_cancel;@@ -434,7 +436,6 @@ pub use crate::devtools::ingress::io::{pub use crate::devtools::ingress::main::{RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,};-pub use crate::devtools::target::RendererDevToolsTargetHandle;pub(crate) use crate::renderer::PageVmInitStage;pub(crate) use crate::service_worker_runtime::{MaterializedServiceWorkerFetchResponseHead, ServiceWorkerClientFocus,diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex fd9f90f1f..62ceeddec 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -185,6 +185,8 @@ pub struct RendererCreateHtmlPageRequest {}pub struct RendererCreateStreamingRawPageRequest {+ pub(super) document_replacement:+ Option<Arc<super::document_replacement::RendererDocumentReplacementScope>>,pub root_frame_id: Option<String>,pub main_document_commit: Option<RendererMainDocumentCommit>,pub requested_url: Url,diff --git a/moli-renderer-v8/src/runtime/owner/owner_commands.rs b/moli-renderer-v8/src/runtime/owner/owner_commands.rsindex cb202525c..37cf32112 100644--- a/moli-renderer-v8/src/runtime/owner/owner_commands.rs+++ b/moli-renderer-v8/src/runtime/owner/owner_commands.rs@@ -177,7 +177,7 @@ impl RendererOwnerHandle {/// observes `Opened` before this release on success, while an early failure/// produces only the release. Never move this to the navigation completion/// channel: that independent channel cannot order against stream opening.- pub(super) fn release_page_output_reservation(+ pub(in crate::runtime) fn release_page_output_reservation(&self,reservation: RendererPageReservationToken,) {diff --git a/moli-renderer-v8/src/runtime/owner/page_creation.rs b/moli-renderer-v8/src/runtime/owner/page_creation.rsindex 4bab8b073..312572622 100644--- a/moli-renderer-v8/src/runtime/owner/page_creation.rs+++ b/moli-renderer-v8/src/runtime/owner/page_creation.rs@@ -722,6 +722,7 @@ impl RendererOwnerHandle {options: crate::RendererDocumentOptions,) -> RendererCreateStreamingRawPageRequest {RendererCreateStreamingRawPageRequest {+ document_replacement: None,root_frame_id: options.root_frame_id,main_document_commit: options.main_document_commit,requested_url,@@ -1108,6 +1109,7 @@ impl RendererOwnerHandle {_owner_local_store: &mut RendererOwnerLocalStore,) -> RenderRuntimeDispatchOutcome {let RendererCreateStreamingRawPageRequest {+ document_replacement: _document_replacement,root_frame_id,main_document_commit,requested_url,diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex 2a5a590cf..318021e57 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -271,9 +271,13 @@ impl RendererPageHandle {self.devtools_target.pause_ref().is_pause_active()}- #[doc(hidden)]- pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {- self.devtools_target.clone()+ /// Captures this exact document without disturbing its execution. Only a+ /// renderer prepare operation may activate the replacement.+ pub fn document_replacement(+ &self,+ cancellation: moli_fetch::FetchCancelHandle,+ ) -> super::RendererDocumentReplacement {+ super::RendererDocumentReplacement::new(self.devtools_target.pause(), cancellation)}/// Enqueues the DevTools IO-agent script policy without borrowing thediff --git a/moli-renderer-v8/src/runtime/page.rs b/moli-renderer-v8/src/runtime/page.rsindex 435ebce44..bcb693307 100644--- a/moli-renderer-v8/src/runtime/page.rs+++ b/moli-renderer-v8/src/runtime/page.rs@@ -472,6 +472,7 @@ impl JsRuntime {let prepared = self.prepare_streaming_raw_document_from_external_body(self.reserve_page_for_creation(),+ None,requested_url,final_url,navigation_initiator_url,@@ -503,6 +504,7 @@ impl JsRuntime {pub async fn prepare_streaming_raw_document_from_external_body(&self,page_reservation: RendererPageReservationToken,+ replacement: Option<super::RendererDocumentReplacement>,requested_url: Url,final_url: Url,navigation_initiator_url: Option<Url>,@@ -547,6 +549,26 @@ impl JsRuntime {request.navigation_reply_policy = navigation_reply_policy;request.reserved_service_worker_client = reserved_service_worker_client;request.lifecycle_decider = lifecycle_decider;+ // This is the provisional-load boundary. Wake the old document before+ // dispatching owner work: queuing the wake itself would deadlock behind+ // a paused script. Downloads and intercepted responses never get here.+ let replacement = replacement+ .map(super::RendererDocumentReplacement::begin)+ .transpose()+ .inspect_err(|_| {+ self.inner+ .renderer_owner+ .release_page_output_reservation(page_reservation);+ })?;+ request.document_replacement = replacement.clone();+ // Own cancellation before awaiting the prepare reply, so abandoning+ // the future also retires a queued or already stored preparation.+ let preparation = RendererDocumentPreparation {+ runtime: self.clone(),+ token: page_reservation,+ cancel_on_drop: true,+ _document_replacement: replacement,+ };let reply = self.inner.renderer_owner@@ -558,11 +580,10 @@ impl JsRuntime {match reply {RendererOwnerReply::PreparedRendererDocumentStored {renderer_devtools_agent_token,- } => Ok(PreparedRendererDocument::new(- self.clone(),- page_reservation,+ } => Ok(PreparedRendererDocument {+ preparation,renderer_devtools_agent_token,- )),+ }),_ => Err(anyhow!("renderer owner returned non-prepare reply for prepared document request")),@@ -608,28 +629,21 @@ impl Drop for JsRuntimeOwner {/// Dropping this handle schedules cancellation. Only a permit issued for this/// exact handle can consume the owner-local residence and start bootstrap.pub struct PreparedRendererDocument {+ preparation: RendererDocumentPreparation,+ renderer_devtools_agent_token: super::RendererDevToolsAgentToken,+}++struct RendererDocumentPreparation {runtime: JsRuntime,token: RendererPageReservationToken,- renderer_devtools_agent_token: super::RendererDevToolsAgentToken,cancel_on_drop: bool,+ _document_replacement:+ Option<Arc<super::document_replacement::RendererDocumentReplacementScope>>,}impl PreparedRendererDocument {- fn new(- runtime: JsRuntime,- token: RendererPageReservationToken,- renderer_devtools_agent_token: super::RendererDevToolsAgentToken,- ) -> Self {- Self {- runtime,- token,- renderer_devtools_agent_token,- cancel_on_drop: true,- }- }-pub fn token(&self) -> RendererPageReservationToken {- self.token+ self.preparation.token}pub fn renderer_devtools_agent_token(&self) -> super::RendererDevToolsAgentToken {@@ -637,7 +651,7 @@ impl PreparedRendererDocument {}pub fn issue_commit_permit(&self) -> RendererDocumentCommitPermit {- RendererDocumentCommitPermit::new(self.token)+ RendererDocumentCommitPermit::new(self.token())}/// Replaces the live target configuration consumed when the first@@ -647,12 +661,13 @@ impl PreparedRendererDocument {configuration: super::RendererPreparedDocumentCommitConfiguration,) -> Result<()> {let reply = self+ .preparation.runtime.inner.renderer_owner.dispatch_command(RendererOwnerCommand::UpdatePreparedRendererDocumentCommitConfiguration {- token: self.token,+ token: self.token(),configuration,},)@@ -676,17 +691,19 @@ impl PreparedRendererDocument {Option<RendererPendingDownloadActivation>,)> {anyhow::ensure!(- permit.prepared_document() == self.token,+ permit.prepared_document() == self.token(),"renderer document commit permit does not belong to this prepared document");- self.cancel_on_drop = false;let reply = self+ .preparation.runtime.inner.renderer_owner.dispatch_command(RendererOwnerCommand::CommitPreparedRendererDocument { permit }).await?;- self.runtime+ self.preparation.cancel_on_drop = false;+ self.preparation+ .runtime.inner.renderer_owner.materialize_page_created_reply_parts(reply)@@ -694,16 +711,17 @@ impl PreparedRendererDocument {pub async fn cancel(mut self) -> Result<()> {let reply = self+ .preparation.runtime.inner.renderer_owner.dispatch_command(RendererOwnerCommand::CancelPreparedRendererDocument {- token: self.token,+ token: self.token(),}).await?;match reply {RendererOwnerReply::PreparedRendererDocumentCanceled => {- self.cancel_on_drop = false;+ self.preparation.cancel_on_drop = false;Ok(())}_ => Err(anyhow!(@@ -713,7 +731,7 @@ impl PreparedRendererDocument {}}-impl Drop for PreparedRendererDocument {+impl Drop for RendererDocumentPreparation {fn drop(&mut self) {if !self.cancel_on_drop {return;diff --git a/moli-renderer-v8/src/runtime/tests.rs b/moli-renderer-v8/src/runtime/tests.rsindex be24102fb..33fd865a8 100644--- a/moli-renderer-v8/src/runtime/tests.rs+++ b/moli-renderer-v8/src/runtime/tests.rs@@ -68,6 +68,7 @@ async fn prepare_test_external_raw_document_with_content_type_and_reply_boundaryruntime.prepare_streaming_raw_document_from_external_body(runtime.reserve_page_for_creation(),+ None,url.clone(),url,None,diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex e0267d796..ee244ba96 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -239,11 +239,13 @@ impl RendererInspectorSessionExecutorLocal {}}};- if exit_reason == crate::devtools::pause::RendererInspectorPauseExitReason::Navigation {+ if exit_reason+ == crate::devtools::pause::RendererInspectorPauseExitReason::DocumentReplacement+ {// Like Chromium's UnpauseAndTerminate, unwind the paused old// document before preparing its replacement on the owner thread.- // Later pauses observe the same provisional-load state until its- // explicit commit/cancel notification. No debugger setting leaks+ // Later pauses observe the same renderer preparation scope until+ // it commits or is discarded. No debugger setting leaks// into the replacement document's Inspector restore snapshots.let sessions: Vec<_> = self.sessions