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(parser): defer document close while blocked
ldm0fa93bfbc40f9
diff --git a/moli-renderer-v8/src/document_runtime/document_write.rs b/moli-renderer-v8/src/document_runtime/document_write.rsindex cef24a6a6..dc4f21406 100644--- a/moli-renderer-v8/src/document_runtime/document_write.rs+++ b/moli-renderer-v8/src/document_runtime/document_write.rs@@ -354,15 +354,10 @@ impl DocumentRuntime {closed,"a live root parser must own an open document stream");- let close_transitioned = self- .root_document_parser+ self.root_document_parser.as_mut().expect("root document parser existence was checked").request_close();- debug_assert!(- close_transitioned,- "an open root document parser must accept its first close request"- );}let _ = self.finish_root_document_parser_stream_if_ready(scope, host_ptr);truediff --git a/moli-renderer-v8/src/live_document_parser.rs b/moli-renderer-v8/src/live_document_parser.rsindex b4594910d..d0b3a718d 100644--- a/moli-renderer-v8/src/live_document_parser.rs+++ b/moli-renderer-v8/src/live_document_parser.rs@@ -177,6 +177,15 @@ pub(crate) enum DocumentParserLifetime {Closing,}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum DocumentParserCloseDisposition {+ /// The parser is ready to consume any queued input and reach EOF now.+ DrainNow,+ /// An active parser operation or blocker owns progress; closing resumes+ /// through that operation's existing completion path.+ DeferredUntilReady,+}+static NEXT_DOCUMENT_PARSER_SESSION_ID: AtomicU64 = AtomicU64::new(1);#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]@@ -664,12 +673,13 @@ impl DocumentParserSession {self.lifetime}- pub(crate) fn request_close(&mut self) -> bool {- if self.lifetime == DocumentParserLifetime::Closing {- return false;- }+ pub(crate) fn request_close(&mut self) -> DocumentParserCloseDisposition {self.lifetime = DocumentParserLifetime::Closing;- true+ if self.run_state() == DocumentParserRunState::Ready {+ DocumentParserCloseDisposition::DrainNow+ } else {+ DocumentParserCloseDisposition::DeferredUntilReady+ }}pub(crate) fn finishes_when_drained(&self) -> bool {@@ -1098,6 +1108,39 @@ mod session_state_tests {assert_eq!(parser.resume(second), ParserResumeApplication::Resumed);}+ #[test]+ fn close_defers_without_consuming_the_active_parser_suspension() {+ let mut parser = DocumentParserSession::start_open_live_document(+ Url::parse("https://parser-session.test/").expect("test URL"),+ NativeNodeId::new(1),+ );+ let parser_owner = owner(1, 2, 3);+ parser.bind_owner(parser_owner, 11);+ let permit = parser.suspend(ParserSuspensionCause::ParserClassicSource {+ script: NativeNodeId::new(8),+ });+ let suspended_state = parser.run_state();++ assert_eq!(+ parser.request_close(),+ DocumentParserCloseDisposition::DeferredUntilReady+ );+ assert_eq!(parser.lifetime(), DocumentParserLifetime::Closing);+ assert_eq!(+ parser.run_state(),+ suspended_state,+ "document.close() must not bypass the active parser blocker"+ );+ assert_eq!(parser.current_resume_permit(), Some(permit));++ assert_eq!(parser.resume(permit), ParserResumeApplication::Resumed);+ assert_eq!(+ parser.request_close(),+ DocumentParserCloseDisposition::DrainNow,+ "the delayed close can drain after the exact blocker releases"+ );+ }+#[test]fn parser_pump_and_drop_transitions_are_observable_by_derived_capabilities() {let parser = session();diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rsindex c8386aacc..5a44148a4 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/live_parser.rs@@ -13,9 +13,9 @@ use crate::{LocalWindowId,},live_document_parser::{- DocumentParserLifetime, DocumentParserRunState, DocumentParserSession,- LiveDocumentParserOwner, LiveDocumentParserStepOutcome, ParserResumeApplication,- ParserSuspensionCause,+ DocumentParserCloseDisposition, DocumentParserLifetime, DocumentParserRunState,+ DocumentParserSession, LiveDocumentParserOwner, LiveDocumentParserStepOutcome,+ ParserResumeApplication, ParserSuspensionCause,},modulepreload::{invalid_modulepreload_as_value, invalid_modulepreload_as_warning,@@ -1044,8 +1044,14 @@ impl JsContextHost {.script_input_session().enqueue_script_input_html(chunk);}- if close_requested {- entry.request_close();+ let parser_ready_to_advance = if close_requested {+ entry.request_close() == DocumentParserCloseDisposition::DrainNow+ } else {+ entry.run_state() == DocumentParserRunState::Ready+ };+ if !parser_ready_to_advance {+ self.child_document_parsers.replace(owner, entry);+ return true;}loop {diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rsindex b519a765b..9f75d2bc8 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs@@ -11067,6 +11067,137 @@ async fn child_document_write_nested_external_classic_blocks_domcontentloaded().await;}+#[tokio::test]+async fn child_document_close_defers_while_written_external_classic_blocks_parser() {+ run_page_vm_async_test(async move {+ let (base_url, server) = spawn_path_response_http_server(vec![(+ "/child-close-blocker.js",+ "HTTP/1.1 200 OK",+ "parent.__childCloseEvents.push('external:' + Boolean(document.getElementById('after-blocker')));"+ .to_owned(),+ Duration::ZERO,+ )])+ .await;+ let loader =+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");+ let document_url = Url::parse(&format!("{base_url}/page")).expect("page url");+ let page_vm = test_page_vm_with_loader_and_document_url(&loader, Vec::new(), document_url);+ let local_executor = page_vm.local_executor.clone();++ let (+ events_after_close,+ source_load_source,+ events_after_external,+ final_events,+ tail_exists,+ ) = local_executor+ .run(async move {+ let mut page_vm = page_vm;+ page_vm.vm_mut().eval(+ r#"+(() => {+ globalThis.__childCloseEvents = [];+ const frame = document.createElement("iframe");+ frame.id = "child-close-frame";+ document.body.appendChild(frame);+})()+"#,+ )?;+ materialize_child_realm_through_page_turn_for_test(+ &mut page_vm,+ "child-close-frame",+ )?;++ let script_url = format!("{base_url}/child-close-blocker.js");+ page_vm.vm_mut().eval(&format!(+ r#"+(() => {{+ const frame = document.getElementById("child-close-frame");+ frame.onload = () => __childCloseEvents.push("load");+ const childDocument = frame.contentDocument;+ childDocument.open();+ childDocument.addEventListener("DOMContentLoaded", () => __childCloseEvents.push("dcl"));+ childDocument.write(`<script src="{script_url}"><\/script><main id="after-blocker">tail</main>`);+ childDocument.close();+ __childCloseEvents.push("after-close");+}})()+"#,+ ))?;+ let events_after_close = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;+ let source_load_source =+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(+ &mut page_vm,+ ChildFrameSemanticTurnKind::ClassicScriptSourceLoad,+ "document.close delayed external classic source load",+ )+ .await;+ if !page_vm+ .page_resource_completion_queue()+ .has_ready_completion()+ {+ let arrived = tokio::time::timeout(+ Duration::from_secs(2),+ wait_for_typed_page_resource_completion(&mut page_vm),+ )+ .await+ .expect("child close blocker completion should arrive before timeout");+ assert!(+ arrived,+ "child close blocker completion sender should remain open"+ );+ }+ let _ = run_next_resource_completion_as_typed_page_turn(&mut page_vm)?;+ run_expected_child_frame_task_source_after_realm_prerequisite_for_wait(+ &mut page_vm,+ ChildFrameSemanticTurnKind::DocumentScriptReady,+ "document.close delayed external classic execution",+ )+ .await;+ let events_after_external =+ page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;+ run_child_interactive_domcontentloaded_then_host_load_for_wait(+ &mut page_vm,+ "document.close delayed child load",+ )+ .await;+ let final_events = page_vm.vm_mut().eval("__childCloseEvents.join('|')")?;+ let tail_exists = page_vm.vm_mut().eval(+ "String(Boolean(document.getElementById('child-close-frame').contentDocument.getElementById('after-blocker')))",+ )?;++ Ok::<_, anyhow::Error>((+ events_after_close,+ source_load_source,+ events_after_external,+ final_events,+ tail_exists,+ ))+ })+ .await+ .expect("child document.close delayed EOF test should run");++ assert_eq!(+ events_after_close, "after-close",+ "document.close() should return without executing or bypassing the blocker"+ );+ assert_eq!(+ source_load_source,+ ChildFrameSemanticTurnKind::ClassicScriptSourceLoad+ );+ assert_eq!(+ events_after_external, "after-close|external:false",+ "the external parser-blocking script must run before future markup is parsed"+ );+ assert_eq!(final_events, "after-close|external:false|dcl|load");+ assert_eq!(tail_exists, "true");++ server+ .await+ .expect("child close blocker server should finish");+ })+ .await;+}+#[tokio::test]async fn page_vm_nested_frame_finish_releases_parent_document_lifecycle() {run_page_vm_async_test(async move {