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(devtools): unblock navigation while the debugger is paused
ldm079ea1406fa9a
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rsindex df6641c64..b744f3f7e 100644--- a/moli-core/src/page/js_evaluation.rs+++ b/moli-core/src/page/js_evaluation.rs@@ -594,6 +594,11 @@ 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 c0ef0acd6..11b3a6187 100644--- a/moli-core/src/page/mod.rs+++ b/moli-core/src/page/mod.rs@@ -91,12 +91,13 @@ pub use moli_renderer_v8::{RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,- RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,- RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,- RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,- RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,- RendererDocumentNodeGeometry, RendererDocumentSourcedSameDocumentNavigation,+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDevToolsTargetHandle,+ RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,+ RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,+ RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,+ RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,+ RendererDocumentLifecycleWaiter, RendererDocumentNodeGeometry,+ RendererDocumentSourcedSameDocumentNavigation,RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,RendererDocumentToken, RendererDomAttributeMutation, RendererDomAttributeMutationOutcome,RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListener,diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rsindex 6b46d694c..6cad96951 100644--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs@@ -1,6 +1,8 @@use super::*;use std::path::Path;+mod navigation_debugger;+fn assert_cdp_event_precedes_response(messages: &[serde_json::Value],method: &str,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.rsnew file mode 100644index 000000000..6b4f68bf6--- /dev/null+++ b/moli-protocol-server/src/protocol_server/tests/websocket/navigation_debugger.rs@@ -0,0 +1,514 @@+use super::*;++type TestSocket =+ tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>;++const NAVIGATION_TIMEOUT: Duration = Duration::from_secs(30);++async fn pause_in_timer(+ socket: &mut TestSocket,+ session_id: &str,+ id: u64,+ body: &str,+) -> Vec<serde_json::Value> {+ let mut messages = send_cdp_command(+ socket,+ id,+ "Runtime.evaluate",+ Some(session_id),+ json!({"expression": format!("setTimeout(() => {{ {body} }}, 0); 'armed'")}),+ )+ .await;+ if !messages+ .iter()+ .any(|message| message["method"] == "Debugger.paused" && message["sessionId"] == session_id)+ {+ messages.extend(+ recv_until_match(socket, |message| {+ message["method"] == "Debugger.paused" && message["sessionId"] == session_id+ })+ .await,+ );+ }+ assert!(+ messages.iter().any(|message| {+ message["id"] == id && message["result"]["result"]["value"] == "armed"+ })+ );+ messages+}++async fn assert_navigation_exits_debugger_pause(body: &str, second_frontend: bool) {+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;+ let (mut socket, _) = connect_async(format!(+ "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"+ ))+ .await+ .expect("connect to cdp websocket");+ let session_id = cdp_create_default_session_and_navigate(+ &mut socket,+ "data:text/html,<title>old document</title>",+ )+ .await;+ send_cdp_command(+ &mut socket,+ 6,+ "Debugger.enable",+ Some(&session_id),+ json!({}),+ )+ .await;+ let second_session = if second_frontend {+ let tree = send_cdp_command(+ &mut socket,+ 20,+ "Page.getFrameTree",+ Some(&session_id),+ json!({}),+ )+ .await;+ let tree_reply = tree+ .iter()+ .find(|message| message["id"] == 20)+ .expect("frame tree response");+ let target_id = &tree_reply["result"]["frameTree"]["frame"]["id"];+ let attached = send_cdp_command(+ &mut socket,+ 21,+ "Target.attachToTarget",+ None,+ json!({"targetId": target_id, "flatten": true}),+ )+ .await;+ let second_session = attached.iter().find(|message| message["id"] == 21).unwrap()["result"]+ ["sessionId"]+ .as_str()+ .unwrap();+ send_cdp_command(+ &mut socket,+ 22,+ "Debugger.enable",+ Some(second_session),+ json!({}),+ )+ .await;+ Some(second_session.to_owned())+ } else {+ None+ };+ let paused = pause_in_timer(&mut socket, &session_id, 7, body).await;+ if let Some(second_session) = second_session+ && !paused.iter().any(|message| {+ message["method"] == "Debugger.paused" && message["sessionId"] == second_session+ })+ {+ recv_until_match(&mut socket, |message| {+ message["method"] == "Debugger.paused" && message["sessionId"] == second_session+ })+ .await;+ }++ let destination = "data:text/html,<title>replacement</title>";+ let navigation = timeout(+ NAVIGATION_TIMEOUT,+ cdp_navigate_and_wait_for_load(&mut socket, 8, &session_id, destination),+ )+ .await;+ // Release the old execution before failing, so a regression cannot leave+ // the test renderer's owner thread in its nested pause loop during cleanup.+ if navigation.is_err() {+ send_cdp_command(+ &mut socket,+ 90,+ "Debugger.resume",+ Some(&session_id),+ json!({"terminateOnResume": true}),+ )+ .await;+ let _ = socket.close(None).await;+ abort_test_cdp_server(protocol_server).await;+ panic!("cross-document navigation must terminate paused old-document execution");+ }+ let messages = navigation.unwrap();+ assert!(messages.iter().any(|message| {+ message["method"] == "Page.frameNavigated"+ && message["params"]["frame"]["url"] == destination+ }));+ assert!(+ !messages+ .iter()+ .any(|message| message["method"] == "Debugger.paused")+ );+ assert_eq!(+ cdp_runtime_evaluate_string(&mut socket, &session_id, 9, "document.title").await,+ "replacement"+ );++ // Navigation must not disable debugging in the replacement inspector+ // session. No second Debugger.enable is sent.+ pause_in_timer(&mut socket, &session_id, 10, "debugger;").await;+ send_cdp_command(+ &mut socket,+ 11,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await;+ let _ = socket.close(None).await;+ abort_test_cdp_server(protocol_server).await;+}++#[tokio::test]+async fn navigation_terminates_single_debugger_pause() {+ assert_navigation_exits_debugger_pause("debugger;", false).await;+}++#[tokio::test]+async fn navigation_terminates_repeated_debugger_pauses() {+ assert_navigation_exits_debugger_pause("for (;;) { debugger; }", false).await;+}++#[tokio::test]+async fn navigation_terminates_pause_with_multiple_debugger_sessions() {+ assert_navigation_exits_debugger_pause("for (;;) { debugger; }", true).await;+}++#[tokio::test]+async fn navigation_terminates_pauses_from_repeating_timers() {+ assert_navigation_exits_debugger_pause("setInterval(() => { debugger; }, 0); debugger;", false)+ .await;+}++#[tokio::test]+async fn navigation_terminates_pause_only_when_document_response_is_ready() {+ assert_delayed_navigation_while_paused(false).await;+}++#[tokio::test]+async fn navigation_supersedes_a_delayed_response_while_debugger_is_paused() {+ assert_delayed_navigation_while_paused(true).await;+}++async fn assert_delayed_navigation_while_paused(supersede: bool) {+ let requested = Arc::new(tokio::sync::Notify::new());+ let release_response = Arc::new(tokio::sync::Notify::new());+ let fixture_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let fixture_addr = fixture_listener.local_addr().unwrap();+ let app = axum::Router::new().route(+ "/",+ axum::routing::get({+ let requested = requested.clone();+ let release_response = release_response.clone();+ move || {+ let requested = requested.clone();+ let release_response = release_response.clone();+ async move {+ requested.notify_one();+ release_response.notified().await;+ axum::response::Html("<title>HTTP replacement</title>")+ }+ }+ }),+ );+ let fixture = tokio::spawn(async move { axum::serve(fixture_listener, app).await.unwrap() });+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;+ let (mut socket, _) = connect_async(format!(+ "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"+ ))+ .await+ .unwrap();+ let session_id =+ cdp_create_default_session_and_navigate(&mut socket, "data:text/html,<title>old</title>")+ .await;+ send_cdp_command(+ &mut socket,+ 6,+ "Debugger.enable",+ Some(&session_id),+ json!({}),+ )+ .await;+ pause_in_timer(&mut socket, &session_id, 7, "for (;;) { debugger; }").await;+ send_cdp_command_without_wait(+ &mut socket,+ 8,+ "Page.navigate",+ Some(&session_id),+ json!({"url": format!("http://{fixture_addr}/")}),+ )+ .await;+ timeout(NAVIGATION_TIMEOUT, requested.notified())+ .await+ .unwrap();++ let mut navigated = if supersede {+ timeout(+ NAVIGATION_TIMEOUT,+ cdp_navigate_and_wait_for_load(+ &mut socket,+ 9,+ &session_id,+ "data:text/html,<title>second replacement</title>",+ ),+ )+ .await+ } else {+ // A response that has not arrived must not terminate the old document.+ // Successful resume proves it is still paused. The loop immediately+ // hits another debugger statement; its event may be navigation-gated.+ let resumed = send_cdp_command(+ &mut socket,+ 9,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await;+ assert!(+ resumed+ .iter()+ .any(|message| { message["id"] == 9 && message.get("error").is_none() })+ );+ release_response.notify_one();+ timeout(+ NAVIGATION_TIMEOUT,+ recv_until_match(&mut socket, |message| {+ message["method"] == "Page.loadEventFired"+ }),+ )+ .await+ };+ if navigated.is_err() {+ send_cdp_command(+ &mut socket,+ 90,+ "Debugger.resume",+ Some(&session_id),+ json!({"terminateOnResume": true}),+ )+ .await;+ }+ if supersede && let Ok(messages) = &mut navigated {+ if !messages.iter().any(|message| message["id"] == 8) {+ messages.extend(recv_until_id(&mut socket, 8).await);+ }+ let aborted = messages+ .iter()+ .find(|message| message["id"] == 8)+ .expect("superseded navigation must receive a terminal response");+ assert!(aborted.get("error").is_none());+ assert_eq!(aborted["result"]["errorText"], "net::ERR_ABORTED");+ // The replacement must commit before the first server sends headers.+ release_response.notify_one();+ }+ let title = cdp_runtime_evaluate_string(&mut socket, &session_id, 10, "document.title").await;+ pause_in_timer(&mut socket, &session_id, 11, "debugger;").await;+ send_cdp_command(+ &mut socket,+ 12,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await;+ let _ = socket.close(None).await;+ abort_test_cdp_server(protocol_server).await;+ fixture.abort();+ assert!(+ navigated.is_ok(),+ "HTTP response preparation must exit the old pause"+ );+ assert_eq!(+ title,+ if supersede {+ "second replacement"+ } else {+ "HTTP replacement"+ }+ );+}++#[tokio::test]+async fn navigation_cancellation_at_request_stage_preserves_the_paused_document_and_debugger() {+ assert_intercepted_navigation_while_paused("Request", InterceptionAction::Cancel).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;+}++#[tokio::test]+async fn navigation_continues_an_intercepted_response_while_debugger_is_paused() {+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Continue).await;+}++#[tokio::test]+async fn navigation_fulfills_an_intercepted_response_while_debugger_is_paused() {+ assert_intercepted_navigation_while_paused("Response", InterceptionAction::Fulfill).await;+}++#[derive(Clone, Copy)]+enum InterceptionAction {+ Cancel,+ Continue,+ Fulfill,+}++async fn assert_intercepted_navigation_while_paused(+ request_stage: &str,+ action: InterceptionAction,+) {+ let (fixture_addr, fixture) = spawn_dedicated_fixture_server(+ Router::new().route(+ "/",+ get(|| async { axum::response::Html("<title>HTTP replacement</title>") }),+ ),+ "paused-navigation-cancellation",+ );+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;+ let (mut socket, _) = connect_async(format!(+ "ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"+ ))+ .await+ .unwrap();+ let session_id =+ cdp_create_default_session_and_navigate(&mut socket, "data:text/html,<title>old</title>")+ .await;+ send_cdp_command(+ &mut socket,+ 6,+ "Debugger.enable",+ Some(&session_id),+ json!({}),+ )+ .await;+ send_cdp_command(+ &mut socket,+ 7,+ "Fetch.enable",+ Some(&session_id),+ json!({"patterns": [{+ "urlPattern": "*", "resourceType": "Document", "requestStage": request_stage+ }]}),+ )+ .await;+ pause_in_timer(+ &mut socket,+ &session_id,+ 8,+ "debugger; globalThis.resumedNormally = 'yes';",+ )+ .await;+ send_cdp_command_without_wait(+ &mut socket,+ 9,+ "Page.navigate",+ Some(&session_id),+ json!({"url": format!("http://{fixture_addr}/")}),+ )+ .await;+ let intercepted = recv_until_match(&mut socket, |message| {+ message["method"] == "Fetch.requestPaused"+ })+ .await;+ let 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 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);+ }+ assert!(+ completed+ .iter()+ .any(|message| message["id"] == 10 && message.get("error").is_none())+ );+ match action {+ InterceptionAction::Cancel => {+ assert!(+ !completed+ .iter()+ .any(|message| message["method"] == "Page.frameNavigated")+ );+ let resumed = send_cdp_command(+ &mut socket,+ 11,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await;+ assert!(+ resumed+ .iter()+ .any(|message| message["id"] == 11 && message.get("error").is_none()),+ "cancellation must keep the current document paused: completed={completed:#?}, resumed={resumed:#?}"+ );+ }+ InterceptionAction::Continue | InterceptionAction::Fulfill => {+ assert!(+ completed+ .iter()+ .any(|message| message["id"] == 9 && message.get("error").is_none())+ );+ if !completed+ .iter()+ .any(|message| message["method"] == "Page.loadEventFired")+ {+ recv_until_match(&mut socket, |message| {+ message["method"] == "Page.loadEventFired"+ })+ .await;+ }+ }+ }+ let expected_title = match action {+ InterceptionAction::Cancel => "old:yes",+ InterceptionAction::Continue => "HTTP replacement:undefined",+ InterceptionAction::Fulfill => "fulfilled:undefined",+ };+ assert_eq!(+ cdp_runtime_evaluate_string(+ &mut socket,+ &session_id,+ 12,+ "document.title + ':' + globalThis.resumedNormally"+ )+ .await,+ expected_title,+ );+ pause_in_timer(&mut socket, &session_id, 13, "debugger;").await;+ send_cdp_command(+ &mut socket,+ 14,+ "Debugger.resume",+ Some(&session_id),+ json!({}),+ )+ .await;+ let _ = socket.close(None).await;+ abort_test_cdp_server(protocol_server).await;+ drop(fixture);+}diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex b4f17a66f..8fedb47d1 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -537,8 +537,8 @@ pub(crate) use runtime_load::decode_data_url_response;pub(crate) use runtime_load::{BackgroundNavigationBodyCompletionSink, BackgroundNavigationEarlyResult,BackgroundNavigationLoadJob, CompletedInitialDocumentPageBuild, FailedInitialDocumentPageBuild,- InitialDocumentPageInstallResult, InitialDocumentPageOwner, PausedResponsePreparedDocument,- PendingInitialDocumentPageBuild, ResponseCommitReady,+ InitialDocumentPageInstallResult, InitialDocumentPageOwner, PendingInitialDocumentPageBuild,+ ResponseCommitReady,};use scheduler_hooks::CdpSchedulerHooks;use scheduler_state::CdpConnectionSchedulerState;diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex 1961e6a70..5a3444f81 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -181,9 +181,16 @@ 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)>,}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,@@ -346,6 +353,7 @@ impl TargetNavigationLoadInputs {.navigation_history_state.position_after_navigation(),),+ renderer_navigation: target.runtime_slot().page_slot().renderer_navigation(),}}@@ -412,6 +420,7 @@ impl TargetNavigationLoadInputs {permission_overrides: Vec::new(),main_document_commit_seed: None,session_history_position: None,+ renderer_navigation: None,}}diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rsindex 9bc66e029..9065ce5fa 100644--- a/moli-protocol/src/conn/fetch_support.rs+++ b/moli-protocol/src/conn/fetch_support.rs@@ -7,7 +7,7 @@ use url::Url;use super::body_spool::ensure_materialize_limit;use super::{CapturedBody, CapturedBodyWriter, CdpConnection, CommandOwnerScope, DocumentNavigationToken,- NavigationDispatchState, NavigationLoadOutcome, PausedResponsePreparedDocument,+ NavigationDispatchState, NavigationLoadOutcome,};use crate::devtools_runtime::{DevToolsNetworkInterceptId, DevToolsNetworkResourceType};use crate::domains::network::MainDocumentBodyProgressSource;@@ -790,7 +790,6 @@ pub(crate) struct PendingStreamingDocumentResponseNavigation {pub(crate) response: StreamingRawResponse,pub(crate) network_observation_journal: NetworkObservationJournal,pub(crate) body_progress_source: MainDocumentBodyProgressSource,- pub(crate) prepared_document: Option<Box<PausedResponsePreparedDocument>>,}impl PausedDocumentTransfer {@@ -818,23 +817,6 @@ impl PausedDocumentTransfer {matches!(self.state, PausedDocumentTransferState::Pending { .. })}- #[cfg(test)]- pub(crate) fn prepared_renderer_agent_token(- &self,- ) -> Option<moli_core::page::RendererDevToolsAgentToken> {- match &self.state {- PausedDocumentTransferState::Pending {- body:- DocumentBodySource::StreamingRaw {- prepared_document: Some(prepared_document),- ..- },- ..- } => Some(prepared_document.renderer_devtools_agent_token()),- _ => None,- }- }-fn owner_session_id(&self) -> Option<&str> {match &self.state {PausedDocumentTransferState::Pending { navigation, .. }@@ -879,7 +861,6 @@ impl PausedDocumentTransfer {response,network_observation_journal,body_progress_source,- prepared_document: _,} => Ok(PendingFetchResponseOpenedBodyStream {handle: handle.clone(),buffered_bytes: None,@@ -1010,7 +991,6 @@ impl PausedDocumentTransfer {response,network_observation_journal,body_progress_source,- prepared_document,},} => {let Some(document_navigation_token) = document_navigation_token else {@@ -1026,7 +1006,6 @@ impl PausedDocumentTransfer {response,network_observation_journal,body_progress_source,- prepared_document,},},}));@@ -1037,7 +1016,6 @@ impl PausedDocumentTransfer {response,network_observation_journal,body_progress_source,- prepared_document,})}state => Err(Box::new(Self {@@ -1383,7 +1361,6 @@ pub enum DocumentBodySource {response: StreamingRawResponse,network_observation_journal: NetworkObservationJournal,body_progress_source: MainDocumentBodyProgressSource,- prepared_document: Option<Box<PausedResponsePreparedDocument>>,},CapturedRaw {requested_url: Url,@@ -1564,12 +1541,8 @@ impl DocumentBodySource {response,network_observation_journal,body_progress_source,- prepared_document,..} => {- if !has_response_override && let Some(prepared_document) = prepared_document {- return Ok(prepared_document.resume_streaming(response, None));- }conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(navigation,NetworkFetchResult::with_observation_journal(@@ -1666,7 +1639,6 @@ impl DocumentBodySource {response,network_observation_journal,body_progress_source,- prepared_document: _,} => {let preserved_head = response.head();let (head, body) = match capture_streaming_raw_response(response).await {diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rsindex 9bba2b073..a20b57f07 100644--- a/moli-protocol/src/conn/runtime_load.rs+++ b/moli-protocol/src/conn/runtime_load.rs@@ -495,95 +495,6 @@ impl Drop for ResponseCommitReady {}}-pub struct PausedResponsePreparedDocument {- prepared_page: PreparedDocumentPage,- renderer_body_tx: mpsc::Sender<Vec<u8>>,- renderer_completion_tx: oneshot::Sender<anyhow::Result<()>>,- body_progress_source: MainDocumentBodyProgressSource,- body_network_progress_state: MainDocumentBodyNetworkProgress,- requested_url: Url,- final_url: Url,- request_method: String,- request_headers: moli_fetch::RequestHeaders,- response_status: u16,- response_headers: Vec<(String, Vec<u8>)>,- response_from_cache: bool,- negotiated_http_version: Option<moli_fetch::NegotiatedHttpVersion>,- network_observation_journal: NetworkObservationJournal,- timing_started: Option<std::time::Instant>,- main_document_commit: Option<Arc<RendererMainDocumentCommit>>,-}--impl std::fmt::Debug for PausedResponsePreparedDocument {- fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- formatter- .debug_struct("PausedResponsePreparedDocument")- .field("requested_url", &self.requested_url)- .field("final_url", &self.final_url)- .field(- "renderer_devtools_agent_token",- &self.prepared_page.renderer_devtools_agent_token(),- )- .finish_non_exhaustive()- }-}--impl PausedResponsePreparedDocument {- #[cfg(test)]- pub(crate) fn renderer_devtools_agent_token(- &self,- ) -> moli_core::page::RendererDevToolsAgentToken {- self.prepared_page.renderer_devtools_agent_token()- }-- pub(crate) fn resume_streaming(- self,- response: StreamingRawResponse,- body_completion_sink: Option<BackgroundNavigationBodyCompletionSink>,- ) -> NavigationLoadOutcome {- let network_extra_info_available = !self.network_observation_journal.is_empty();- self.body_progress_source.emit_response_metadata(- &self.request_method,- &self.request_headers.to_byte_strings(),- response.request_cookie_report.as_ref(),- &response.redirect_chain,- &self.final_url,- self.response_status,- &self.response_headers,- &response.cookie_set_reports,- &self.network_observation_journal,- network_extra_info_available,- self.response_from_cache,- self.negotiated_http_version,- );- let body_capture_task = spawn_streaming_body_capture(- response,- None,- self.renderer_body_tx,- self.renderer_completion_tx,- );- let ready = ResponseCommitReady {- prepared_page: Some(self.prepared_page),- body_capture: Some(ResponseCommitBodyCapture::Pending(body_capture_task)),- body_completion_sink,- body_progress_source: self.body_progress_source,- body_network_progress_state: Some(self.body_network_progress_state),- synthetic_body: false,- requested_url: self.requested_url,- final_url: self.final_url,- request_method: self.request_method,- request_headers: self.request_headers,- response_status: self.response_status,- response_headers: self.response_headers,- response_from_cache: self.response_from_cache,- timing_started: self.timing_started,- main_document_commit: self.main_document_commit,- network_error_page: None,- };- NavigationLoadOutcome::response_commit_ready(ready)- }-}-async fn first_nonempty_response_body_chunk(response: &mut StreamingRawResponse,) -> anyhow::Result<Option<Vec<u8>>> {@@ -1387,6 +1298,7 @@ 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();@@ -1646,145 +1558,6 @@ impl CdpConnection {.flatten()}- pub(crate) async fn prepare_paused_streaming_response_navigation_async(- &mut self,- navigation: &NavigationDispatchState,- response: &StreamingRawResponse,- network_observation_journal: &NetworkObservationJournal,- body_progress_source: MainDocumentBodyProgressSource,- ) -> anyhow::Result<Option<PausedResponsePreparedDocument>> {- if super::downloads::response_headers_indicate_download(&response.headers)- || response_headers_indicate_xml_document(&response.headers)- || response_status_may_use_http_error_page(response.status)- {- return Ok(None);- }- let load_inputs = self.navigation_load_inputs_for_navigation(navigation);- if load_inputs.browser_context_id.is_none() {- return Ok(None);- }- let requested_url = navigation.requested_url.clone();- let network_extra_info_available = !network_observation_journal.is_empty();- let request_method = navigation.request_method.clone();- let request_headers = navigation.request_headers.clone();- let timing_started = moli_trace::cdp_nav_timing_enabled().then(std::time::Instant::now);- let final_url = response.final_url.clone();- let response_status = response.status;- let response_headers = response.headers.clone();- let response_cookie_reports = response.cookie_set_reports.clone();- let response_from_cache = response.from_cache;- let negotiated_http_version = response.negotiated_http_version;- let initial_request_cookie_report = response.request_cookie_report.clone();- let redirect_chain = response- .redirect_chain- .clone()- .into_iter()- .map(Into::into)- .collect::<Vec<_>>();- let network_events = CompletedMainDocumentNetworkEvents::new(- request_method.clone(),- request_headers.to_byte_strings(),- initial_request_cookie_report,- response_status,- response_headers.clone(),- response_cookie_reports.clone(),- redirect_chain.clone(),- network_extra_info_available,- response_from_cache,- )- .with_negotiated_http_version(negotiated_http_version)- .with_network_observation_journal(network_observation_journal.clone());- let body_network_progress_state =- body_progress_source.body_network_progress_for_completed_events(network_events);- let (renderer_body_tx, renderer_body_rx) =- mpsc::channel(EXTERNAL_RAW_BODY_CHANNEL_CAPACITY);- let (renderer_completion_tx, renderer_completion_rx) = oneshot::channel();- let raw_body = moli_core::runtime::ExternalRawDocumentBodyStream::new(- renderer_body_rx,- renderer_completion_rx,- );- let shared_resource_runtime =- self.shared_resource_runtime_for_navigation_load_inputs(&load_inputs);- let mut engine = self.navigation_engine_handle_for_load_inputs(&load_inputs);- if let Some(resource_runtime) = shared_resource_runtime {- engine- .adopt_registered_resource_runtime(resource_runtime)- .context("failed to update navigation runtime policy")?;- }- let (fetch_subresource_interception_enabled, fetch_subresource_interception_resource_type) =- load_inputs.fetch_subresource_interception;- let page_storage = load_inputs.page_storage_handles();- let main_document_commit = load_inputs- .main_document_commit_for_final_url(&final_url, None)- .map(Arc::new);- let page_reservation =- self.reserve_renderer_page_for_owner(&navigation.owner, &load_inputs, &engine);- let prepared_page = engine- .prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(- page_reservation,- page_storage.into_navigation_storage(),- requested_url.clone(),- final_url.clone(),- load_inputs.navigation_initiator_url.clone(),- response.redirected,- redirect_chain.len(),- response_status,- response_headers.clone(),- raw_body,- load_inputs.document_start_scripts.clone(),- load_inputs.runtime_bindings.clone(),- load_inputs- .runtime_inspector_session_restore_snapshots- .clone(),- load_inputs.extra_http_headers.clone(),- load_inputs.script_execution_disabled,- load_inputs.bypass_content_security_policy,- load_inputs.emulated_media.clone(),- load_inputs.viewport_surface,- load_inputs.network_offline,- load_inputs.blocked_url_patterns.clone(),- fetch_subresource_interception_enabled,- fetch_subresource_interception_resource_type,- PageVmInitStage::DomContentLoaded,- RendererReplyBoundary::DocumentCommit,- load_inputs.root_frame_id.clone(),- CommittedDocumentResourceSource::Synthetic,- None,- main_document_commit.as_deref().cloned(),- )- .await- .with_context(|| format!(- "failed to prepare response-stage page `{}`",- requested_url- ))?;- if let Some(started) = timing_started {- tracing::info!(- target: "moli_cdp_nav_timing",- url = %requested_url,- stage = "response_stage_document_prepared",- elapsed_ms = started.elapsed().as_millis(),- );- }- Ok(Some(PausedResponsePreparedDocument {- prepared_page,- renderer_body_tx,- renderer_completion_tx,- body_progress_source,- body_network_progress_state,- requested_url,- final_url,- request_method,- request_headers,- response_status,- response_headers,- response_from_cache,- negotiated_http_version,- network_observation_journal: network_observation_journal.clone(),- timing_started,- main_document_commit,- }))- }-pub(crate) fn start_initial_document_page_ensure_for_owner(&mut self,owner: &CommandOwnerScope,@@ -3825,6 +3598,7 @@ 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,diff --git a/moli-protocol/src/conn/state/attachment_identity.rs b/moli-protocol/src/conn/state/attachment_identity.rsindex 163b7770f..f1fd8bae8 100644--- a/moli-protocol/src/conn/state/attachment_identity.rs+++ b/moli-protocol/src/conn/state/attachment_identity.rs@@ -36,6 +36,10 @@ 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/fetch.rs b/moli-protocol/src/conn/state/fetch.rsindex 9c086f7e9..12213759b 100644--- a/moli-protocol/src/conn/state/fetch.rs+++ b/moli-protocol/src/conn/state/fetch.rs@@ -2165,17 +2165,6 @@ impl TargetFetchOwner {.is_some_and(PausedDocumentTransfer::is_pending)}- #[cfg(test)]- pub(crate) fn pending_fetch_response_prepared_renderer_agent_for_test(- &self,- request_id: &str,- ) -> Option<moli_core::page::RendererDevToolsAgentToken> {- self.pending- .pending_fetch_response_transfers- .get(request_id)- .and_then(PausedDocumentTransfer::prepared_renderer_agent_token)- }-#[cfg(test)]pub(crate) fn active_fetch_response_body_stream_request_id_for_test(&self,diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rsindex 3ee27ba80..c9e3765a2 100644--- a/moli-protocol/src/conn/state/page_slot.rs+++ b/moli-protocol/src/conn/state/page_slot.rs@@ -84,16 +84,24 @@ 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) -> Self {+ 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());+ }Self {token,page_attachment_id: TargetPageAttachmentId::allocate(),cancellation_handles: vec![moli_fetch::FetchCancelHandle::new()],background_completion_pending: false,committed: false,+ renderer_target,}}@@ -127,8 +135,15 @@ impl PendingNavigationRequest {self.cancellation_handles.clear();}- fn cancel(&self) {- for cancellation in &self.cancellation_handles {+ 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();}}@@ -667,10 +682,31 @@ impl TargetPageSlot {request_id: NavigationRequestId::allocate(),};self.pending_renderer_page = None;- self.pending_navigation_request = Some(PendingNavigationRequest::new(token.clone()));+ 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,+ ));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();+ }+ }+pub(crate) fn document_navigation_cancellation_handle(&self,token: &DocumentNavigationToken,@@ -828,6 +864,7 @@ 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;@@ -853,7 +890,7 @@ impl TargetPageSlot {) {self.pending_renderer_page = None;}- self.pending_navigation_request = None;+ self.cancel_pending_document_navigation();return true;}false@@ -863,7 +900,7 @@ impl TargetPageSlot {self.finish_renderer_document_lifecycle_observers(RendererDocumentLifecycleObservation::Unavailable,);- self.pending_navigation_request = None;+ self.cancel_pending_document_navigation();self.committed_document_navigation = None;self.pending_renderer_page = None;self.renderer_document_lifecycle = RendererDocumentLifecycleProtocolState::default();diff --git a/moli-protocol/src/conn/tests/navigation_error.rs b/moli-protocol/src/conn/tests/navigation_error.rsindex 574565782..7e85b99f1 100644--- a/moli-protocol/src/conn/tests/navigation_error.rs+++ b/moli-protocol/src/conn/tests/navigation_error.rs@@ -40,7 +40,6 @@ fn failing_streamed_document(response,network_observation_journal: Default::default(),body_progress_source: Default::default(),- prepared_document: None,}}diff --git a/moli-protocol/src/domains/fetch/commands.rs b/moli-protocol/src/domains/fetch/commands.rsindex 64118705a..1c5887273 100644--- a/moli-protocol/src/domains/fetch/commands.rs+++ b/moli-protocol/src/domains/fetch/commands.rs@@ -1872,30 +1872,8 @@ fn continue_streaming_document_response_in_background(response,network_observation_journal,body_progress_source,- prepared_document,} = pending;let cancellation = response.cancellation_handle();- if response_code.is_none()- && response_headers.is_empty()- && let Some(prepared_document) = prepared_document- {- conn.arm_background_navigation_completion(&document_navigation_token, Some(cancellation));- tokio::task::spawn_local(async move {- let body_completion_sink = BackgroundNavigationBodyCompletionSink::new(- sender.clone(),- document_navigation_token.clone(),- navigation.clone(),- );- let navigation_result =- prepared_document.resume_streaming(response, Some(body_completion_sink));- let _ = sender.send(page::BackgroundNavigationCompletion::new(- document_navigation_token,- navigation,- Ok(navigation_result),- ));- });- return;- }let job = conn.background_streaming_response_navigation_load_job_for_navigation(&navigation,response,diff --git a/moli-protocol/src/domains/fetch/navigation.rs b/moli-protocol/src/domains/fetch/navigation.rsindex 687a913a8..9127d0740 100644--- a/moli-protocol/src/domains/fetch/navigation.rs+++ b/moli-protocol/src/domains/fetch/navigation.rs@@ -530,27 +530,9 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(network_extra_info_available,);out.extend_background_events_after_messages(response_extra_info_events);- let prepared_document = match conn- .prepare_paused_streaming_response_navigation_async(- &pending.navigation,- response.response(),- network_observation_journal,- body_progress_source.clone(),- )- .await- {- Ok(prepared_document) => prepared_document,- Err(error) => {- complete_pending_fetch_navigation_result_into_buffer_async(- conn,- out,- pending,- Err(error),- )- .await;- return;- }- };+ // Keep only the response until the client accepts it. Preparing a renderer+ // here would wait on the old document's debugger pause before we could even+ // publish Fetch.requestPaused. Continue/fulfill owns document replacement.let (response, network_observation_journal) = response.into_parts_with_observation_journal();conn.register_pending_fetch_response_navigation_for_owner(&pending.navigation.owner,@@ -564,7 +546,6 @@ async fn handle_streaming_response_head_for_navigation_into_buffer_async(response,network_observation_journal,body_progress_source,- prepared_document: prepared_document.map(Box::new),},);out.extend_background_events_after_messages([navigation_response_stage_request_paused_event(diff --git a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rsindex 8c986f6b5..a45cf0a97 100644--- a/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs+++ b/moli-protocol/src/domains/fetch/tests/navigation_response_stage.rs@@ -72,16 +72,15 @@ async fn response_stage_pause_happens_before_navigation_body_eof() {.as_str().expect("response-stage request id").to_owned();- let prepared_agent = ctx- .conn- .browser_context- .as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&response_request_id)- })- .expect("final response head should reserve a renderer agent before continueResponse");+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .unwrap()+ .active_page_target()+ .fetch_owner+ .pending_fetch_response_transfer_is_pending_for_test(&response_request_id)+ );assert!(ctx.conn.browser_context@@ -106,19 +105,6 @@ async fn response_stage_pause_happens_before_navigation_body_eof() {Some("SID-1"),);- {- let page = ctx- .conn- .browser_context- .as_ref()- .and_then(|bc| bc.loaded_page())- .expect("loaded page");- assert_eq!(- page.renderer_devtools_agent_token(),- prepared_agent,- "continueResponse must commit the exact agent reserved at the response head"- );- }assert!(loaded_page_html_for_test(&mut ctx).await@@ -165,11 +151,7 @@ async fn assert_empty_http_error_response_stage(ctx: &mut TestContext, url: &strctx.conn.browser_context.as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&request_id)- })+ .and_then(|bc| bc.loaded_page()).is_none(),"an empty HTTP error must be classified from its body after continueResponse");@@ -857,7 +839,7 @@ 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_prepared_document() {+async fn interleaved_response_heads_only_commit_the_current_response() {async fn first() -> impl IntoResponse {([(CONTENT_TYPE.as_str(), "text/html")],@@ -919,16 +901,15 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document().as_str().expect("first response-stage request id").to_owned();- let first_agent = ctx- .conn- .browser_context- .as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&first_request_id)- })- .expect("first response head should reserve a renderer agent");+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .unwrap()+ .active_page_target()+ .fetch_owner+ .pending_fetch_response_transfer_is_pending_for_test(&first_request_id)+ );ctx.process_async(json!({"id": 366,@@ -942,17 +923,15 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document().as_str().expect("second response-stage request id").to_owned();- let second_agent = ctx- .conn- .browser_context- .as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&second_request_id)- })- .expect("second response head should reserve a renderer agent");- assert_ne!(first_agent, second_agent);+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .unwrap()+ .active_page_target()+ .fetch_owner+ .pending_fetch_response_transfer_is_pending_for_test(&second_request_id)+ );let attachment_before_continue = ctx.conn.browser_context.as_ref().and_then(|bc| {bc.active_page_target()@@ -1003,8 +982,6 @@ async fn interleaved_response_heads_only_commit_the_current_prepared_document().as_ref().and_then(|bc| bc.loaded_page()).expect("current navigation should commit a page");- assert_eq!(page.renderer_devtools_agent_token(), second_agent);- assert_ne!(page.renderer_devtools_agent_token(), first_agent);let html = page.serialize_html_async().await@@ -1802,16 +1779,12 @@ async fn fail_request_at_response_stage_aborts_navigation() {.current_renderer_attachment()});assert!(- ctx.conn- .browser_context- .as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&response_request_id)- })- .is_some(),- "response head should own a prepared candidate before cancellation"+ ctx.conn.browser_context.as_ref().is_some_and(|bc| {+ bc.active_page_target()+ .fetch_owner+ .pending_fetch_response_transfer_is_pending_for_test(&response_request_id)+ }),+ "response head should retain its pending transfer before cancellation");ctx.process_async(json!({@@ -1834,14 +1807,14 @@ async fn fail_request_at_response_stage_aborts_navigation() {.runtime_slot.current_renderer_attachment(),attachment_before_cancel,- "canceling a response-stage candidate must not switch the renderer channel"+ "canceling a response-stage transfer must not switch the renderer channel");server.abort();}#[tokio::test(flavor = "multi_thread")]-async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once() {+async fn fulfill_request_at_response_stage_replaces_the_network_response_once() {async fn handler() -> impl IntoResponse {([(CONTENT_TYPE.as_str(), "text/html")],@@ -1891,16 +1864,15 @@ async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once().as_str().expect("response-stage request id").to_owned();- let network_agent = ctx- .conn- .browser_context- .as_ref()- .and_then(|bc| {- bc.active_page_target()- .fetch_owner- .pending_fetch_response_prepared_renderer_agent_for_test(&request_id)- })- .expect("network response head should reserve a renderer agent");+ assert!(+ ctx.conn+ .browser_context+ .as_ref()+ .unwrap()+ .active_page_target()+ .fetch_owner+ .pending_fetch_response_transfer_is_pending_for_test(&request_id)+ );ctx.process_async(json!({"id": 371,@@ -1927,11 +1899,6 @@ async fn fulfill_request_at_response_stage_replaces_the_network_candidate_once().as_ref().and_then(|bc| bc.loaded_page()).expect("synthetic response should commit a page");- assert_ne!(- page.renderer_devtools_agent_token(),- network_agent,- "fulfillRequest must discard the prepared network response candidate"- );let html = page.serialize_html_async().awaitdiff --git a/moli-protocol/src/domains/network/main_document_progress/mod.rs b/moli-protocol/src/domains/network/main_document_progress/mod.rsindex 7764c9120..3502b9b72 100644--- a/moli-protocol/src/domains/network/main_document_progress/mod.rs+++ b/moli-protocol/src/domains/network/main_document_progress/mod.rs@@ -71,6 +71,16 @@ pub(crate) enum FailedNavigationDocumentPolicy {}impl FailedNavigationDocumentPolicy {+ fn for_navigation_error(error_text: &str) -> Self {+ // Fetch.failRequest supplies the CDP reason "Aborted", while the+ // transport supplies net::ERR_ABORTED. Both cancel the provisional+ // load without discarding the currently committed document.+ match error_text {+ "Aborted" | moli_fetch::NET_ERR_ABORTED_ERROR_TEXT => Self::PreserveCommittedDocument,+ _ => Self::InvalidateCommittedDocument,+ }+ }+pub(crate) fn invalidates_committed_document(self) -> bool {matches!(self, Self::InvalidateCommittedDocument)}@@ -350,11 +360,12 @@ fn materialize_navigation_load_outcome(materialize_download_navigation_progress(conn, state, *navigation),),NavigationLoadOutcome::NetworkFailure(error_text) => {+ let document_policy = FailedNavigationDocumentPolicy::for_navigation_error(&error_text);MaterializedNavigationLoadOutcome::Failed(materialize_failed_navigation_progress(conn,state,error_text,- FailedNavigationDocumentPolicy::InvalidateCommittedDocument,+ document_policy,FailedNavigationResponseMode::CdpErrorTextResult,))}@@ -378,11 +389,12 @@ pub(crate) fn materialize_navigation_load_result(Some(blocked) => blocked.to_string(),None => format!("{error:#}"),};+ let document_policy = FailedNavigationDocumentPolicy::for_navigation_error(&error_text);MaterializedNavigationLoadOutcome::Failed(materialize_failed_navigation_progress(conn,state,error_text,- FailedNavigationDocumentPolicy::InvalidateCommittedDocument,+ document_policy,FailedNavigationResponseMode::ProtocolError,))}diff --git a/moli-protocol/src/domains/network/main_document_progress/tests.rs b/moli-protocol/src/domains/network/main_document_progress/tests.rsindex d5e79a961..bd7b17dae 100644--- a/moli-protocol/src/domains/network/main_document_progress/tests.rs+++ b/moli-protocol/src/domains/network/main_document_progress/tests.rs@@ -18,6 +18,26 @@ use super::gate::{};use super::*;+#[test]+fn aborted_navigation_preserves_the_document_without_hiding_other_failures() {+ for error_text in ["Aborted", "net::ERR_ABORTED"] {+ assert_eq!(+ FailedNavigationDocumentPolicy::for_navigation_error(error_text),+ FailedNavigationDocumentPolicy::PreserveCommittedDocument,+ );+ }+ for error_text in [+ "Failed",+ "net::ERR_CONNECTION_RESET",+ "net::ERR_BLOCKED_BY_CLIENT",+ ] {+ assert_eq!(+ FailedNavigationDocumentPolicy::for_navigation_error(error_text),+ FailedNavigationDocumentPolicy::InvalidateCommittedDocument,+ );+ }+}+fn completed_events() -> CompletedMainDocumentNetworkEvents {CompletedMainDocumentNetworkEvents::new("GET".to_owned(),diff --git a/moli-renderer-v8/src/devtools/ingress/io.rs b/moli-renderer-v8/src/devtools/ingress/io.rsindex d19809300..80b93402b 100644--- a/moli-renderer-v8/src/devtools/ingress/io.rs+++ b/moli-renderer-v8/src/devtools/ingress/io.rs@@ -529,7 +529,9 @@ impl RendererInspectorIoIngress {&self,pause_bridge: &crate::devtools::pause::RendererInspectorPauseBridge,) -> Option<RendererInspectorIoCommand> {- pause_bridge.wait_for_pause_work(|| self.claim_for_pause())+ pause_bridge+ .wait_for_pause_work(|| self.claim_for_pause())+ .ok()}fn claim_next(diff --git a/moli-renderer-v8/src/devtools/pause/loop_state.rs b/moli-renderer-v8/src/devtools/pause/loop_state.rsindex 686e8921f..ff13b5af8 100644--- a/moli-renderer-v8/src/devtools/pause/loop_state.rs+++ b/moli-renderer-v8/src/devtools/pause/loop_state.rs@@ -17,3 +17,11 @@ pub(crate) enum RendererInspectorPauseLoopPolicy {MainAndIo,IoOnly,}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum RendererInspectorPauseExitReason {+ Resumed,+ Navigation,+ SessionDetached,+ TargetClosed,+}diff --git a/moli-renderer-v8/src/devtools/pause/mod.rs b/moli-renderer-v8/src/devtools/pause/mod.rsindex 5f4075421..58d1fe754 100644--- a/moli-renderer-v8/src/devtools/pause/mod.rs+++ b/moli-renderer-v8/src/devtools/pause/mod.rs@@ -24,6 +24,7 @@ use crate::runtime::{mod causality;mod loop_state;+mod navigation;use causality::{RendererInspectorPauseCommandDispatch, RendererInspectorPauseCommandTransition,@@ -32,8 +33,9 @@ use causality::{pub(crate) use causality::{RendererInspectorPauseCommandOutputRoute, RendererInspectorPauseNotificationRoute,};-pub(crate) use loop_state::RendererInspectorPauseLoopPolicy;use loop_state::RendererInspectorPausePhase;+pub(crate) use loop_state::{RendererInspectorPauseExitReason, RendererInspectorPauseLoopPolicy};+use navigation::RendererProvisionalLoad;#[derive(Clone)]pub(crate) struct RendererInspectorPauseBridge {@@ -56,6 +58,7 @@ struct RendererInspectorPauseBridgeState {pause_loop_policy: RendererInspectorPauseLoopPolicy,quit_requested: bool,session_detach_arms: usize,+ provisional_load: Option<RendererProvisionalLoad>,target_closed: bool,pending_prefaces: VecDeque<RendererInspectorPausePreface>,paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,@@ -125,6 +128,7 @@ impl RendererInspectorPauseBridge {pause_loop_policy: RendererInspectorPauseLoopPolicy::MainAndIo,quit_requested: false,session_detach_arms: 0,+ provisional_load: None,target_closed: false,pending_prefaces: VecDeque::new(),paused_sessions_awaiting_resumed: HashSet::new(),@@ -147,6 +151,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("target_closed", &state.target_closed).field("pending_prefaces", &state.pending_prefaces.len()).field(@@ -359,14 +364,29 @@ impl RendererInspectorPauseBridge {Some(state.pause_loop_policy)}- pub(crate) fn wait_for_pause_work<T>(&self, mut claim: impl FnMut() -> Option<T>) -> Option<T> {+ pub(crate) fn wait_for_pause_work<T>(+ &self,+ mut claim: impl FnMut() -> Option<T>,+ ) -> Result<T, RendererInspectorPauseExitReason> {let mut state = self.shared.state.lock();loop {- if state.target_closed || state.quit_requested || state.session_detach_arms != 0 {- return None;+ if state.target_closed {+ return Err(RendererInspectorPauseExitReason::TargetClosed);+ }+ if matches!(+ state.provisional_load,+ Some(RendererProvisionalLoad::ReplacingDocument(_))+ ) {+ return Err(RendererInspectorPauseExitReason::Navigation);+ }+ if state.session_detach_arms != 0 {+ return Err(RendererInspectorPauseExitReason::SessionDetached);+ }+ if state.quit_requested {+ return Err(RendererInspectorPauseExitReason::Resumed);}if let Some(work) = claim() {- return Some(work);+ return Ok(work);}self.shared.pause_loop_wake.wait(&mut state);}diff --git a/moli-renderer-v8/src/devtools/pause/navigation.rs b/moli-renderer-v8/src/devtools/pause/navigation.rsnew file mode 100644index 000000000..07fcbc6aa--- /dev/null+++ b/moli-renderer-v8/src/devtools/pause/navigation.rs@@ -0,0 +1,206 @@+#[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/devtools/target.rs b/moli-renderer-v8/src/devtools/target.rsindex b6767d6c4..cb0fb80ab 100644--- a/moli-renderer-v8/src/devtools/target.rs+++ b/moli-renderer-v8/src/devtools/target.rs@@ -93,7 +93,8 @@ impl Drop for RendererDevToolsTargetShutdownRegistration {/// only ingress and lifecycle coordination; all V8 session access remains in/// the renderer-local Inspector executor.#[derive(Clone)]-pub(crate) struct RendererDevToolsTargetHandle {+#[doc(hidden)]+pub struct RendererDevToolsTargetHandle {pause: RendererInspectorPauseBridge,main: RendererInspectorMainIngress,io: RendererInspectorIoIngress,diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rsindex f52835290..44e250da4 100644--- a/moli-renderer-v8/src/lib.rs+++ b/moli-renderer-v8/src/lib.rs@@ -234,18 +234,19 @@ pub use runtime::{RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,- 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,+ 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,RendererDocumentSourcedSameDocumentNavigation,RendererDocumentSourcedTopLevelLocationNavigation, RendererDocumentTerminationReason,diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rsindex 0880947fa..c22ab7d22 100644--- a/moli-renderer-v8/src/runtime/mod.rs+++ b/moli-renderer-v8/src/runtime/mod.rs@@ -434,6 +434,7 @@ 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_local.rs b/moli-renderer-v8/src/runtime/owner_local.rsindex 15194cbda..2a5a590cf 100644--- a/moli-renderer-v8/src/runtime/owner_local.rs+++ b/moli-renderer-v8/src/runtime/owner_local.rs@@ -271,6 +271,11 @@ impl RendererPageHandle {self.devtools_target.pause_ref().is_pause_active()}+ #[doc(hidden)]+ pub fn renderer_devtools_target(&self) -> super::RendererDevToolsTargetHandle {+ self.devtools_target.clone()+ }+/// Enqueues the DevTools IO-agent script policy without borrowing the/// owner-resident `PageVm` that may currently be executing JavaScript.#[doc(hidden)]diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rsindex ed5490bc5..e0267d796 100644--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs@@ -171,55 +171,60 @@ impl RendererInspectorSessionExecutorLocal {return;};let mut prefer_main = true;- while let Some(command) = self.target.pause_ref().wait_for_pause_work(|| {- // These are actual posted owner tasks, not an environment-version- // check. Service them in both pause modes, before a following- // Inspector observation; they never execute page JavaScript.- if let Some(invalidation) = self.target.io_ref().claim_environment_invalidation() {- return Some(RendererInspectorNestedCommand::EnvironmentInvalidation(- invalidation,- ));- }- let command = match pause_loop_policy {- crate::devtools::pause::RendererInspectorPauseLoopPolicy::IoOnly => self- .target- .io_ref()- .claim_for_pause()- .map(RendererInspectorNestedCommand::Io),- crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo- if prefer_main =>- {- self.target- .main_ref()- .claim_for_pause()- .map(RendererInspectorNestedCommand::Main)- .or_else(|| {- self.target- .io_ref()- .claim_for_pause()- .map(RendererInspectorNestedCommand::Io)- })+ let exit_reason = loop {+ let work = self.target.pause_ref().wait_for_pause_work(|| {+ // These are actual posted owner tasks, not an environment-version+ // check. Service them in both pause modes, before a following+ // Inspector observation; they never execute page JavaScript.+ if let Some(invalidation) = self.target.io_ref().claim_environment_invalidation() {+ return Some(RendererInspectorNestedCommand::EnvironmentInvalidation(+ invalidation,+ ));}- crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo => self- .target- .io_ref()- .claim_for_pause()- .map(RendererInspectorNestedCommand::Io)- .or_else(|| {+ let command = match pause_loop_policy {+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::IoOnly => self+ .target+ .io_ref()+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Io),+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo+ if prefer_main =>+ {self.target.main_ref().claim_for_pause().map(RendererInspectorNestedCommand::Main)- }),+ .or_else(|| {+ self.target+ .io_ref()+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Io)+ })+ }+ crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo => self+ .target+ .io_ref()+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Io)+ .or_else(|| {+ self.target+ .main_ref()+ .claim_for_pause()+ .map(RendererInspectorNestedCommand::Main)+ }),+ };+ if command.is_some()+ && pause_loop_policy+ == crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo+ {+ prefer_main = !prefer_main;+ }+ command+ });+ let command = match work {+ Ok(command) => command,+ Err(reason) => break reason,};- if command.is_some()- && pause_loop_policy- == crate::devtools::pause::RendererInspectorPauseLoopPolicy::MainAndIo- {- prefer_main = !prefer_main;- }- command- }) {match command {RendererInspectorNestedCommand::EnvironmentInvalidation(invalidation) => {let isolate = unsafe { &mut *self.isolate.get() };@@ -233,6 +238,23 @@ impl RendererInspectorSessionExecutorLocal {self.dispatch_io_command(context_group_id, command);}}+ };+ if exit_reason == crate::devtools::pause::RendererInspectorPauseExitReason::Navigation {+ // 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+ // into the replacement document's Inspector restore snapshots.+ let sessions: Vec<_> = self+ .sessions+ .borrow()+ .iter()+ .filter(|((group, _), _)| *group == context_group_id)+ .filter_map(|(_, route)| route.session.upgrade())+ .collect();+ for session in sessions {+ session.resume(true);+ }}self.target.pause_ref().leave_pause();}diff --git a/vendor/v8-152.2.0/src/inspector.rs b/vendor/v8-152.2.0/src/inspector.rsindex 99ea3b89b..e60c2142d 100644--- a/vendor/v8-152.2.0/src/inspector.rs+++ b/vendor/v8-152.2.0/src/inspector.rs@@ -82,6 +82,10 @@ unsafe extern "C" {);fn v8_inspector__V8InspectorSession__DELETE(this: *mut RawV8InspectorSession);+ fn v8_inspector__V8InspectorSession__resume(+ session: *mut RawV8InspectorSession,+ terminate_on_resume: bool,+ );fn v8_inspector__V8InspectorSession__dispatchProtocolMessage(session: *mut RawV8InspectorSession,message: StringView,@@ -965,6 +969,16 @@ impl V8InspectorSession {}}+ /// Resumes paused execution, optionally terminating it as it unwinds.+ pub fn resume(&self, terminate_on_resume: bool) {+ unsafe {+ v8_inspector__V8InspectorSession__resume(+ self.raw.as_ptr(),+ terminate_on_resume,+ );+ }+ }+/// Cancel a pause previously scheduled by/// [`Self::schedule_pause_on_next_statement`] if it hasn't fired yet.pub fn cancel_pause_on_next_statement(&self) {diff --git a/vendor/v8-152.2.0/src/inspector_session_ext.cc b/vendor/v8-152.2.0/src/inspector_session_ext.ccindex ea4a8f112..447f3a961 100644--- a/vendor/v8-152.2.0/src/inspector_session_ext.cc+++ b/vendor/v8-152.2.0/src/inspector_session_ext.cc@@ -7,6 +7,11 @@ using namespace support;extern "C" {+void v8_inspector__V8InspectorSession__resume(+ v8_inspector::V8InspectorSession* self, bool terminate_on_resume) {+ self->resume(terminate_on_resume);+}+void v8_inspector__V8InspectorSession__breakProgram(v8_inspector::V8InspectorSession* self,v8_inspector::StringView reason,