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(renderer): trace response body handles on realm teardown
ldm0cd2cbc8541a4
diff --git a/moli-renderer-v8/src/native_bridge/identity.rs b/moli-renderer-v8/src/native_bridge/identity.rsindex 24adaa79a..d87528380 100644--- a/moli-renderer-v8/src/native_bridge/identity.rs+++ b/moli-renderer-v8/src/native_bridge/identity.rs@@ -590,6 +590,10 @@ pub(crate) fn clear_context_wrapper_cache_for_teardown(}crate::context_bootstrap::exposed_interfaces::retain_intrinsic_interfaces_in_realm(scope);crate::context_bootstrap::retain_indexed_db_state_in_retired_realm(scope);+ crate::network_host::retain_pending_network_body_state_in_retired_realm(+ scope,+ include_shared_default_world,+ );}#[derive(Debug, Default)]diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rsindex f2c85c135..70344c9ff 100644--- a/moli-renderer-v8/src/network_host.rs+++ b/moli-renderer-v8/src/network_host.rs@@ -63,7 +63,7 @@ pub(crate) use self::body_source::{PendingNetworkBodySourceState, close_pending_network_body_stream,enqueue_pending_network_body_chunk, error_pending_network_body_stream,error_pending_network_body_stream_with_reason, new_network_body_source_id,- pending_network_body_stream,+ pending_network_body_stream, retain_pending_network_body_state_in_retired_realm,};pub(in crate::network_host) use self::browser_response::http_status_text;pub(crate) use self::browser_response::{diff --git a/moli-renderer-v8/src/network_host/body_source.rs b/moli-renderer-v8/src/network_host/body_source.rsindex dd52105e8..f28aec8b4 100644--- a/moli-renderer-v8/src/network_host/body_source.rs+++ b/moli-renderer-v8/src/network_host/body_source.rs@@ -4,7 +4,7 @@ use crate::context_bootstrap::{};use crate::protocol_types::SubresourceResponseBody;use crate::types::NetworkBodySourceId;-use crate::util::{get_private_value, set_private_value};+use crate::util::{RealmObjectHandle, RealmValueHandle, get_private_value, set_private_value};use crate::web_api_interfaces;use crate::worker::get_worker_state;use std::collections::{HashMap, HashSet};@@ -244,7 +244,7 @@ enum PendingBodyMaterializationKind {}pub(crate) struct PendingBodyMaterialization {- resolver: v8::Global<v8::PromiseResolver>,+ resolver: RealmObjectHandle,kind: PendingBodyMaterializationKind,}@@ -261,10 +261,52 @@ pub(crate) struct PendingNetworkBodySourceState {pull_requested: bool,closed: bool,error: Option<String>,- error_reason: Option<v8::Global<v8::Value>>,+ error_reason: Option<RealmValueHandle>,materializations: Vec<PendingBodyMaterialization>,}+pub(crate) fn retain_pending_network_body_state_in_retired_realm(+ scope: &mut v8::PinScope<'_, '_>,+ include_shared_default_world: bool,+) {+ let context = scope.get_current_context();+ let Some(host) = context_host_mut(scope) else {+ return;+ };+ // Retained Responses keep their buffered bytes and error identity. Their+ // native body state must not in turn root the retired realm through a+ // pending body-method resolver or stored JavaScript rejection reason.+ for state in host.pending_network_body_sources.values_mut() {+ for materialization in &mut state.materializations {+ if include_shared_default_world+ || materialization+ .resolver+ .to_local(scope)+ .and_then(|resolver| resolver.get_creation_context(scope))+ == Some(context)+ {+ materialization.resolver.retain_in_realm(scope);+ }+ }+ let stream_context = state+ .stream+ .to_local(scope)+ .and_then(|stream| stream.get_creation_context(scope));+ if (include_shared_default_world || stream_context == Some(context))+ && let Some(reason) = &mut state.error_reason+ {+ // A shared native host can own body state from several realms.+ // Anchor the reason in the stream's realm, even during main teardown.+ if let Some(stream_context) = stream_context {+ let scope = &mut v8::ContextScope::new(scope, stream_context);+ reason.retain_in_realm(scope);+ } else {+ reason.retain_in_realm(scope);+ }+ }+ }+}+enum PendingBodyRejection {Reason(v8::Global<v8::Value>),Message(String),@@ -907,7 +949,7 @@ fn error_pending_network_body_stream_with_clone_ids<'s>(}state.closed = true;state.error = Some(error_text.to_owned());- state.error_reason = Some(v8::Global::new(scope, reason));+ state.error_reason = Some(RealmValueHandle::new(scope, reason));if let Some(stream) = state.stream.to_local(scope) {error_stream(scope, stream, reason);}@@ -926,7 +968,7 @@ fn error_pending_network_body_stream_with_clone_ids<'s>(}clone.closed = true;clone.error = Some(error_text.to_owned());- clone.error_reason = Some(v8::Global::new(scope, reason));+ clone.error_reason = Some(RealmValueHandle::new(scope, reason));if let Some(stream) = clone.stream.to_local(scope) {error_stream(scope, stream, reason);}@@ -1199,10 +1241,10 @@ fn clone_pending_network_body_source_in_maps(let snapshot = original.bytes.clone();outcome.close_now = original.closed;outcome.error_now = original.error.clone();- outcome.error_reason_now = original- .error_reason- .as_ref()- .map(|reason| v8::Global::new(scope, v8::Local::new(scope, reason)));+ outcome.error_reason_now = original.error_reason.as_ref().map(|reason| {+ let reason = reason.to_local(scope);+ v8::Global::new(scope, reason)+ });if let Some(clone) = sources.get_mut(&clone_id) {append_pending_body_state_bytes(scope, clone, &snapshot);}@@ -1513,10 +1555,8 @@ fn inspect_pending_body_source_for_materialization<'s>(.error_reason.as_ref().map(|reason| {- PendingBodyRejection::Reason(v8::Global::new(- scope,- v8::Local::new(scope, reason),- ))+ let reason = reason.to_local(scope);+ PendingBodyRejection::Reason(v8::Global::new(scope, reason))}).unwrap_or(PendingBodyRejection::Message(error_text)),);@@ -1526,7 +1566,7 @@ fn inspect_pending_body_source_for_materialization<'s>(sources.remove(&id);} else {state.materializations.push(PendingBodyMaterialization {- resolver: v8::Global::new(scope, resolver),+ resolver: RealmObjectHandle::new(scope, resolver.into()),kind,});}@@ -1770,7 +1810,11 @@ fn resolve_pending_body_materializations(let mut bytes: Vec<u8> = take_pending_network_body_source_bytes(scope, id).unwrap_or_default();let materialization_count = materializations.len();for (index, materialization) in materializations.into_iter().enumerate() {- let resolver = v8::Local::new(scope, &materialization.resolver);+ let Some(resolver) = materialization.resolver.to_local(scope) else {+ continue;+ };+ // The private handle is populated only from a PromiseResolver.+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };// Most body sources have exactly one pending materialization. Move the// completed buffer into that consumer and clone only when fan-out is// actually needed.@@ -1808,7 +1852,11 @@ fn reject_pending_body_materializations_with_reason<'s>(reason: v8::Local<'s, v8::Value>,) {for materialization in materializations {- let resolver = v8::Local::new(scope, &materialization.resolver);+ let Some(resolver) = materialization.resolver.to_local(scope) else {+ continue;+ };+ // The private handle is populated only from a PromiseResolver.+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };let _ = resolver.reject(scope, reason);}}diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs b/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rsindex 994db8ad5..c8f410e25 100644--- a/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs+++ b/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs@@ -1,5 +1,223 @@use super::*;+fn new_vm_with_pending_response_for_teardown_test()+-> (StandaloneScriptVmHarness, crate::types::NetworkBodySourceId) {+ let mut vm = new_storage_test_vm("https://body-teardown.test/");+ let body_source_id = crate::network_host::new_network_body_source_id();+ let document_url = vm.document_runtime.document_url().clone();+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {+ let response =+ crate::network_host::build_fetch_response_object_from_stream_for_request_mode(+ scope,+ &document_url,+ moli_fetch::RequestMode::Cors,+ moli_fetch::ResponseHead {+ final_url: document_url.join("data.json").unwrap(),+ status: 200,+ headers: vec![("content-type".to_owned(), b"application/json".to_vec())],+ request_cookie_report: None,+ cookie_set_reports: Vec::new(),+ redirected: false,+ redirect_chain: Vec::new(),+ from_cache: false,+ negotiated_http_version: None,+ },+ body_source_id,+ );+ let global = scope.get_current_context().global(scope);+ let _ = global.set(+ scope,+ crate::util::v8str(scope, "response").into(),+ response.into(),+ );+ Ok(())+ })+ .expect("pending Response should be installed");+ (vm, body_source_id)+}++fn error_response_for_teardown_test(+ vm: &mut StandaloneScriptVmHarness,+ body_source_id: crate::types::NetworkBodySourceId,+) {+ vm.eval("globalThis.bodyFailure = new Error('body failed')")+ .unwrap();+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {+ let global = scope.get_current_context().global(scope);+ let reason = global+ .get(scope, crate::util::v8str(scope, "bodyFailure").into())+ .unwrap();+ crate::network_host::error_pending_network_body_stream_with_reason(+ scope,+ body_source_id,+ "body failed".to_owned(),+ reason,+ );+ Ok(())+ })+ .expect("pending Response should retain its rejection reason");+}++#[test]+fn pending_response_body_releases_native_host_on_context_teardown() {+ let (mut vm, _) = new_vm_with_pending_response_for_teardown_test();+ vm.eval("globalThis.bodyPromise = response.json(); 1")+ .expect("body materialization should wait for network completion");+ let weak_host = vm.context_host_weak_for_test();+ let isolate = vm.renderer_document_isolate.clone();+ drop(vm);+ for _ in 0..2 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(+ weak_host.upgrade().is_none(),+ "a pending body resolver must not root its retired native Document"+ );+}++#[test]+fn errored_response_body_releases_native_host_on_context_teardown() {+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();+ error_response_for_teardown_test(&mut vm, body_source_id);+ let weak_host = vm.context_host_weak_for_test();+ let isolate = vm.renderer_document_isolate.clone();+ drop(vm);+ for _ in 0..2 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(+ weak_host.upgrade().is_none(),+ "a stored body error must not root its retired native Document"+ );+}++#[test]+fn retained_response_body_keeps_bytes_until_the_last_v8_reference() {+ for pending in [false, true] {+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {+ crate::network_host::enqueue_pending_network_body_chunk(+ scope,+ body_source_id,+ br#"{"ok":true}"#.to_vec(),+ );+ if !pending {+ crate::network_host::close_pending_network_body_stream(scope, body_source_id);+ }+ Ok(())+ })+ .unwrap();+ vm.eval(if pending {+ "globalThis.bodyPromise = response.text(); globalThis.readBody = () => bodyPromise"+ } else {+ "globalThis.readBody = () => response.text()"+ })+ .unwrap();+ let isolate = vm.renderer_document_isolate.clone();+ let callback = isolate.with_renderer_document_isolate_mut(|isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let context = v8::Local::new(scope, &vm.page_default_context);+ let scope = &mut v8::ContextScope::new(scope, context);+ let value = context+ .global(scope)+ .get(scope, crate::util::v8str(scope, "readBody").into())+ .unwrap();+ let function = v8::Local::<v8::Function>::try_from(value).unwrap();+ v8::Global::new(scope, function)+ });+ let weak_host = vm.context_host_weak_for_test();+ drop(vm);+ for _ in 0..2 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(weak_host.upgrade().is_some());+ let value = isolate.with_renderer_document_isolate_mut(|isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let caller_context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, caller_context);+ let function = v8::Local::new(scope, &callback);+ let context = function.get_creation_context(scope).unwrap();+ let scope = &mut v8::ContextScope::new(scope, context);+ if pending {+ crate::network_host::close_pending_network_body_stream(scope, body_source_id);+ }+ let receiver = v8::undefined(scope).into();+ let value = crate::script_execution::call_function(scope, function, receiver, &[])+ .expect("retained Response body should remain readable");+ let promise = v8::Local::<v8::Promise>::try_from(value).unwrap();+ assert_eq!(promise.state(), v8::PromiseState::Fulfilled);+ promise.result(scope).to_rust_string_lossy(scope)+ });+ assert_eq!(value, r#"{"ok":true}"#);+ isolate.with_renderer_document_isolate_mut(|isolate| {+ drop(callback);+ isolate.low_memory_notification();+ });+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ assert!(+ weak_host.upgrade().is_none(),+ "releasing the body reader must release its retired native Document"+ );+ }+}++#[test]+fn retained_response_body_keeps_error_reason_until_the_last_v8_reference() {+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();+ error_response_for_teardown_test(&mut vm, body_source_id);+ vm.eval("globalThis.readBody = () => response.text()")+ .unwrap();+ let isolate = vm.renderer_document_isolate.clone();+ let callback = isolate.with_renderer_document_isolate_mut(|isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let context = v8::Local::new(scope, &vm.page_default_context);+ let scope = &mut v8::ContextScope::new(scope, context);+ let value = context+ .global(scope)+ .get(scope, crate::util::v8str(scope, "readBody").into())+ .unwrap();+ let function = v8::Local::<v8::Function>::try_from(value).unwrap();+ v8::Global::new(scope, function)+ });+ let weak_host = vm.context_host_weak_for_test();+ drop(vm);+ for _ in 0..2 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(weak_host.upgrade().is_some());+ isolate.with_renderer_document_isolate_mut(|isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let caller_context = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, caller_context);+ let function = v8::Local::new(scope, &callback);+ let context = function.get_creation_context(scope).unwrap();+ let scope = &mut v8::ContextScope::new(scope, context);+ let receiver = v8::undefined(scope).into();+ let value = crate::script_execution::call_function(scope, function, receiver, &[])+ .expect("retained Response should preserve its body error");+ let promise = v8::Local::<v8::Promise>::try_from(value).unwrap();+ assert_eq!(promise.state(), v8::PromiseState::Rejected);+ let reason = context+ .global(scope)+ .get(scope, crate::util::v8str(scope, "bodyFailure").into())+ .unwrap();+ assert!(promise.result(scope).strict_equals(reason));+ });+ isolate.with_renderer_document_isolate_mut(|isolate| {+ drop(callback);+ isolate.low_memory_notification();+ });+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ assert!(+ weak_host.upgrade().is_none(),+ "releasing the body reader must release its retired native Document"+ );+}+fn new_vm_with_evaluated_module_for_teardown_test() -> StandaloneScriptVmHarness {let mut vm = new_storage_test_vm("https://module-teardown.test/");let url = vm.document_runtime.document_url().clone();