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(fonts): retain pending loads across promise chains
ldm0ac823a3eabca
diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rsindex ce40e83b4..17b532725 100644--- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs+++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs@@ -24,9 +24,9 @@ pub(super) fn load_matching_faces<'s>(return promise;}let state = v8::Object::new(scope);- // Reactions retain their state from the input promises, but the returned- // promise must also retain it when a CSS face leaves document.fonts.- // This heap edge keeps the settlement endpoints alive without a Global.+ // Keep the direct promise's state in the JS heap as well. Native pending+ // font loads root each face until completion or Window retirement, so a+ // downstream .then()/await promise need not retain this original promise.set_private_value(scope, promise.into(), QUERY_STATE, state.into());set_private_value(scope, state, QUERY_RESOLVER, resolver.into());set_private_value(scope, state, QUERY_FACES, faces.into());@@ -199,10 +199,9 @@ pub(super) fn initialize_resolver<'s>(request_context: Option<crate::native_bridge::WindowExecutionContextIdentity>,) {set_private_value(scope, face, RESOLVER, resolver.into());- // A retained pending .loaded promise must retain its settlement endpoint,- // including CSS-started loads with no explicit JS network request root.- // Keep this edge in the JS heap so an otherwise unreachable cycle remains- // collectible; no isolate-wide Global may keep a retired document alive.+ // A retained pending .loaded promise also retains its settlement endpoint.+ // Loading faces have a Window-owned native root, released on completion+ // or retirement; unloaded JS-only cycles remain collectible.set_private_value(scope,resolver.get_promise(scope).into(),@@ -216,6 +215,9 @@ pub(super) fn initialize_resolver<'s>(/// Only the observer layer creates JS errors, settles promises and dispatches/// events. Native CSS completions update the same resource without touching V8.fn publish_state<'s>(scope: &mut v8::PinScope<'s, '_>, face: v8::Local<'s, v8::Object>) {+ // Synchronize before running any reentrant loading handler, including when+ // rebinding replaced the resource without changing its published status.+ super::state::sync_loading_root(scope, face);let Some((previous, load)) = super::state::take_change(scope, face) else {return;};diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rsindex 5db03817f..3fc8d1369 100644--- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs+++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs@@ -107,6 +107,41 @@ pub(super) fn request_context<'s>(.request_context}+/// Native loading operations retain the wrapper, independently of which+/// promise in a .then()/await chain page code keeps alive. Retired Windows+/// cannot acquire new roots, and terminal resources release existing roots.+pub(super) fn sync_loading_root<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ face: v8::Local<'s, v8::Object>,+) {+ let Some(id) = id(scope, face) else {+ return;+ };+ let Some((loading, request_context)) = scope.get_slot::<Store>().and_then(|store| {+ let store = store.borrow();+ let observer = store.entries.get(&id)?;+ Some((+ observer.load.borrow().status() == FontFaceStatus::Loading,+ observer.request_context,+ ))+ }) else {+ return;+ };+ let Some(context) = face.get_creation_context(scope) else {+ return;+ };+ let scope = &mut v8::ContextScope::new(scope, context);+ let Some(host_ptr) = crate::util::context_host_ptr_from_global_bridge(scope) else {+ return;+ };+ let host = unsafe { &mut *host_ptr };+ if let (true, Some(identity)) = (loading, request_context) {+ host.retain_pending_font_face_load(scope, id, identity, face);+ } else {+ host.release_pending_font_face_load(id);+ }+}+pub(super) fn bind<'s>(scope: &mut v8::PinScope<'s, '_>,face: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rsindex c6808ee11..3fc5bc759 100644--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs@@ -468,6 +468,7 @@ impl JsContextHost {next_image_decode_id: 1,pending_image_decode_requests: HashMap::new(),resource_timing_buffers: SharedResourceTimingBufferRegistry::new(),+ pending_font_face_loads: HashMap::new(),next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId::first(),pending_webcrypto_tasks: HashMap::new(),opfs_owner_state: None,diff --git a/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rsnew file mode 100644index 000000000..e174d2494--- /dev/null+++ b/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rs@@ -0,0 +1,65 @@+use super::{+ JsContextHost, RuntimeObservableContextToken, WindowExecutionContextIdentity,+ WindowExecutionContextOwner,+};++/// CSS-started requests do not carry a JS FontFace continuation. Keep their+/// settlement endpoints alive even when page code retains only a derived+/// promise. The creating Window owns these roots and retires them on teardown.+pub(super) struct PendingFontFaceLoad {+ execution_context: WindowExecutionContextIdentity,+ _face: v8::Global<v8::Object>,+}++impl JsContextHost {+ pub(crate) fn retain_pending_font_face_load(+ &mut self,+ scope: &mut v8::PinScope<'_, '_>,+ id: u64,+ execution_context: WindowExecutionContextIdentity,+ face: v8::Local<'_, v8::Object>,+ ) {+ if !self.window_execution_context_identity_is_current(execution_context) {+ self.pending_font_face_loads.remove(&id);+ return;+ }+ self.pending_font_face_loads+ .entry(id)+ .or_insert_with(|| PendingFontFaceLoad {+ execution_context,+ _face: v8::Global::new(scope, face),+ });+ }++ pub(crate) fn release_pending_font_face_load(&mut self, id: u64) {+ self.pending_font_face_loads.remove(&id);+ }++ pub(crate) fn retire_font_face_loads_for_context_token(+ &mut self,+ token: RuntimeObservableContextToken,+ ) -> usize {+ let before = self.pending_font_face_loads.len();+ self.pending_font_face_loads+ .retain(|_, pending| pending.execution_context.realm_token() != token);+ before - self.pending_font_face_loads.len()+ }++ pub(crate) fn retire_font_face_loads_for_execution_context_owner(+ &mut self,+ owner: WindowExecutionContextOwner,+ ) {+ self.pending_font_face_loads+ .retain(|_, pending| pending.execution_context.owner() != owner);+ }++ #[cfg(test)]+ pub(crate) fn pending_font_face_execution_contexts_for_test(+ &self,+ ) -> Vec<WindowExecutionContextIdentity> {+ self.pending_font_face_loads+ .values()+ .map(|pending| pending.execution_context)+ .collect()+ }+}diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rsindex 764b80051..127fe4456 100644--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs@@ -147,6 +147,7 @@ mod security_policy;mod selection_records;mod service_workers;pub(crate) use service_workers::ServiceWorkerWindowOwner;+mod font_face_loads;mod shared_workers;mod signal_bridge;mod storage_events;@@ -942,6 +943,7 @@ pub(crate) struct JsContextHost {next_image_decode_id: u64,pending_image_decode_requests: HashMap<ImageDecodeRequestId, PendingImageDecodeRequest>,resource_timing_buffers: SharedResourceTimingBufferRegistry,+ pending_font_face_loads: HashMap<u64, font_face_loads::PendingFontFaceLoad>,next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId,pending_webcrypto_tasks: HashMap<crate::page_task_queue::RendererPageWebCryptoTaskId,diff --git a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rsindex 9d8bd9f13..39f9c0717 100644--- a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs@@ -112,6 +112,7 @@ impl JsContextHost {let bindings = self.retire_runtime_binding_context_token(realm_token);let images = self.retire_image_decode_requests_for_context_token(realm_token);let crypto = self.retire_webcrypto_context_token(realm_token);+ let fonts = self.retire_font_face_loads_for_context_token(realm_token);self.retire_opfs_context_token(realm_token);let workers = self.retire_workers_for_context_token(realm_token);let shared_workers = self.disconnect_shared_worker_clients_for_context_token(realm_token);@@ -128,6 +129,7 @@ impl JsContextHost {bindings = bindings.retired_execution_context_count(),images,crypto,+ fonts,workers,shared_workers,xhrs,@@ -208,6 +210,7 @@ impl JsContextHost {drop(std::mem::take(&mut self.misc_platform_api_tasks));drop(std::mem::take(&mut self.file_entry_file_callbacks));drop(std::mem::take(&mut self.user_interaction_tasks));+ self.pending_font_face_loads.clear();self.pending_image_load_events.clear();self.pending_media_load_sequences.clear();self.pending_text_track_load_sequences.clear();@@ -512,6 +515,7 @@ impl JsContextHost {&mut self,owner: WindowExecutionContextOwner,) -> bool {+ self.retire_font_face_loads_for_execution_context_owner(owner);self.retire_event_callbacks_for_execution_context(owner);crate::observer_runtime::retire_execution_context_owner(self, owner);let retired = self.window_execution_contexts.remove(&owner);@@ -543,6 +547,7 @@ impl JsContextHost {&mut self,context_token: RuntimeObservableContextToken,) -> usize {+ self.retire_font_face_loads_for_context_token(context_token);crate::observer_runtime::retire_context_token(self, context_token);let indexed_db_retirement = self.retire_indexed_db_context(context_token);let retired_indexed_db_connections = indexed_db_retirement.retired_connections.len();@@ -592,6 +597,7 @@ impl JsContextHost {&mut self,context_token: RuntimeObservableContextToken,) -> usize {+ self.retire_font_face_loads_for_context_token(context_token);crate::observer_runtime::retire_context_token(self, context_token);let indexed_db_retirement = self.retire_indexed_db_context(context_token);indexed_db_retirement.finish(self.indexed_db_manager.as_ref());diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rsindex 88cda365d..be728e227 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs@@ -308,8 +308,16 @@ async fn assert_loaded_promise_lifetime(mode: &str) {// FontFace.load(), which installs a separate strong request root.vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0)).unwrap();- let query_promise = if mode.contains("query") {+ let query_promise = if mode.contains("query-then") {+ "document.fonts.load('16px Lifetime','A').then(faces => faces)"+ } else if mode.contains("query-await") {+ "(async () => await document.fonts.load('16px Lifetime','A'))()"+ } else if mode.contains("query") {"document.fonts.load('16px Lifetime','A')"+ } else if mode.contains("loaded-then") {+ "face.loaded.then(face => face)"+ } else if mode.contains("loaded-await") {+ "(async () => await face.loaded)()"} else {"face.loaded"};@@ -356,6 +364,38 @@ async fn assert_loaded_promise_lifetime(mode: &str) {.pending_subresource_request_count(),1);+ let pending_contexts = vm+ ._context_host+ .borrow()+ .pending_font_face_execution_contexts_for_test();+ assert_eq!(+ pending_contexts.len(),+ 1,+ "{mode}: native load must root its face"+ );+ let execution_context = pending_contexts[0];+ let retired = mode.contains("retire-");+ if retired {+ let mut host = vm._context_host.borrow_mut();+ if mode.ends_with("retire-realm") {+ host.retire_window_realm_resources(execution_context.realm_token());+ } else if mode.ends_with("retire-owner") {+ assert!(host.retire_window_execution_context(execution_context.owner()));+ } else if mode.ends_with("retire-context") {+ assert_eq!(+ host.retire_window_execution_contexts_for_context_token(+ execution_context.realm_token()+ ),+ 1+ );+ } else {+ panic!("unknown retirement mode {mode}");+ }+ assert!(+ host.pending_font_face_execution_contexts_for_test()+ .is_empty()+ );+ }// Every vm.eval HandleScope above has exited. Clear WeakRef's job-local// keepalive before forcing full GC so the witness cannot root the face.if mode != "css-removed-no-gc" {@@ -370,11 +410,14 @@ async fn assert_loaded_promise_lifetime(mode: &str) {}assert_eq!(vm.eval("faceWitness.deref()===undefined").unwrap(),- "false",- "a retained .loaded promise must keep the loading wrapper alive"+ if retired { "true" } else { "false" },+ "{mode}: active loads must keep settlement endpoints alive, retired Windows must release them");gates.remove("lifetime.woff2").unwrap().send(()).unwrap();server.await.unwrap();+ if retired {+ return;+ }assert!(tokio::time::timeout(Duration::from_secs(2),@@ -395,6 +438,13 @@ async fn assert_loaded_promise_lifetime(mode: &str) {.pending_subresource_request_count(),0);+ assert!(+ vm._context_host+ .borrow()+ .pending_font_face_execution_contexts_for_test()+ .is_empty(),+ "{mode}: terminal loads must release their native roots"+ );let results = vm.eval("JSON.stringify(promiseResults)").unwrap();assert_eq!(results,@@ -403,7 +453,7 @@ async fn assert_loaded_promise_lifetime(mode: &str) {} else {r#"[["Lifetime","loaded"]]"#},- "{mode}: retaining .loaded must preserve its settlement endpoint"+ "{mode}: retaining the promise chain must preserve its settlement endpoint");// A fulfilled promise necessarily retains its FontFace result. A rejected// promise must release the wrapper even while that promise remains live.@@ -442,6 +492,61 @@ async fn css_removed_rejected_query_promise_releases_wrapper_after_gc() {assert_loaded_promise_lifetime("css-removed-query-error").await;}+#[tokio::test]+async fn css_removed_query_then_promise_survives_gc() {+ assert_loaded_promise_lifetime("css-removed-query-then-gc").await;+}++#[tokio::test]+async fn css_removed_rejected_query_then_promise_releases_wrapper_after_gc() {+ assert_loaded_promise_lifetime("css-removed-query-then-error").await;+}++#[tokio::test]+async fn css_removed_query_await_promise_survives_gc() {+ assert_loaded_promise_lifetime("css-removed-query-await-gc").await;+}++#[tokio::test]+async fn css_removed_rejected_query_await_promise_releases_wrapper_after_gc() {+ assert_loaded_promise_lifetime("css-removed-query-await-error").await;+}++#[tokio::test]+async fn css_removed_loaded_then_promise_survives_gc() {+ assert_loaded_promise_lifetime("css-removed-loaded-then-gc").await;+}++#[tokio::test]+async fn css_removed_rejected_loaded_then_promise_releases_wrapper_after_gc() {+ assert_loaded_promise_lifetime("css-removed-loaded-then-error").await;+}++#[tokio::test]+async fn css_removed_loaded_await_promise_survives_gc() {+ assert_loaded_promise_lifetime("css-removed-loaded-await-gc").await;+}++#[tokio::test]+async fn css_removed_rejected_loaded_await_promise_releases_wrapper_after_gc() {+ assert_loaded_promise_lifetime("css-removed-loaded-await-error").await;+}++#[tokio::test]+async fn css_removed_query_chain_releases_wrapper_on_realm_retirement() {+ assert_loaded_promise_lifetime("css-removed-query-then-retire-realm").await;+}++#[tokio::test]+async fn css_removed_query_chain_releases_wrapper_on_owner_retirement() {+ assert_loaded_promise_lifetime("css-removed-query-await-retire-owner").await;+}++#[tokio::test]+async fn css_removed_query_chain_releases_wrapper_on_context_retirement() {+ assert_loaded_promise_lifetime("css-removed-query-then-retire-context").await;+}+#[tokio::test]async fn css_removed_loaded_promise_without_forced_gc() {assert_loaded_promise_lifetime("css-removed-no-gc").await;