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): retain detached document state until realm collection
ldm09fd3e07f4797
diff --git a/moli-file-api/src/blob_store.rs b/moli-file-api/src/blob_store.rsindex e9163cc66..4979c1ee6 100644--- a/moli-file-api/src/blob_store.rs+++ b/moli-file-api/src/blob_store.rs@@ -246,6 +246,32 @@ whereSome((String::from_utf8_lossy(&bytes).into_owned(), mime_type))}+ /// Revoke a departing context's URLs while preserving bytes retained by+ /// wrappers, readers, or URLs created by another context.+ pub fn retire_owner_resources(&self, owner_id: OwnerId) {+ let retired = {+ let mut urls = self.object_urls.lock();+ let mut retired = Vec::new();+ urls.retain(|_, state| {+ if state.owner_id == Some(owner_id) {+ retired.push(state.blob_id);+ false+ } else {+ true+ }+ });+ retired+ };+ for blob_id in retired {+ self.release_blob_object_url_ref(blob_id);+ }+ for blob in self.blobs.lock().by_id.values_mut() {+ if blob.owner_id == Some(owner_id) {+ blob.owner_id = None;+ }+ }+ }+/// Remove Blob/object URL entries owned by a context.pub fn cleanup_owner_resources(&self, owner_id: OwnerId) {let removed_blob_ids = {@@ -504,6 +530,30 @@ mod tests {assert!(store.blob_bytes_by_uuid_in_partition(&uuid, &10).is_none());}+ #[test]+ fn retiring_owner_preserves_wrappers_readers_and_foreign_urls() {+ let store = BlobStore::<u64, u64>::default();+ let blob = store.create_blob(Some(1), Some(10), b"retained".to_vec(), "text/plain".into());+ let own_url = store+ .create_object_url(Some(1), blob, "https://example.test")+ .unwrap();+ let foreign_url = store+ .create_object_url(Some(2), blob, "https://example.test")+ .unwrap();+ store.retain_blob_reader_ref(blob);+ store.retire_owner_resources(1);+ assert!(store.object_url_bytes_and_type(&own_url).is_none());+ assert_eq!(store.blob_bytes(blob).unwrap(), b"retained");+ store.release_blob_wrapper_ref(blob);+ store.release_blob_reader_ref(blob);+ assert_eq!(+ store.object_url_bytes_and_type(&foreign_url).unwrap().0,+ b"retained"+ );+ assert!(store.revoke_object_url(&foreign_url));+ assert!(store.blob_bytes(blob).is_none());+ }+#[test]fn cleanup_owner_removes_owned_blobs_and_urls() {let store = BlobStore::<u64, u64>::default();diff --git a/moli-renderer-v8/src/blob.rs b/moli-renderer-v8/src/blob.rsindex a4c0c0d49..98c226c82 100644--- a/moli-renderer-v8/src/blob.rs+++ b/moli-renderer-v8/src/blob.rs@@ -487,7 +487,7 @@ fn blob_mime_type(blob_id: BlobId) -> Option<String> {}pub(crate) fn cleanup_owner_resources(owner_id: ResourceOwnerId) {- blob_store().cleanup_owner_resources(owner_id);+ blob_store().retire_owner_resources(owner_id);}fn release_blob_wrapper_ref(blob_id: BlobId) {diff --git a/moli-renderer-v8/src/context_bootstrap/constructors/dom_exception.rs b/moli-renderer-v8/src/context_bootstrap/constructors/dom_exception.rsindex dda15594d..fe481fec7 100644--- a/moli-renderer-v8/src/context_bootstrap/constructors/dom_exception.rs+++ b/moli-renderer-v8/src/context_bootstrap/constructors/dom_exception.rs@@ -530,6 +530,16 @@ pub(crate) fn new_dom_exception_value<'s>(scope,"DOMException",)+ .or_else(|| {+ // A native exception must materialize its own realm's intrinsic.+ // Reading the public Window property can run author code or enter+ // an access check again after navigation detaches its global.+ crate::context_bootstrap::exposed_interfaces::ensure_intrinsic_interface_prototype(+ scope,+ "DOMException",+ )+ .ok()+ }){let exception = v8::Object::new(scope);initialize_dom_exception(scope, exception, message, name);diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rsindex 888e68510..fdeda3af9 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs@@ -30,3 +30,5 @@ pub(super) use metadata::constructor_spec_is_eager;#[cfg(test)]pub(crate) use metadata::dedicated_worker_lazy_interface_names_for_test;pub(in crate::context_bootstrap) use template_registry::ExposedInterfaceTemplateRegistry;++pub(crate) use realm_registry::retain_intrinsic_interfaces_in_realm;diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/realm_registry.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/realm_registry.rsindex cdcba7a63..c735cf8d0 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/realm_registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/realm_registry.rs@@ -20,9 +20,9 @@ pub(super) struct IntrinsicInterfaceRegistry {}pub(super) struct RealmInterfaceObjects {- constructor: v8::Global<v8::Object>,- prototype: v8::Global<v8::Object>,- public_interface: v8::Global<v8::Object>,+ constructor: crate::util::RealmObjectHandle,+ prototype: crate::util::RealmObjectHandle,+ public_interface: crate::util::RealmObjectHandle,}impl IntrinsicInterfaceRegistry {@@ -156,9 +156,9 @@ impl IntrinsicInterfaceRegistry {RealmInterfaceEntry::Uninitialized | RealmInterfaceEntry::Materializing => {}}*slot = RealmInterfaceEntry::Ready(RealmInterfaceObjects {- constructor: v8::Global::new(scope, constructor),- prototype: v8::Global::new(scope, prototype),- public_interface: v8::Global::new(scope, public_interface),+ constructor: crate::util::RealmObjectHandle::new(scope, constructor),+ prototype: crate::util::RealmObjectHandle::new(scope, prototype),+ public_interface: crate::util::RealmObjectHandle::new(scope, public_interface),});Ok(())}@@ -172,7 +172,7 @@ impl IntrinsicInterfaceRegistry {let RealmInterfaceEntry::Ready(objects) = entries.get(id.index())? else {return None;};- Some(v8::Local::new(scope, &objects.constructor))+ objects.constructor.to_local(scope)}pub(super) fn prototype<'s>(@@ -184,7 +184,7 @@ impl IntrinsicInterfaceRegistry {let RealmInterfaceEntry::Ready(objects) = entries.get(id.index())? else {return None;};- Some(v8::Local::new(scope, &objects.prototype))+ objects.prototype.to_local(scope)}pub(super) fn public_interface<'s>(@@ -196,10 +196,25 @@ impl IntrinsicInterfaceRegistry {let RealmInterfaceEntry::Ready(objects) = entries.get(id.index())? else {return None;};- Some(v8::Local::new(scope, &objects.public_interface))+ objects.public_interface.to_local(scope)}}+pub(crate) fn retain_intrinsic_interfaces_in_realm(scope: &mut v8::PinScope<'_, '_>) {+ let context = scope.get_current_context();+ let Some(registry) = context.get_slot::<IntrinsicInterfaceRegistry>() else {+ return;+ };+ for entry in registry.entries.borrow_mut().iter_mut() {+ if let RealmInterfaceEntry::Ready(objects) = entry {+ objects.constructor.retain_in_realm(scope);+ objects.prototype.retain_in_realm(scope);+ objects.public_interface.retain_in_realm(scope);+ }+ }+ crate::util::retain_context_v8_handle_state_for_safe_release(context, registry);+}+#[cfg(test)]mod tests {use std::pin::pin;diff --git a/moli-renderer-v8/src/document_runtime/lifecycle.rs b/moli-renderer-v8/src/document_runtime/lifecycle.rsindex beaf3ba22..c8be855da 100644--- a/moli-renderer-v8/src/document_runtime/lifecycle.rs+++ b/moli-renderer-v8/src/document_runtime/lifecycle.rs@@ -37,6 +37,19 @@ fn image_is_small_for_priority_boost(element: &crate::dom::native::Element) -> b// the host document state accessors, current-script/parser visibility// bookkeeping, and pending resource-load delivery that feed DCL/load decisions.impl DocumentRuntime {+ pub(crate) fn retire_v8_execution_state_for_context_teardown(&mut self) {+ self.timeouts = HostTimeoutScheduler::default();+ self.events = HostEventTargetRegistry::default();+ self.script_lifecycle.clear_for_document_replacement();+ self.root_document_parser = None;+ self.document_write_script_preload_scanner = None;+ self.document_write_script_preloads.clear();+ self.pending_parser_blocking_work = None;+ self.pending_parser_post_step_runtime_work = Default::default();+ self.reset_main_parser_continuation_for_document_replacement();+ self.main_document_script_preloads.clear();+ }+pub(crate) fn bind_main_document_script_preload_store(&mut self,store: crate::runtime::DocumentScriptPreloadStore,diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rsindex b5993d169..859d20402 100644--- a/moli-renderer-v8/src/native_bridge/abort.rs+++ b/moli-renderer-v8/src/native_bridge/abort.rs@@ -23,6 +23,9 @@ pub(crate) use statics::{};const ABORT_SIGNAL_ID_SLOT: &str = "__lmAbortSignalId";+const ABORT_SIGNAL_STATE_SLOT: &str = "__moliAbortSignalState";+const ABORT_SIGNAL_ABORTED_SLOT: &str = "__moliAbortSignalAborted";+const ABORT_SIGNAL_REASON_SLOT: &str = "__moliAbortSignalReason";const ABORT_CONTROLLER_ID_SLOT: &str = "__lmAbortControllerId";const ABORT_CONTROLLER_SIGNAL_SLOT: &str = "__lmAbortControllerSignal";@@ -35,6 +38,9 @@ pub(crate) fn bind_signal_wrapper<'s>(return false;};set_private_value(scope, wrapper, ABORT_SIGNAL_ID_SLOT, id);+ if let Some(state) = get_private_value(scope, signal, ABORT_SIGNAL_STATE_SLOT) {+ set_private_value(scope, wrapper, ABORT_SIGNAL_STATE_SLOT, state);+ }true}@@ -44,13 +50,14 @@ pub(super) struct AbortStore {next_controller_id: u32,signals: HashMap<u32, AbortSignalState>,controllers: HashMap<u32, u32>,+ detached: bool,}#[derive(Default)]struct AbortSignalState {- signal: Option<v8::Global<v8::Object>>,+ signal: Option<crate::util::RealmObjectHandle>,aborted: bool,- reason: Option<v8::Global<v8::Value>>,+ detached: bool,abort_algorithms: Vec<v8::Global<v8::Function>>,linked_target_listeners: Vec<AbortLinkedTargetListener>,// None for a source; Some (including empty) for a dependent signal's ordered roots.@@ -68,9 +75,82 @@ struct AbortLinkedTargetListener {struct AbortSignalDispatch {algorithms: Vec<v8::Global<v8::Function>>,linked_target_listeners: Vec<AbortLinkedTargetListener>,+ dispatch_event: bool,}impl AbortStore {+ pub(super) fn clear_for_context_teardown(&mut self) {+ self.detached = true;+ for state in self.signals.values_mut() {+ state.detached = true;+ state.abort_algorithms.clear();+ state.linked_target_listeners.clear();+ }+ }++ pub(crate) fn retire_context<'s>(+ &mut self,+ scope: &mut v8::PinScope<'s, '_>,+ context: v8::Local<'s, v8::Context>,+ ) {+ for state in self.signals.values_mut() {+ let Some(handle) = state.signal.as_mut() else {+ continue;+ };+ let Some(signal) = handle.to_local(scope) else {+ continue;+ };+ if signal.get_creation_context(scope) != Some(context) {+ continue;+ }+ handle.retain_in_realm(scope);+ state.detached = true;+ state.abort_algorithms.clear();+ state.linked_target_listeners.clear();+ }+ }++ fn signal_passive_state<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+ ) -> Option<v8::Local<'s, v8::Object>> {+ get_private_value(scope, signal, ABORT_SIGNAL_STATE_SLOT)+ .and_then(|state| v8::Local::<v8::Object>::try_from(state).ok())+ }++ fn signal_aborted_from_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+ ) -> bool {+ Self::signal_passive_state(scope, signal)+ .and_then(|state| get_private_value(scope, state, ABORT_SIGNAL_ABORTED_SLOT))+ .is_some_and(|value| value.is_true())+ }++ fn signal_reason_from_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+ ) -> Option<v8::Local<'s, v8::Value>> {+ let state = Self::signal_passive_state(scope, signal)?;+ get_private_value(scope, state, ABORT_SIGNAL_REASON_SLOT)+ }++ fn publish_signal_abort<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+ reason: v8::Local<'s, v8::Value>,+ ) {+ if let Some(state) = Self::signal_passive_state(scope, signal) {+ set_private_value(+ scope,+ state,+ ABORT_SIGNAL_ABORTED_SLOT,+ v8::Boolean::new(scope, true).into(),+ );+ set_private_value(scope, state, ABORT_SIGNAL_REASON_SLOT, reason);+ }+ }+fn alloc_signal_id(&mut self) -> u32 {self.next_signal_id = self.next_signal_id@@ -102,9 +182,7 @@ impl AbortStore {scope: &mut v8::PinScope<'s, '_>,object: v8::Local<'s, v8::Object>,) -> bool {- Self::signal_id_from_object(scope, object)- .and_then(|id| self.signal_state(id))- .is_some()+ Self::signal_id_from_object(scope, object).is_some()}fn controller_id_from_object<'s>(@@ -127,13 +205,25 @@ impl AbortStore {let signal_id = self.alloc_signal_id();let mut state = AbortSignalState {aborted,+ detached: self.detached,..AbortSignalState::default()};- state.signal = Some(v8::Global::new(scope, signal));- if let Some(reason) = reason {- state.reason = Some(v8::Global::new(scope, reason));- }+ state.signal = Some(crate::util::RealmObjectHandle::new(scope, signal));self.signals.insert(signal_id, state);+ let passive_state = v8::Object::new(scope);+ set_private_value(+ scope,+ passive_state,+ ABORT_SIGNAL_ABORTED_SLOT,+ v8::Boolean::new(scope, aborted).into(),+ );+ set_private_value(+ scope,+ passive_state,+ ABORT_SIGNAL_REASON_SLOT,+ reason.unwrap_or_else(|| v8::undefined(scope).into()),+ );+ set_private_value(scope, signal, ABORT_SIGNAL_STATE_SLOT, passive_state.into());set_private_value(scope,signal,@@ -182,7 +272,7 @@ impl AbortStore {) -> Option<v8::Local<'s, v8::Object>> {self.signal_state(id).and_then(|state| state.signal.as_ref())- .map(|signal| v8::Local::new(scope, signal))+ .and_then(|signal| signal.to_local(scope))}pub(super) fn signal_aborted<'s>(@@ -190,9 +280,7 @@ impl AbortStore {scope: &mut v8::PinScope<'s, '_>,signal: v8::Local<'s, v8::Object>,) -> bool {- Self::signal_id_from_object(scope, signal)- .and_then(|id| self.signal_state(id))- .is_some_and(|state| state.aborted)+ Self::signal_aborted_from_object(scope, signal)}pub(super) fn signal_reason<'s>(@@ -200,10 +288,7 @@ impl AbortStore {scope: &mut v8::PinScope<'s, '_>,signal: v8::Local<'s, v8::Object>,) -> Option<v8::Local<'s, v8::Value>> {- Self::signal_id_from_object(scope, signal)- .and_then(|id| self.signal_state(id))- .and_then(|state| state.reason.as_ref())- .map(|reason| v8::Local::new(scope, reason))+ Self::signal_reason_from_object(scope, signal)}pub(crate) fn register_abort_algorithm<'s>(@@ -218,6 +303,9 @@ impl AbortStore {let Some(state) = self.signal_state_mut(signal_id) else {return false;};+ if state.detached {+ return false;+ }state.abort_algorithms.push(v8::Global::new(scope, algorithm));@@ -283,12 +371,15 @@ impl AbortStore {reason: v8::Local<'s, v8::Value>,) -> Option<Vec<(u32, v8::Local<'s, v8::Object>)>> {let signal_id = Self::signal_id_from_object(scope, signal)?;+ if Self::signal_aborted_from_object(scope, signal) {+ return None;+ }+ Self::publish_signal_abort(scope, signal, reason);let state = self.signal_state_mut(signal_id)?;if state.aborted {return None;}state.aborted = true;- state.reason = Some(v8::Global::new(scope, reason));let dependent_signals = state.dependent_signals.clone();// Publish every reason before any author callback can reenter abort.let mut signals = vec![(signal_id, signal)];@@ -300,9 +391,13 @@ impl AbortStore {continue;}state.aborted = true;- state.reason = Some(v8::Global::new(scope, reason));- if let Some(signal) = &state.signal {- signals.push((dependent_signal_id, v8::Local::new(scope, signal)));+ if let Some(signal) = state+ .signal+ .as_ref()+ .and_then(|signal| signal.to_local(scope))+ {+ Self::publish_signal_abort(scope, signal, reason);+ signals.push((dependent_signal_id, signal));}}Some(signals)@@ -313,6 +408,7 @@ impl AbortStore {Some(AbortSignalDispatch {algorithms: std::mem::take(&mut state.abort_algorithms),linked_target_listeners: std::mem::take(&mut state.linked_target_listeners),+ dispatch_event: !state.detached,})}@@ -384,7 +480,9 @@ pub(crate) fn abort_signal<'s>();}// Snapshot listeners after earlier signals and abort algorithms.- abort_signal_events::dispatch_abort(scope, signal);+ if dispatch.dispatch_event {+ abort_signal_events::dispatch_abort(scope, signal);+ }}}diff --git a/moli-renderer-v8/src/native_bridge/abort/controller.rs b/moli-renderer-v8/src/native_bridge/abort/controller.rsindex ff0e78d88..2bd7c1e27 100644--- a/moli-renderer-v8/src/native_bridge/abort/controller.rs+++ b/moli-renderer-v8/src/native_bridge/abort/controller.rs@@ -47,12 +47,12 @@ pub(crate) fn abort_controller_abort_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ let Some(_) = context_host_ptr_from_global_bridge(scope) else {rv.set_undefined();return;};let controller = args.this();- let Some(controller_id) = AbortStore::controller_id_from_object(scope, controller) else {+ let Some(_) = AbortStore::controller_id_from_object(scope, controller) else {rv.set_undefined();return;};@@ -67,26 +67,6 @@ pub(crate) fn abort_controller_abort_callback<'s>(} else {abort_error_value(scope)};- let host = unsafe { &mut *host_ptr };- let Some(signal_id) = host- .native_bridge_mut()- .abort- .controllers- .get(&controller_id)- .copied()- else {- rv.set_undefined();- return;- };- if host- .native_bridge_mut()- .abort- .signal_state(signal_id)- .is_some_and(|state| state.aborted)- {- rv.set_undefined();- return;- }crate::native_bridge::abort::abort_signal(scope, signal, reason);rv.set_undefined();}diff --git a/moli-renderer-v8/src/native_bridge/abort/signal.rs b/moli-renderer-v8/src/native_bridge/abort/signal.rsindex ba43412ba..dd7fdf6b0 100644--- a/moli-renderer-v8/src/native_bridge/abort/signal.rs+++ b/moli-renderer-v8/src/native_bridge/abort/signal.rs@@ -1,31 +1,11 @@use super::AbortStore;-use crate::util::context_host_ptr_from_global_bridge;pub(crate) fn abort_signal_aborted_getter_callback<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {- rv.set_bool(false);- return;- };- let signal = args.this();- if AbortStore::signal_id_from_object(scope, signal).is_none() {- rv.set_bool(false);- return;- }- // SAFETY: as_ptr() — this getter may be called during event dispatch- // (re-entrant from another callback holding borrow_mut). See util.rs.- let aborted = AbortStore::signal_id_from_object(scope, signal)- .and_then(|id| {- unsafe { &mut *host_ptr }- .native_bridge_mut()- .abort- .signal_state(id)- })- .is_some_and(|state| state.aborted);- rv.set_bool(aborted);+ rv.set_bool(AbortStore::signal_aborted_from_object(scope, args.this()));}pub(crate) fn abort_signal_reason_getter_callback<'s>(@@ -33,29 +13,10 @@ pub(crate) fn abort_signal_reason_getter_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {- rv.set_undefined();- return;- };- let signal = args.this();- if AbortStore::signal_id_from_object(scope, signal).is_none() {- rv.set_undefined();- return;+ match AbortStore::signal_reason_from_object(scope, args.this()) {+ Some(reason) => rv.set(reason),+ None => rv.set_undefined(),}- let Some(reason) = AbortStore::signal_id_from_object(scope, signal)- .and_then(|id| {- unsafe { &mut *host_ptr }- .native_bridge_mut()- .abort- .signal_state(id)- })- .and_then(|state| state.reason.as_ref())- .map(|reason| v8::Local::new(scope, reason))- else {- rv.set_undefined();- return;- };- rv.set(reason);}pub(crate) fn abort_signal_throw_if_aborted_callback<'s>(@@ -63,30 +24,12 @@ pub(crate) fn abort_signal_throw_if_aborted_callback<'s>(args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'_, v8::Value>,) {- let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {- rv.set_undefined();- return;- };let signal = args.this();- if AbortStore::signal_id_from_object(scope, signal).is_none() {+ if !AbortStore::signal_aborted_from_object(scope, signal) {rv.set_undefined();return;}- let Some(reason) = AbortStore::signal_id_from_object(scope, signal)- .and_then(|id| {- unsafe { &mut *host_ptr }- .native_bridge_mut()- .abort- .signal_state(id)- })- .filter(|state| state.aborted)- .and_then(|state| state.reason.as_ref())- .map(|reason| v8::Local::new(scope, reason))- else {- rv.set_undefined();- return;- };- // DOM requires throwing the stored abort reason itself. In particular, a- // string reason remains a string rather than being wrapped in `Error`.+ let reason = AbortStore::signal_reason_from_object(scope, signal)+ .unwrap_or_else(|| v8::undefined(scope).into());scope.throw_exception(reason);}diff --git a/moli-renderer-v8/src/native_bridge/abort/statics.rs b/moli-renderer-v8/src/native_bridge/abort/statics.rsindex 3b8512b1b..5d196cbc7 100644--- a/moli-renderer-v8/src/native_bridge/abort/statics.rs+++ b/moli-renderer-v8/src/native_bridge/abort/statics.rs@@ -91,20 +91,11 @@ pub(crate) fn abort_signal_any_callback<'s>(let signals = parsed.signals;for source_signal in &signals {- let Some(source_signal_id) = AbortStore::signal_id_from_object(scope, *source_signal)- else {+ if !AbortStore::signal_aborted_from_object(scope, *source_signal) {continue;- };- let Some(reason) = host- .native_bridge_mut()- .abort- .signal_state(source_signal_id)- .filter(|state| state.aborted)- .and_then(|state| state.reason.as_ref())- .map(|reason| v8::Local::new(scope, reason))- else {- continue;- };+ }+ let reason = AbortStore::signal_reason_from_object(scope, *source_signal)+ .unwrap_or_else(|| v8::undefined(scope).into());crate::native_bridge::abort::abort_signal(scope, signal, reason);rv.set(signal.into());return;diff --git a/moli-renderer-v8/src/native_bridge/context_host/bridge_install.rs b/moli-renderer-v8/src/native_bridge/context_host/bridge_install.rsindex 2d8d83124..d010aa887 100644--- a/moli-renderer-v8/src/native_bridge/context_host/bridge_install.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/bridge_install.rs@@ -81,7 +81,11 @@ impl JsContextHost {// The actual JsContextHost pointer for runtime_ptr_from_object compatibility.let bridge = unsafe { &mut (*host_ptr).bridge };bridge.install_global(scope, global, host_ptr, bridge_ref.as_external_ptr())?;- crate::util::install_context_host_pointer_slot(scope.get_current_context(), host_ptr);+ crate::util::install_context_host_pointer_slot(+ scope.get_current_context(),+ host_ptr,+ unsafe { &*host_ptr }.context_host_lifecycle_handle(),+ );Ok(bridge_ref)}}diff --git a/moli-renderer-v8/src/native_bridge/context_host/broadcast_channels.rs b/moli-renderer-v8/src/native_bridge/context_host/broadcast_channels.rsindex 5bdf453a2..f4c83db26 100644--- a/moli-renderer-v8/src/native_bridge/context_host/broadcast_channels.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/broadcast_channels.rs@@ -59,6 +59,26 @@ impl JsContextHost {closed_count}+ pub(crate) fn close_broadcast_channels_for_context_token(+ &mut self,+ context_token: RuntimeObservableContextToken,+ ) -> usize {+ let channel_ids = self+ .broadcast_channel_wrappers+ .iter()+ .filter_map(|(channel_id, entry)| {+ (entry.identity.realm_token() == context_token).then_some(*channel_id)+ })+ .collect::<Vec<_>>();+ let closed_count = channel_ids.len();+ for channel_id in channel_ids {+ self.broadcast_channel_wrappers.remove(&channel_id);+ self.broadcast_channel_registry+ .close_broadcast_channel(channel_id);+ }+ closed_count+ }+pub(crate) fn register_broadcast_channel_wrapper(&mut self,scope: &mut v8::PinScope<'_, '_>,diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/window.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/window.rsindex b7b965a35..9028c98c5 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/window.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/window.rs@@ -962,7 +962,11 @@ impl JsContextHost {else {return false;};- crate::util::install_context_host_pointer_slot(context, self as *mut Self);+ crate::util::install_context_host_pointer_slot(+ context,+ self as *mut Self,+ self.context_host_lifecycle_handle(),+ );let previous = context.set_slot(Rc::new(ChildWindowProxyFacadeContextHandle(handle)));debug_assert!(previous.is_none());// Keep V8's unique default security token. A facade is not a realdiff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rsindex 4107af34a..42923e4a1 100644--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs@@ -212,6 +212,10 @@ impl JsContextHost {root_document_lifecycle: None,output_journal: None,page_context_resources_closed: false,+ context_host_lifecycle: Rc::new(Cell::new(crate::util::ContextHostLifecycle::Active)),+ deferred_context_host_release_queue: Default::default(),+ retained_document_runtime: None,+ published_document_host: false,page_default_context: None,v8_finalizers: crate::v8_finalizer::V8FinalizerRegistry::default(),bridge: NativeDomBridge::new(bindings),diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rsindex fb4105ec1..2f404a8d8 100644--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs@@ -820,6 +820,8 @@ pub(crate) struct JsContextHost {root_document_lifecycle: Option<RendererDocumentLifecycleJournalHandle>,output_journal: Option<crate::runtime::RendererTurnOutputJournal>,page_context_resources_closed: bool,+ context_host_lifecycle: Rc<Cell<crate::util::ContextHostLifecycle>>,+ deferred_context_host_release_queue: crate::script_vm::RendererDeferredContextHostReleaseQueue,page_default_context: Option<v8::Weak<v8::Context>>,pub(crate) v8_finalizers: crate::v8_finalizer::V8FinalizerRegistry,pub(super) bridge: NativeDomBridge,@@ -1099,6 +1101,8 @@ pub(crate) struct JsContextHost {stylo_computed_style_property_reads: Cell<u64>,#[cfg(test)]style_observation_environment_resolutions: Cell<u64>,+ retained_document_runtime: Option<Box<DocumentRuntime>>,+ published_document_host: bool,}struct PendingTextControlChangeCommit {@@ -1253,16 +1257,66 @@ impl JsContextHost {self.app_manifest_link_change_epoch}+ pub(crate) fn document_host_is_published(&self) -> bool {+ self.published_document_host+ }++ pub(crate) fn publish_document_host(&mut self) {+ self.published_document_host = true;+ }++ pub(crate) fn mark_page_context_detached(&self) {+ if self.context_host_lifecycle.get() == crate::util::ContextHostLifecycle::Active {+ self.context_host_lifecycle+ .set(crate::util::ContextHostLifecycle::Detached);+ }+ }++ pub(crate) fn context_host_lifecycle_handle(+ &self,+ ) -> Rc<Cell<crate::util::ContextHostLifecycle>> {+ self.context_host_lifecycle.clone()+ }++ pub(crate) fn deferred_context_host_release_queue(+ &self,+ ) -> crate::script_vm::RendererDeferredContextHostReleaseQueue {+ self.deferred_context_host_release_queue.clone()+ }++ pub(crate) fn adopt_retained_document_runtime(+ &mut self,+ document_runtime: Box<DocumentRuntime>,+ ) {+ assert!(+ self.retained_document_runtime.is_none(),+ "JsContextHost must adopt its DocumentRuntime at most once"+ );+ assert!(+ std::ptr::eq(self.runtime.cast_const(), document_runtime.as_ref()),+ "retained DocumentRuntime transfer must preserve the host raw pointer"+ );+ self.retained_document_runtime = Some(document_runtime);+ }+ pub(crate) fn bind_deferred_context_host_release_queue(+ &mut self,+ queue: crate::script_vm::RendererDeferredContextHostReleaseQueue,+ ) {+ self.deferred_context_host_release_queue = queue;+ }+pub(crate) fn close_page_context_resources_for_teardown(&mut self) {+ self.mark_page_context_detached();if self.page_context_resources_closed {return;}self.page_context_resources_closed = true;self.bridge.web_mcp.clear();+ self.retire_all_window_execution_context_resources_for_teardown();self.pending_history_traversal_admissions.clear();self.retire_all_document_resource_loaders();self.page_default_context = None;- self.v8_finalizers.clear_for_context_teardown();+self.clear_pending_top_level_navigation();self.unregister_all_service_worker_child_clients();self.unregister_all_service_worker_popup_clients();@@ -1272,11 +1326,20 @@ impl JsContextHost {self.close_owned_broadcast_channels();self.close_owned_message_ports();self.shutdown_workers();+ self.output_journal = None;+ self.root_document_lifecycle = None;+ self.child_default_context_bootstrap = None;+ self.command_turn_output = None;+ self.lightweight_popup_browsing_contexts.clear();+ self.internal_inspector_value_references.clear();}}impl Drop for JsContextHost {fn drop(&mut self) {self.close_page_context_resources_for_teardown();+ self.context_host_lifecycle+ .set(crate::util::ContextHostLifecycle::Destroyed);+ self.v8_finalizers.clear_for_context_teardown();}}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 477989ba4..849412d49 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@@ -100,6 +100,103 @@ impl PendingRuntimeObservableConsoleSourceEvent {}impl JsContextHost {+ pub(crate) fn retire_all_window_execution_context_resources_for_teardown(&mut self) {+ let owners = self+ .window_execution_contexts+ .keys()+ .copied()+ .collect::<Vec<_>>();+ let mut realm_tokens = self+ .window_execution_contexts+ .values()+ .map(WindowExecutionContextBinding::realm_token)+ .chain(+ self.window_execution_context_realms+ .concrete_by_token+ .keys()+ .copied(),+ )+ .collect::<Vec<_>>();+ realm_tokens.sort_unstable();+ realm_tokens.dedup();++ for realm_token in realm_tokens {+ self.cancel_timers_for_context_token(realm_token);+ self.retire_runtime_binding_context_token(realm_token);+ self.retire_image_decode_requests_for_context_token(realm_token);+ self.retire_webcrypto_context_token(realm_token);+ self.retire_opfs_context_token(realm_token);+ self.retire_workers_for_context_token(realm_token);+ self.disconnect_shared_worker_clients_for_context_token(realm_token);+ self.retire_window_xhrs_for_context_token(realm_token);+ self.retire_window_fetches_for_context_token(realm_token);+ self.retire_window_event_sources_for_context_token(realm_token);+ self.retire_message_ports_for_context_token(realm_token);+ self.retire_window_messages_for_context_token(realm_token);+ self.close_broadcast_channels_for_context_token(realm_token);+ self.retire_websockets_for_context_token(realm_token);+ self.retire_window_execution_contexts_for_context_token(realm_token);+ }++ for owner in owners {+ self.cancel_window_execution_context_timers(owner);+ self.retire_webcrypto_execution_context_owner(owner);+ self.retire_opfs_execution_context_owner(owner);+ self.retire_workers_for_execution_context_owner(owner);+ self.disconnect_shared_worker_clients_for_execution_context_owner(owner);+ self.retire_window_xhrs_for_execution_context_owner(owner);+ self.retire_window_fetches_for_execution_context_owner(owner);+ self.retire_window_event_sources_for_execution_context_owner(owner);+ self.retire_window_messages_for_execution_context_owner(owner);+ self.close_broadcast_channels_for_execution_context_owner(owner);+ self.retire_websockets_for_execution_context_owner(owner);+ self.retire_image_decode_requests_for_execution_context_owner(owner);+ self.retire_message_ports_for_execution_context_owner(owner);+ self.retire_window_execution_context(owner);+ }++ self.retire_v8_execution_state_for_context_teardown();++ // A detached Document realm may keep this host and its native DOM+ // alive through the V8 Context slot. None of the host's active+ // execution registries may in turn keep that Context alive with a+ // strong Global handle: that would form an untraceable+ // Context -> Rust host -> Global -> Context cycle. Chromium retires+ // these LocalDOMWindow/ExecutionContext-owned services when the frame+ // is detached while ordinary retained Document/Node values remain+ // usable.+ drop(std::mem::take(&mut self.custom_elements));+ self.child_custom_elements.clear();+ self.scoped_custom_elements.clear();+ drop(std::mem::take(&mut self.custom_element_reactions));+ drop(std::mem::take(&mut self.observers));+ drop(std::mem::take(&mut self.child_window_proxy_records));+ self.pending_service_worker_registers.clear();+ self.pending_service_worker_unregisters.clear();+ self.pending_service_worker_ready.clear();+ self.service_worker_registration_watchers.clear();+ self.pending_window_messages.clear();+ drop(std::mem::take(&mut self.directory_reader_callbacks));+ 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_image_load_events.clear();+ self.pending_media_load_sequences.clear();+ self.pending_text_track_load_sequences.clear();+ self.pending_media_text_track_gates.clear();+ self.resource_timing_buffers =+ super::resource_timing::SharedResourceTimingBufferRegistry::new();+ drop(std::mem::take(&mut self.history_queue));+ drop(std::mem::take(&mut self.rendering_updates));+ drop(std::mem::take(&mut self.view_transition_updates));+ drop(std::mem::take(&mut self.media_element_events));+ drop(std::mem::take(&mut self.element_toggle_events));+ drop(std::mem::take(&mut self.text_track_default_modes));+ self.child_window_event_listeners.clear();+ drop(std::mem::take(&mut self.event_callbacks));+ self.bridge.abort.clear_for_context_teardown();+ }+pub(crate) fn register_lightweight_popup_execution_context(&mut self,scope: &mut v8::PinScope<'_, '_>,diff --git a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rsindex d86a3135c..b06d7e412 100644--- a/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/websockets/commands.rs@@ -127,6 +127,24 @@ impl JsContextHost {retired}+ pub(crate) fn retire_websockets_for_context_token(+ &mut self,+ context_token: super::super::RuntimeObservableContextToken,+ ) -> usize {+ let socket_ids = self+ .websockets+ .iter()+ .filter_map(|(socket_id, state)| {+ (state.owner.realm_token() == context_token).then_some(*socket_id)+ })+ .collect::<Vec<_>>();+ let retired = socket_ids.len();+ for socket_id in socket_ids {+ self.retire_websocket(socket_id);+ }+ retired+ }+pub(crate) fn retire_websocket(&mut self, socket_id: u64) -> bool {let Some(state) = self.websockets.remove(&socket_id) else {return false;diff --git a/moli-renderer-v8/src/native_bridge/identity.rs b/moli-renderer-v8/src/native_bridge/identity.rsindex f0d4e17ba..8f0780e63 100644--- a/moli-renderer-v8/src/native_bridge/identity.rs+++ b/moli-renderer-v8/src/native_bridge/identity.rs@@ -448,14 +448,14 @@ pub(crate) fn contexts_share_wrapper_world(#[derive(Debug)]struct BridgeCachedWrapper {- wrapper: v8::Global<v8::Object>,+ wrapper: crate::util::RealmObjectHandle,creation_realm: Option<NonZeroU64>,}impl BridgeCachedWrapper {fn new(scope: &mut v8::PinScope<'_, '_>, wrapper: v8::Local<'_, v8::Object>) -> Self {Self {- wrapper: v8::Global::new(scope, wrapper),+ wrapper: crate::util::RealmObjectHandle::new(scope, wrapper),creation_realm: scope.get_current_context().get_slot::<RuntimeObservableContextToken>()@@ -468,7 +468,7 @@ impl BridgeCachedWrapper {#[derive(Debug)]struct BridgeContextWindowWrapper {- wrapper: v8::Global<v8::Object>,+ wrapper: RefCell<crate::util::RealmObjectHandle>,}fn context_window_wrapper<'s>(@@ -477,7 +477,7 @@ fn context_window_wrapper<'s>(scope.get_current_context().get_slot::<BridgeContextWindowWrapper>()- .map(|entry| v8::Local::new(scope, &entry.wrapper))+ .and_then(|entry| entry.wrapper.borrow().to_local(scope))}fn set_context_window_wrapper(@@ -487,7 +487,7 @@ fn set_context_window_wrapper(let _ = scope.get_current_context().set_slot(Rc::new(BridgeContextWindowWrapper {- wrapper: v8::Global::new(scope, wrapper),+ wrapper: RefCell::new(crate::util::RealmObjectHandle::new(scope, wrapper)),}));}@@ -514,7 +514,16 @@ impl BridgeContextWrapperCacheRetainForTest {self.cache.borrow().wrappers.len()}- pub(crate) fn wrapper_entry_count_for_realm(+ pub(crate) fn strong_wrapper_entry_count(&self) -> usize {+ self.cache+ .borrow()+ .wrappers+ .values()+ .filter(|entry| entry.wrapper.is_strong())+ .count()+ }++ pub(crate) fn strong_wrapper_entry_count_for_realm(&self,realm_token: RuntimeObservableContextToken,) -> usize {@@ -522,7 +531,10 @@ impl BridgeContextWrapperCacheRetainForTest {.borrow().wrappers.values()- .filter(|entry| entry.creation_realm.map(NonZeroU64::get) == Some(realm_token.as_u64()))+ .filter(|entry| {+ entry.wrapper.is_strong()+ && entry.creation_realm.map(NonZeroU64::get) == Some(realm_token.as_u64())+ }).count()}}@@ -541,18 +553,41 @@ pub(crate) fn clear_context_wrapper_cache_for_teardown(include_shared_default_world: bool,) {let context = scope.get_current_context();- if !include_shared_default_world- && context+ crate::util::detach_document_page_context(context);+ if let Some(host) = crate::util::context_host_ptr_from_context_slot(context) {+ unsafe { &mut *host }+ .native_bridge_mut()+ .abort+ .retire_context(scope, context);+ }+ let all_entries = include_shared_default_world+ || context.get_slot::<SharedDefaultWorldWrapperCache>()- .is_some()- {- return;- }+ .is_none();+ let realm = context+ .get_slot::<RuntimeObservableContextToken>()+ .as_deref()+ .map(|token| token.as_u64());if let Some(cache) = context.get_slot::<RefCell<BridgeContextWrapperCache>>() {- let mut cache = cache.borrow_mut();- cache.wrappers.clear();- cache.live_collection_wrappers.clear();+ let mut entries = cache.borrow_mut();+ for entry in entries.wrappers.values_mut() {+ if all_entries || entry.creation_realm.map(NonZeroU64::get) == realm {+ entry.wrapper.retain_in_realm(scope);+ }+ }+ for entry in entries.live_collection_wrappers.values_mut() {+ if all_entries || entry.creation_realm.map(NonZeroU64::get) == realm {+ entry.wrapper.retain_in_realm(scope);+ }+ }+ drop(entries);+ crate::util::retain_context_v8_handle_state_for_safe_release(context, cache);+ }+ if let Some(wrapper) = context.get_slot::<BridgeContextWindowWrapper>() {+ wrapper.wrapper.borrow_mut().retain_in_realm(scope);+ crate::util::retain_context_v8_handle_state_for_safe_release(context, wrapper);}+ crate::context_bootstrap::exposed_interfaces::retain_intrinsic_interfaces_in_realm(scope);}#[derive(Debug, Default)]@@ -603,7 +638,7 @@ impl BridgeIdentityStore {.borrow().wrappers.get(&reflector_id)- .map(|entry| v8::Local::new(scope, &entry.wrapper))+ .and_then(|entry| entry.wrapper.to_local(scope))}pub(super) fn cache_wrapper(@@ -642,7 +677,7 @@ impl BridgeIdentityStore {.borrow().live_collection_wrappers.get(descriptor)- .map(|entry| v8::Local::new(scope, &entry.wrapper))+ .and_then(|entry| entry.wrapper.to_local(scope))}pub(super) fn cache_live_collection_wrapper(@@ -664,9 +699,11 @@ impl BridgeIdentityStore {let mut cache = self.default_world_wrapper_cache.borrow_mut();cache.wrappers.retain(|_, entry| {entry.creation_realm.map(NonZeroU64::get) != Some(realm_token.as_u64())+ || !entry.wrapper.is_strong()});cache.live_collection_wrappers.retain(|_, entry| {entry.creation_realm.map(NonZeroU64::get) != Some(realm_token.as_u64())+ || !entry.wrapper.is_strong()});}@@ -749,9 +786,9 @@ mod tests {}#[test]- fn cached_wrapper_entry_uses_the_global_handle_niche() {+ fn cached_wrapper_entry_bounds_the_handle_and_realm_metadata() {#[cfg(target_pointer_width = "64")]- assert_eq!(size_of::<BridgeCachedWrapper>(), 24);+ assert_eq!(size_of::<BridgeCachedWrapper>(), 32);}#[test]diff --git a/moli-renderer-v8/src/native_bridge/identity/dense_reflector_map.rs b/moli-renderer-v8/src/native_bridge/identity/dense_reflector_map.rsindex a9aaf28a9..ad867a9b0 100644--- a/moli-renderer-v8/src/native_bridge/identity/dense_reflector_map.rs+++ b/moli-renderer-v8/src/native_bridge/identity/dense_reflector_map.rs@@ -62,6 +62,7 @@ impl<V> DenseReflectorMap<V> {self.sparse.insert(id, value)}+ #[cfg(test)]pub(super) fn clear(&mut self) {self.dense_base = None;self.dense.clear();@@ -112,6 +113,13 @@ impl<V> DenseReflectorMap<V> {pub(super) fn values(&self) -> impl Iterator<Item = &V> {self.dense.iter().flatten().chain(self.sparse.values())}++ pub(super) fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {+ self.dense+ .iter_mut()+ .flatten()+ .chain(self.sparse.values_mut())+ }}#[cfg(test)]diff --git a/moli-renderer-v8/src/native_bridge/traversal/filters.rs b/moli-renderer-v8/src/native_bridge/traversal/filters.rsindex 1b419fe3b..d2ad4fe4b 100644--- a/moli-renderer-v8/src/native_bridge/traversal/filters.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/filters.rs@@ -1,3 +1,4 @@+use crate::v8_traced_webidl_callback::V8TracedWebIdlCallbackInterface;use crate::webidl::{PreparedWebIdlCallbackInterface, WebIdlCallbackInterface};use crate::{callback_invocation::{@@ -28,37 +29,44 @@ pub(super) enum TraversalFilterResult {/// The callback-interface value owned by one TreeWalker or NodeIterator.///-/// Traversal owns registration lifetime and reentrancy. The callback kernel-/// owns the rooted callback plus its relevant/incumbent contexts. The renderer+/// The wrapper owns a V8-traced callback carrier; the native registry only+/// observes it weakly. The callback kernel roots invocation snapshots. The renderer/// identity is deliberately kept beside those engine-neutral facts so a/// detached or replaced Window cannot re-enter through a still-reachable/// traversal wrapper.pub(in crate::native_bridge) struct TraversalFilter {- callback: WebIdlCallbackInterface,+ callback: v8::Weak<v8::Object>,execution_context: Option<WindowExecutionContextIdentity>,}impl TraversalFilter {- pub(super) fn new(- scope: &mut v8::PinScope<'_, '_>,+ pub(super) fn new<'s>(+ scope: &mut v8::PinScope<'s, '_>,runtime_ptr: *mut JsContextHost,+ wrapper: v8::Local<'s, v8::Object>,callback: WebIdlCallbackInterface,) -> Self {let prepared = callback.prepare(scope);let relevant_context = prepared.relevant_context(scope);let execution_context = unsafe { &*runtime_ptr }.window_execution_context_identity_for_v8_context(scope, relevant_context);+ let carrier = V8TracedWebIdlCallbackInterface::new(scope, callback).into_object();+ crate::util::set_private_value(scope, wrapper, "__lmTraversalFilter", carrier.into());Self {- callback,+ callback: v8::Weak::new(scope, carrier),execution_context,}}- pub(super) fn prepare(&self, scope: &mut v8::PinScope<'_, '_>) -> PreparedTraversalFilter {- PreparedTraversalFilter {- callback: self.callback.prepare(scope),+ pub(super) fn prepare(+ &self,+ scope: &mut v8::PinScope<'_, '_>,+ ) -> Option<PreparedTraversalFilter> {+ let carrier = self.callback.to_local(scope)?;+ Some(PreparedTraversalFilter {+ callback: V8TracedWebIdlCallbackInterface::from_object(carrier).prepare(scope),execution_context: self.execution_context,- }+ })}}diff --git a/moli-renderer-v8/src/native_bridge/traversal/state.rs b/moli-renderer-v8/src/native_bridge/traversal/state.rsindex f19172fc1..a1955986d 100644--- a/moli-renderer-v8/src/native_bridge/traversal/state.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/state.rs@@ -219,7 +219,7 @@ fn prepare_filter(filter: Option<&TraversalFilter>,) -> Option<Rc<PreparedTraversalFilter>> {let filter = filter?;- Some(Rc::new(filter.prepare(scope)))+ Some(Rc::new(filter.prepare(scope)?))}#[cfg(test)]diff --git a/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs b/moli-renderer-v8/src/native_bridge/traversal/wrappers.rsindex 9ed6703da..9b9b34223 100644--- a/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs+++ b/moli-renderer-v8/src/native_bridge/traversal/wrappers.rs@@ -115,12 +115,12 @@ pub(in crate::native_bridge) fn build_node_iterator_wrapper<'s>(what_to_show: u32,filter: Option<WebIdlCallbackInterface>,) -> v8::Local<'s, v8::Object> {- let filter = filter.map(|filter| TraversalFilter::new(scope, runtime_ptr, filter));- let id = bridge.register_node_iterator(root, what_to_show, filter);let template = bridge.node_iterator_wrapper_template();let wrapper = template.new_instance(scope).expect("failed to instantiate NodeIterator wrapper");+ let filter = filter.map(|filter| TraversalFilter::new(scope, runtime_ptr, wrapper, filter));+ let id = bridge.register_node_iterator(root, what_to_show, filter);let runtime_external = v8::External::new(scope, runtime_ptr as *mut c_void);assert!(wrapper.set_internal_field(0, runtime_external.into()),@@ -142,12 +142,12 @@ pub(in crate::native_bridge) fn build_tree_walker_wrapper<'s>(what_to_show: u32,filter: Option<WebIdlCallbackInterface>,) -> v8::Local<'s, v8::Object> {- let filter = filter.map(|filter| TraversalFilter::new(scope, runtime_ptr, filter));- let id = bridge.register_tree_walker(root, what_to_show, filter);let template = bridge.tree_walker_wrapper_template();let wrapper = template.new_instance(scope).expect("failed to instantiate TreeWalker wrapper");+ let filter = filter.map(|filter| TraversalFilter::new(scope, runtime_ptr, wrapper, filter));+ let id = bridge.register_tree_walker(root, what_to_show, filter);let runtime_external = v8::External::new(scope, runtime_ptr as *mut c_void);assert!(wrapper.set_internal_field(0, runtime_external.into()),diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex 42a27860b..c377ea295 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -891,9 +891,10 @@ pub(crate) use standalone_test_harness::StandaloneScriptVmHarness;use crate::document_runtime::{DeferredPageTaskLane, FollowupPageTaskDisposition};use document_isolate::*;pub(crate) use document_isolate::{- RendererDocumentIsolateBootstrap, RendererDocumentIsolateHandle,- RendererDocumentIsolateReservationAccounting, RendererPageScriptEnvironment,- ScriptVmDefaultWorldBootstrap, renderer_document_isolate_accounting_diagnostics,+ RendererDeferredContextHostReleaseQueue, RendererDocumentIsolateBootstrap,+ RendererDocumentIsolateHandle, RendererDocumentIsolateReservationAccounting,+ RendererPageScriptEnvironment, ScriptVmDefaultWorldBootstrap,+ renderer_document_isolate_accounting_diagnostics,};pub(crate) use eval_exec::execute_source_text_on_current_stack;pub(crate) use input_helpers::*;@@ -907,6 +908,7 @@ pub(crate) use runtime_bindings::PromiseRejectDispatchSlot;pub(crate) use runtime_bindings::perform_microtask_checkpoint_and_report_pending_promise_rejections;use runtime_bindings::*;pub(crate) use runtime_work::*;+use std::ops::{Deref, DerefMut};#[cfg(any(test, feature = "test-support"))]type ScriptGlobalsBaseline = Vec<String>;@@ -950,15 +952,46 @@ fn register_main_window_execution_context_for_bootstrap(.context("failed to register main LocalWindow execution context")}+pub(super) struct ScriptVmDocumentRuntimeOwner {+ document_runtime: Option<Box<DocumentRuntime>>,+}++impl ScriptVmDocumentRuntimeOwner {+ fn new(document_runtime: Box<DocumentRuntime>) -> Self {+ Self {+ document_runtime: Some(document_runtime),+ }+ }++ fn take_for_retained_document_host(&mut self) -> Option<Box<DocumentRuntime>> {+ self.document_runtime.take()+ }+}++impl Deref for ScriptVmDocumentRuntimeOwner {+ type Target = DocumentRuntime;++ fn deref(&self) -> &Self::Target {+ self.document_runtime+ .as_deref()+ .expect("ScriptVm DocumentRuntime must remain owned until ScriptVm drop")+ }+}++impl DerefMut for ScriptVmDocumentRuntimeOwner {+ fn deref_mut(&mut self) -> &mut Self::Target {+ self.document_runtime+ .as_deref_mut()+ .expect("ScriptVm DocumentRuntime must remain owned until ScriptVm drop")+ }+}+pub(super) struct ScriptVm {resource_owner_id: crate::resource_owner::ResourceOwnerId,/// Page/target-facing inspector state. This must drop before the renderer/// document isolate handle because the V8 inspector session touches the/// isolate-level backend while being destroyed.page_inspector: DocumentInspectorBinding,- /// Handle to renderer-owner document isolate-level V8 state. Multiple page- /// facades can share the holder while keeping page/context state here.- renderer_document_isolate: RendererDocumentIsolateHandle,renderer_document_isolate_teardown: RendererDocumentIsolateTeardown,renderer_page_script_environment: Option<RendererPageScriptEnvironment>,page_default_context: v8::Global<v8::Context>,@@ -973,7 +1006,7 @@ pub(super) struct ScriptVm {// `JsContextHost` stores a non-owning pointer into `document_runtime`, so it// must be dropped before the runtime field during normal Rust field teardown._context_host: Rc<RefCell<JsContextHost>>,- pub(super) document_runtime: Box<DocumentRuntime>,+ pub(super) document_runtime: ScriptVmDocumentRuntimeOwner,post_domcontentloaded_page_task_tx: PageTaskSender,page_runtime_wake_tx: PageRuntimeWakeSender,queued_main_document_runtime_continuation_owner:@@ -1014,6 +1047,9 @@ pub(super) struct ScriptVm {#[cfg(test)]_page_task_residence_for_executor_test:Option<crate::page_task_queue::RendererPageTaskTestResidence>,+ // Native and V8 per-document state must drop before the final isolate+ // handle; retained realms then release their host through its GC queue.+ renderer_document_isolate: RendererDocumentIsolateHandle,}impl moli_layout::GeometryProvider for ScriptVm {@@ -2010,6 +2046,11 @@ impl ScriptVmPageRealmBootstrap {top_level_storage_key,reserved_service_worker_client_id,)));+ context_host+ .borrow_mut()+ .bind_deferred_context_host_release_queue(+ renderer_document_isolate.deferred_context_host_release_queue(),+ );let main_document_owner = context_host.borrow().current_main_document_task_owner()@@ -2383,7 +2424,7 @@ impl ScriptVmDefaultWorldBootstrap {page_default_runtime_observable_context_token: runtime_observable_context_token,root_frame_id,baseline_globals,- document_runtime,+ document_runtime: ScriptVmDocumentRuntimeOwner::new(document_runtime),_context_host: context_host,page_context_cancel_tx,post_domcontentloaded_page_task_tx,@@ -2426,6 +2467,26 @@ impl ScriptVmDefaultWorldBootstrap {.borrow_mut().bind_output_journal(environment.output_journal());}+ vm._context_host.borrow_mut().publish_document_host();+ vm.renderer_document_isolate+ .with_renderer_document_isolate_mut(|isolate| {+ let scope = pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ crate::util::retain_context_host_for_document_realm(+ v8::Local::new(scope, &vm.page_default_context),+ vm._context_host.clone(),+ vm.renderer_document_isolate+ .deferred_context_host_release_queue(),+ );+ for child in vm.prebootstrapped_child_default_contexts.borrow().values() {+ crate::util::retain_context_host_for_document_realm(+ v8::Local::new(scope, &child.context),+ vm._context_host.clone(),+ vm.renderer_document_isolate+ .deferred_context_host_release_queue(),+ );+ }+ });Ok(vm)}}diff --git a/moli-renderer-v8/src/script_vm/document_isolate.rs b/moli-renderer-v8/src/script_vm/document_isolate.rsindex a42c21498..0c8c3fc6d 100644--- a/moli-renderer-v8/src/script_vm/document_isolate.rs+++ b/moli-renderer-v8/src/script_vm/document_isolate.rs@@ -34,7 +34,7 @@ use crate::{};use anyhow::{Result, anyhow};use std::{- cell::{OnceCell, RefCell},+ cell::{Cell, OnceCell, RefCell},rc::Rc,sync::atomic::{AtomicU64, Ordering},};@@ -44,6 +44,67 @@ static DOCUMENT_ISOLATE_DESTROYED_COUNT: AtomicU64 = AtomicU64::new(0);static DOCUMENT_ISOLATE_LIVE_COUNT: AtomicU64 = AtomicU64::new(0);static DOCUMENT_ISOLATE_RESERVED_COUNT: AtomicU64 = AtomicU64::new(0);+#[derive(Clone, Debug, Default)]+pub(crate) struct RendererDeferredContextHostReleaseQueue {+ inner: Rc<RendererDeferredContextHostReleaseQueueInner>,+}++struct RendererDeferredContextHostRelease {+ _host: Rc<RefCell<JsContextHost>>,+ retained_v8_handle_state: Vec<Box<dyn std::any::Any>>,+}++impl std::fmt::Debug for RendererDeferredContextHostRelease {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ formatter+ .debug_struct("RendererDeferredContextHostRelease")+ .field(+ "retained_v8_handle_state_count",+ &self.retained_v8_handle_state.len(),+ )+ .finish_non_exhaustive()+ }+}++#[derive(Debug, Default)]+struct RendererDeferredContextHostReleaseQueueInner {+ pending: RefCell<Vec<RendererDeferredContextHostRelease>>,+ isolate_shutting_down: Cell<bool>,+}++impl RendererDeferredContextHostReleaseQueue {+ pub(crate) fn defer(+ &self,+ host: Rc<RefCell<JsContextHost>>,+ retained_v8_handle_state: Vec<Box<dyn std::any::Any>>,+ ) {+ let release = RendererDeferredContextHostRelease {+ _host: host,+ retained_v8_handle_state,+ };+ if self.inner.isolate_shutting_down.get() {+ drop(release);+ return;+ }+ self.inner.pending.borrow_mut().push(release);+ }++ fn drain_on_entered_isolate(&self) {+ loop {+ let pending = std::mem::take(&mut *self.inner.pending.borrow_mut());+ if pending.is_empty() {+ return;+ }+ drop(pending);+ }+ }++ fn begin_isolate_shutdown(&self) {+ self.drain_on_entered_isolate();+ self.inner.isolate_shutting_down.set(true);+ }+}+pub(crate) fn renderer_document_isolate_accounting_diagnostics()-> crate::runtime::RendererDocumentIsolateAccountingDiagnostics {crate::runtime::RendererDocumentIsolateAccountingDiagnostics {@@ -93,11 +154,8 @@ pub(super) struct ScriptVmPageRealmBootstrap {pub(super) resource_owner_id: ResourceOwnerId,pub(super) promise_reject_dispatch: PromiseRejectDispatchSlot,pub(super) page_inspector: DocumentInspectorBinding,- pub(super) renderer_document_isolate: RendererDocumentIsolateHandle,pub(super) renderer_document_isolate_teardown: RendererDocumentIsolateTeardown,- pub(super) document_runtime: Box<DocumentRuntime>,pub(super) root_frame_id: Option<String>,- pub(super) context_host: Rc<RefCell<JsContextHost>>,pub(super) prebootstrapped_child_default_contexts: SharedPrebootstrappedChildDefaultContexts,pub(super) page_context_cancel_tx: RendererPageContextCancelSender,pub(super) post_domcontentloaded_page_task_tx: PageTaskSender,@@ -105,6 +163,12 @@ pub(super) struct ScriptVmPageRealmBootstrap {pub(super) storage_bucket_store: crate::context_bootstrap::SharedStorageBucketStore,pub(super) renderer_page_script_environment: Option<RendererPageScriptEnvironment>,pub(super) reuse_main_window_proxy: bool,+ // Partial bootstrap can drop before publication. Release bridge owners+ // before their native backing, and keep V8 alive until all of it+ // has been released.+ pub(super) context_host: Rc<RefCell<JsContextHost>>,+ pub(super) document_runtime: Box<DocumentRuntime>,+ pub(super) renderer_document_isolate: RendererDocumentIsolateHandle,}pub(super) struct ScriptVmContextBootstrap {@@ -269,21 +333,24 @@ pub(crate) struct ScriptVmDefaultWorldBootstrap {pub(super) resource_owner_id: ResourceOwnerId,pub(super) promise_reject_dispatch: PromiseRejectDispatchSlot,pub(super) page_inspector: DocumentInspectorBinding,- pub(super) renderer_document_isolate: RendererDocumentIsolateHandle,pub(super) renderer_document_isolate_teardown: RendererDocumentIsolateTeardown,pub(super) renderer_page_script_environment: Option<RendererPageScriptEnvironment>,pub(super) page_default_context: v8::Global<v8::Context>,pub(super) bridge_ref: JsContextHostBridgeRef,pub(super) runtime_observable_context_token: RuntimeObservableContextToken,pub(super) baseline_globals: super::ScriptGlobalsBaseline,- pub(super) document_runtime: Box<DocumentRuntime>,pub(super) root_frame_id: Option<String>,- pub(super) context_host: Rc<RefCell<JsContextHost>>,pub(super) prebootstrapped_child_default_contexts: SharedPrebootstrappedChildDefaultContexts,pub(super) page_context_cancel_tx: RendererPageContextCancelSender,pub(super) post_domcontentloaded_page_task_tx: PageTaskSender,pub(super) page_runtime_wake_tx: PageRuntimeWakeSender,pub(super) storage_bucket_store: crate::context_bootstrap::SharedStorageBucketStore,+ // Partial bootstrap can drop before publication. Release bridge owners+ // before their native backing, and keep V8 alive until all of it+ // has been released.+ pub(super) context_host: Rc<RefCell<JsContextHost>>,+ pub(super) document_runtime: Box<DocumentRuntime>,+ pub(super) renderer_document_isolate: RendererDocumentIsolateHandle,}#[derive(Clone, Copy, Debug)]@@ -342,6 +409,7 @@ impl RendererDocumentIsolateTeardown {#[derive(Clone)]pub(crate) struct RendererDocumentIsolateHandle {inner: Rc<RefCell<RendererDocumentIsolateHolder>>,+ deferred_context_host_releases: RendererDeferredContextHostReleaseQueue,}impl std::fmt::Debug for RendererDocumentIsolateHandle {@@ -352,6 +420,12 @@ impl std::fmt::Debug for RendererDocumentIsolateHandle {}impl RendererDocumentIsolateHandle {+ pub(crate) fn deferred_context_host_release_queue(+ &self,+ ) -> RendererDeferredContextHostReleaseQueue {+ self.deferred_context_host_releases.clone()+ }+#[cfg(test)]pub(crate) fn new_standalone_without_owner_reservation_for_test(v8_foreground_task_sender: RendererPageV8ForegroundTaskSender,@@ -384,7 +458,11 @@ impl RendererDocumentIsolateHandle {foreground_wake,devtools_target_shutdown_registry,)?;+ let deferred_context_host_releases = renderer_document_isolate+ .deferred_context_host_releases+ .clone();let renderer_document_isolate = Self {+ deferred_context_host_releases,inner: Rc::new(RefCell::new(renderer_document_isolate)),};let isolate_backend = renderer_document_isolate.inspector_isolate_backend_handle();@@ -445,7 +523,12 @@ impl RendererDocumentIsolateHandle {let inspector_backend = inspector_backend.as_mut().expect("document isolate Inspector backend missing before ScriptVm drop");- with_entered_owned_isolate(isolate, |isolate| op(isolate, inspector_backend))+ with_entered_owned_isolate(isolate, |isolate| {+ let result = op(isolate, inspector_backend);+ self.deferred_context_host_releases+ .drain_on_entered_isolate();+ result+ })}pub(super) fn with_entered_renderer_document_isolate_and_inspector_mut<T>(@@ -461,7 +544,12 @@ impl RendererDocumentIsolateHandle {let inspector_backend = inspector_backend.as_mut().ok_or_else(|| anyhow!("document isolate Inspector backend unavailable"))?;- with_entered_owned_isolate(isolate, |isolate| op(isolate, inspector_backend))+ with_entered_owned_isolate(isolate, |isolate| {+ let result = op(isolate, inspector_backend);+ self.deferred_context_host_releases+ .drain_on_entered_isolate();+ result+ })}pub(super) fn with_renderer_document_isolate_mut<T>(@@ -469,7 +557,12 @@ impl RendererDocumentIsolateHandle {op: impl FnOnce(&mut v8::OwnedIsolate) -> T,) -> T {let mut holder = self.inner.borrow_mut();- with_entered_owned_isolate(&mut holder.isolate, op)+ with_entered_owned_isolate(&mut holder.isolate, |isolate| {+ let result = op(isolate);+ self.deferred_context_host_releases+ .drain_on_entered_isolate();+ result+ })}pub(super) fn with_entered_renderer_document_isolate<T>(@@ -477,7 +570,12 @@ impl RendererDocumentIsolateHandle {op: impl FnOnce(&mut v8::OwnedIsolate) -> Result<T>,) -> Result<T> {let mut holder = self.inner.borrow_mut();- with_entered_owned_isolate(&mut holder.isolate, op)+ with_entered_owned_isolate(&mut holder.isolate, |isolate| {+ let result = op(isolate);+ self.deferred_context_host_releases+ .drain_on_entered_isolate();+ result+ })}pub(super) fn with_entered_renderer_document_isolate_and_bootstrap<T>(@@ -488,7 +586,12 @@ impl RendererDocumentIsolateHandle {let RendererDocumentIsolateHolder {isolate, bootstrap, ..} = &mut *holder;- with_entered_owned_isolate(isolate, |isolate| op(isolate, &*bootstrap))+ with_entered_owned_isolate(isolate, |isolate| {+ let result = op(isolate, &*bootstrap);+ self.deferred_context_host_releases+ .drain_on_entered_isolate();+ result+ })}pub(super) fn unregister_renderer_document_isolate_platform(&self) {@@ -506,6 +609,7 @@ impl RendererDocumentIsolateHandle {}pub(super) struct RendererDocumentIsolateHolder {+ deferred_context_host_releases: RendererDeferredContextHostReleaseQueue,// Unregister before destroying the Inspector backend so owner shutdown// never observes a target whose isolate has already been disposed._devtools_target_shutdown_registration: Option<RendererDevToolsTargetShutdownRegistration>,@@ -675,6 +779,7 @@ impl RendererDocumentIsolateHolder {isolate: v8::OwnedIsolate,) -> Self {Self {+ deferred_context_host_releases: RendererDeferredContextHostReleaseQueue::default(),_devtools_target_shutdown_registration: devtools_target_shutdown_registration,inspector_backend: Some(inspector_backend),bootstrap,@@ -694,6 +799,7 @@ impl Drop for RendererDocumentIsolateHolder {unsafe {self.isolate.enter();}+ self.deferred_context_host_releases.begin_isolate_shutdown();}}diff --git a/moli-renderer-v8/src/script_vm/drop_cleanup.rs b/moli-renderer-v8/src/script_vm/drop_cleanup.rsindex 616dee19a..f3557152a 100644--- a/moli-renderer-v8/src/script_vm/drop_cleanup.rs+++ b/moli-renderer-v8/src/script_vm/drop_cleanup.rs@@ -19,5 +19,10 @@ impl Drop for ScriptVm {.deactivate_page_vm_binding_for_teardown();self.page_default_bridge_ref.take();+ if let Some(runtime) = self.document_runtime.take_for_retained_document_host() {+ self._context_host+ .borrow_mut()+ .adopt_retained_document_runtime(runtime);+ }}}diff --git a/moli-renderer-v8/src/script_vm/execution_contexts.rs b/moli-renderer-v8/src/script_vm/execution_contexts.rsindex 0a26cfaa3..33f1450fc 100644--- a/moli-renderer-v8/src/script_vm/execution_contexts.rs+++ b/moli-renderer-v8/src/script_vm/execution_contexts.rs@@ -406,6 +406,8 @@ impl ScriptVm {Some(context)}Some(context) => {+ let context_ptr = &context.context as *const v8::Global<v8::Context>;+ self.clear_context_wrapper_cache_for_context_ptr(context_ptr, false);self.cancel_history_traversals_for_retiring_window(crate::native_bridge::WindowExecutionContextOwner::Frame(context.local_window_id,@@ -555,6 +557,8 @@ impl ScriptVm {};if !stale_prebootstrapped_contexts.is_empty() {for (_, context) in &stale_prebootstrapped_contexts {+ let context_ptr = &context.context as *const v8::Global<v8::Context>;+ self.clear_context_wrapper_cache_for_context_ptr(context_ptr, false);self.cancel_history_traversals_for_retiring_window(crate::native_bridge::WindowExecutionContextOwner::Frame(context.local_window_id,@@ -623,6 +627,8 @@ impl ScriptVm {let Some(context) = self.child_frame_realm_store.remove(&execution_context_id) else {return;};+ let context_ptr: *const v8::Global<v8::Context> = &context.context as *const _;+ self.clear_context_wrapper_cache_for_context_ptr(context_ptr, false);self.cancel_history_traversals_for_retiring_window(crate::native_bridge::WindowExecutionContextOwner::Frame(context.local_window_id),);@@ -696,8 +702,6 @@ impl ScriptVm {retired_timer_count,"retired child Runtime binding context");- let context_ptr: *const v8::Global<v8::Context> = &context.context as *const _;- self.clear_context_wrapper_cache_for_context_ptr(context_ptr, false);assert!(self.page_inspector.destroy_context_registration(context.inspector_context_registration_id),@@ -806,6 +810,8 @@ impl ScriptVm {.destroy_context_registration(context.inspector_context_registration_id),"isolated context must retain its document-owned Inspector registration");+ let context_ptr: *const v8::Global<v8::Context> = &context.context as *const _;+ self.clear_context_wrapper_cache_for_context_ptr(context_ptr, false);// V8 Inspector consumes the still-identifiable realm while processing// `context_destroyed` (including Runtime lifecycle projection for// named child worlds). Only after that notification may the strictdiff --git a/moli-renderer-v8/src/script_vm/post_parse.rs b/moli-renderer-v8/src/script_vm/post_parse.rsindex c09aab2f6..30d8eaddc 100644--- a/moli-renderer-v8/src/script_vm/post_parse.rs+++ b/moli-renderer-v8/src/script_vm/post_parse.rs@@ -363,6 +363,13 @@ impl ScriptVmContextBootstrap {if let Some(registration) = realm_registration.as_mut() {registration.commit();}+ // Child Window exposure can reach bootstrap while the caller holds+ // the host's RefCell borrow. Follow the bootstrap's raw host access+ // discipline and end each native read before touching V8 again.+ if unsafe { &*host_ptr }.document_host_is_published() {+ let queue = unsafe { &*host_ptr }.deferred_context_host_release_queue();+ crate::util::retain_context_host_for_document_realm(local_context, context_host, queue);+ }Ok(Self {context: v8::Global::new(scope, local_context),runtime_observable_context_token,diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/child_documents.rs b/moli-renderer-v8/src/script_vm/tests/extracted/child_documents.rsindex a9cee40cd..ae907ff2c 100644--- a/moli-renderer-v8/src/script_vm/tests/extracted/child_documents.rs+++ b/moli-renderer-v8/src/script_vm/tests/extracted/child_documents.rs@@ -2986,7 +2986,8 @@ async fn child_default_bridge_ref_is_released_on_child_context_teardown() {).expect("child wrapper cache setup should evaluate");assert_eq!(child_wrappers, "child-wrappers");- let child_wrapper_count = retained_child_cache.wrapper_entry_count_for_realm(child_realm_token);+ let child_wrapper_count =+ retained_child_cache.strong_wrapper_entry_count_for_realm(child_realm_token);assert!(child_wrapper_count >= 1,"child context wrappers should populate its default-world cache partition: {child_wrapper_count}"@@ -2999,7 +3000,8 @@ async fn child_default_bridge_ref_is_released_on_child_context_teardown() {)}).expect("top default context token should be readable");- let top_wrapper_count = retained_child_cache.wrapper_entry_count_for_realm(top_realm_token);+ let top_wrapper_count =+ retained_child_cache.strong_wrapper_entry_count_for_realm(top_realm_token);assert!(top_wrapper_count >= 1,"the shared default-world cache should contain live top-context wrappers"@@ -3031,12 +3033,13 @@ async fn child_default_bridge_ref_is_released_on_child_context_teardown() {"removed iframe should not keep a live child default context");assert_eq!(- retained_child_cache.wrapper_entry_count_for_realm(child_realm_token),+ retained_child_cache.strong_wrapper_entry_count_for_realm(child_realm_token),0,"destroying a child default context must retire its strong wrapper entries");assert!(- retained_child_cache.wrapper_entry_count_for_realm(top_realm_token) >= top_wrapper_count,+ retained_child_cache.strong_wrapper_entry_count_for_realm(top_realm_token)+ >= top_wrapper_count,"destroying a child context must preserve wrappers owned by the live top realm");assert_eq!(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 54a5a75b2..8e11f4ece 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,77 @@use super::*;+#[test]+fn retained_document_realm_keeps_native_values_until_the_last_v8_reference() {+ let mut vm = new_parsed_test_vm(+ "https://retained-document.test/old",+ "<!doctype html><p>old document</p>",+ );+ vm.eval(+ r#"+ globalThis.savedNode = document.querySelector('p');+ globalThis.savedDecoder = new TextDecoder();+ globalThis.savedBlob = new Blob(['retained blob']);+ globalThis.savedController = new AbortController();+ globalThis.savedSignal = savedController.signal;+ globalThis.savedComposite = AbortSignal.any([savedSignal]);+ globalThis.abortEventRan = false;+ savedSignal.onabort = () => { abortEventRan = true; };+ globalThis.savedReason = {kind: 'old realm'};+ globalThis.savedFunction = () => [savedNode.textContent, document.URL];+ 'ready'+ "#,+ )+ .unwrap();+ let weak_host = vm.context_host_weak_for_test();+ let isolate = vm.renderer_document_isolate.clone();+ let context = vm.page_default_context.clone();+ drop(vm);+ assert!(+ weak_host.upgrade().is_some(),+ "retained realm owns its native DOM"+ );++ let value = 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, &context);+ let scope = &mut v8::ContextScope::new(scope, context);+ let source = crate::util::v8str(scope, r#"+ savedNode.textContent = 'retained';+ savedController.abort(savedReason);+ JSON.stringify([+ savedFunction(),+ savedDecoder.decode(new Uint8Array([65])),+ savedBlob.size,+ savedSignal.aborted,+ savedSignal.reason === savedReason,+ savedComposite.aborted && savedComposite.reason === savedReason,+ abortEventRan,+ savedNode === document.querySelector('p'),+ (() => { try { savedSignal.throwIfAborted(); } catch (e) { return e === savedReason; } })()+ ])+ "#);+ let script = v8::Script::compile(scope, source, None).expect("retained realm compiles");+ crate::script_execution::execute_compiled_script(scope, script)+ .expect("retained native values remain usable")+ .to_rust_string_lossy(scope)+ });+ assert_eq!(+ value,+ r#"[["retained","https://retained-document.test/old"],"A",13,true,true,true,false,true,true]"#+ );++ isolate.with_renderer_document_isolate_mut(|isolate| {+ drop(context);+ isolate.low_memory_notification();+ });+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ assert!(+ weak_host.upgrade().is_none(),+ "last V8 reference releases native DOM outside GC"+ );+}+#[test]fn runtime_binding_calls_freeze_the_invoking_realm_generation() {let mut vm = new_storage_test_vm("https://runtime-binding-source-realm.test/");@@ -307,23 +379,33 @@ fn page_context_teardown_releases_opfs_handle_and_directory_iterator_registratiovm.close_page_context_resources_for_context_teardown();+ let handles = vm._context_host.borrow().opfs_handle_registry().unwrap();+ let iterators = vm+ ._context_host+ .borrow()+ .opfs_directory_iterator_registry()+ .unwrap();assert_eq!(- vm._context_host- .borrow()- .opfs_handle_registry()- .expect("OPFS handle registry remains owned until host teardown")- .len(),+ handles.len(),+ 1,+ "retained handle remains backed while its realm is alive"+ );+ assert_eq!(+ iterators.len(),+ 16,+ "retained iterators remain backed while their realm is alive"+ );+ assert_eq!(vm.eval("__opfsRoot.kind").unwrap(), "directory");+ drop(vm);+ assert_eq!(+ handles.len(),0,- "page teardown must run handle finalizers before isolate teardown"+ "final Context release retires native handle registrations");assert_eq!(- vm._context_host- .borrow()- .opfs_directory_iterator_registry()- .expect("OPFS iterator registry remains owned until host teardown")- .len(),+ iterators.len(),0,- "page teardown must run iterator finalizers before isolate teardown"+ "final Context release retires native iterator registrations");}#[test]@@ -802,7 +884,7 @@ fn promise_reject_context_slot_does_not_retain_context_host_after_script_vm_drop);}#[test]-fn context_wrapper_cache_is_cleared_on_script_vm_teardown() {+fn context_wrapper_cache_releases_native_roots_on_script_vm_teardown() {let mut vm = new_parsed_test_vm("https://wrapper-cache-retention.test/","<!doctype html><main></main>",@@ -846,7 +928,7 @@ fn context_wrapper_cache_is_cleared_on_script_vm_teardown() {drop(vm);assert_eq!(- retained_cache.wrapper_entry_count(),+ retained_cache.strong_wrapper_entry_count(),0,"page context teardown must clear strong wrapper cache entries before contexts are dropped");@@ -890,7 +972,7 @@ fn script_vm_page_context_teardown_is_idempotent() {);}#[test]-fn page_context_teardown_releases_all_context_owned_v8_finalizers() {+fn page_context_teardown_preserves_finalizers_for_retained_native_objects() {let mut vm = new_parsed_test_vm("https://v8-finalizer-teardown.test/","<!doctype html><body></body>",@@ -933,10 +1015,9 @@ fn page_context_teardown_releases_all_context_owned_v8_finalizers() {);vm.close_page_context_resources_for_context_teardown();- assert_eq!(- vm._context_host.borrow().v8_finalizers.len(),- 0,- "page context teardown must reset every weak handle before isolate teardown"+ assert!(+ vm._context_host.borrow().v8_finalizers.len() >= 128,+ "retiring active execution must preserve native objects retained by author code");assert_eq!(vm._context_host@@ -947,7 +1028,13 @@ fn page_context_teardown_releases_all_context_owned_v8_finalizers() {);vm.close_page_context_resources_for_context_teardown();+ assert_eq!(vm.eval("__finalizerObjects[2].size").unwrap(), "9");+ let weak_host = vm.context_host_weak_for_test();drop(vm);+ assert!(+ weak_host.upgrade().is_none(),+ "final isolate release must drop the native host"+ );}#[test]fn embedded_frame_owners_create_child_contexts_only_for_document_content() {@@ -1737,3 +1824,97 @@ fn frame_owner_content_accessors_live_on_exact_owner_prototypes() {r#"{"descriptors":[{"contentDocument":{"get":"function","set":"undefined","enumerable":true,"configurable":true},"contentWindow":{"get":"function","set":"undefined","enumerable":true,"configurable":true}},{"contentDocument":{"get":"function","set":"undefined","enumerable":true,"configurable":true},"contentWindow":{"get":"function","set":"undefined","enumerable":true,"configurable":true}},{"contentDocument":{"get":"function","set":"undefined","enumerable":true,"configurable":true},"contentWindow":{"get":"function","set":"undefined","enumerable":true,"configurable":true}}],"sameOriginValues":[true,true,true],"brandErrors":[["TypeError","TypeError"],["TypeError","TypeError"],["TypeError","TypeError"]],"absentFromBase":true}"#);}++#[test]+fn unreferenced_traversal_filters_release_retired_document() {+ for method in ["createTreeWalker", "createNodeIterator"] {+ let mut vm = new_parsed_test_vm("https://traversal.test/old", "<body>old document</body>");+ vm.eval(&format!(+ "document.{method}(document, NodeFilter.SHOW_ALL, () => NodeFilter.FILTER_ACCEPT); 1"+ ))+ .expect("unreferenced traversal setup");+ let host = vm.context_host_weak_for_test();+ let isolate = vm.renderer_document_isolate.clone();+ drop(vm);+ for _ in 0..3 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(+ host.upgrade().is_none(),+ "{method}: an unreferenced filter must not retain its retired Document host"+ );+ }+}++#[test]+fn retained_traversal_filters_release_host_after_last_reference() {+ for method in ["createTreeWalker", "createNodeIterator"] {+ let mut vm = new_parsed_test_vm(+ "https://retained-traversal.test/old",+ "<body>old document</body>",+ );+ vm.eval(&format!(+ r#"+ window.retainedFilter = () => NodeFilter.FILTER_ACCEPT;+ window.retainedTraversal = document.{method}(+ document.body, NodeFilter.SHOW_ALL, retainedFilter+ );+ 1+ "#+ ))+ .expect("retained traversal setup");+ let walker = vm+ .with_default_context_scope_and_checkpoint_for_test(|scope, _| {+ let context = scope.get_current_context();+ let value = context+ .global(scope)+ .get(scope, crate::util::v8str(scope, "retainedTraversal").into())+ .unwrap();+ let walker = v8::Local::<v8::Object>::try_from(value).unwrap();+ Ok(v8::Global::new(scope, walker))+ })+ .unwrap();+ let host = vm.context_host_weak_for_test();+ let isolate = vm.renderer_document_isolate.clone();+ drop(vm);+ for _ in 0..3 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(+ host.upgrade().is_some(),+ "a retained walker keeps native backing alive"+ );+ let result = isolate.with_renderer_document_isolate_mut(|isolate| {+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));+ let scope = &mut scope.init();+ let caller = v8::Context::new(scope, Default::default());+ let scope = &mut v8::ContextScope::new(scope, caller);+ let walker = v8::Local::new(scope, &walker);+ let context = walker.get_creation_context(scope).unwrap();+ let scope = &mut v8::ContextScope::new(scope, context);+ let source = crate::util::v8str(+ scope,+ r#"JSON.stringify([+ retainedTraversal.filter === retainedFilter,+ retainedTraversal.root.textContent+ ])"#,+ );+ let script = v8::Script::compile(scope, source, None).unwrap();+ crate::script_execution::execute_compiled_script(scope, script)+ .unwrap()+ .to_rust_string_lossy(scope)+ });+ assert_eq!(result, r#"[true,"old document"]"#);+ isolate.with_renderer_document_isolate_mut(|isolate| {+ drop(walker);+ isolate.low_memory_notification();+ });+ for _ in 0..3 {+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());+ }+ assert!(+ host.upgrade().is_none(),+ "the last walker reference releases its retired host"+ );+ }+}diff --git a/moli-renderer-v8/src/script_vm/tests/lazy_storage.rs b/moli-renderer-v8/src/script_vm/tests/lazy_storage.rsindex 1a6cf10db..f1ffb6f40 100644--- a/moli-renderer-v8/src/script_vm/tests/lazy_storage.rs+++ b/moli-renderer-v8/src/script_vm/tests/lazy_storage.rs@@ -613,6 +613,95 @@ fn native_dom_exception_uses_registered_prototype_after_public_override() {.expect("native exception should use the realm registry");}+#[test]+fn native_dom_exception_materializes_without_reading_the_public_constructor() {+ let mut vm = new_storage_test_vm("https://native-dom-exception-lazy.test/");+ vm.eval(+ r#"+ globalThis.exceptionConstructorReads = 0;+ delete globalThis.DOMException;+ Object.defineProperty(globalThis, 'DOMException', {+ configurable: true,+ get() {+ ++exceptionConstructorReads;+ throw new Error('the public constructor must not be read');+ }+ });+ "#,+ )+ .expect("public constructor override should evaluate");+ assert_eq!(+ constructor_materialization_count(&mut vm, "DOMException"),+ 0+ );++ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _host_ptr| {+ let exception = crate::context_bootstrap::new_dom_exception_value(+ scope,+ "native security failure",+ "SecurityError",+ );+ let exception = v8::Local::<v8::Object>::try_from(exception).unwrap();+ let intrinsic =+ crate::context_bootstrap::ensure_intrinsic_interface_prototype(scope, "DOMException")?;+ assert!(+ exception+ .get_prototype(scope)+ .unwrap()+ .strict_equals(intrinsic.into())+ );+ Ok(())+ })+ .expect("native exception should materialize through its realm registry");+ assert_eq!(vm.eval("exceptionConstructorReads").unwrap(), "0");+ assert_eq!(+ constructor_materialization_count(&mut vm, "DOMException"),+ 1+ );+}++#[test]+fn native_dom_exception_materializes_in_a_detached_realm() {+ let mut vm = new_storage_test_vm("https://native-dom-exception-detached.test/");+ assert_eq!(+ constructor_materialization_count(&mut vm, "DOMException"),+ 0+ );+ let isolate = vm.renderer_document_isolate.clone();+ let context = vm.page_default_context.clone();+ drop(vm);+ 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, &context);+ context.detach_global();+ let scope = &mut v8::ContextScope::new(scope, context);+ let exception = crate::context_bootstrap::new_dom_exception_value(+ scope,+ "native security failure",+ "SecurityError",+ );+ let exception = v8::Local::<v8::Object>::try_from(exception).unwrap();+ let intrinsic =+ crate::context_bootstrap::ensure_intrinsic_interface_prototype(scope, "DOMException")+ .expect("detached realm must retain its intrinsic registry");+ assert!(+ exception+ .get_prototype(scope)+ .unwrap()+ .strict_equals(intrinsic.into())+ );+ assert_eq!(exception.get_creation_context(scope), Some(context));+ assert_eq!(+ exception+ .get(scope, crate::util::v8str(scope, "name").into())+ .unwrap()+ .to_rust_string_lossy(scope),+ "SecurityError"+ );+ });+}+#[test]fn illegal_storage_receivers_do_not_materialize_wrappers_or_opfs_state() {let mut vm = new_storage_test_vm("https://lazy-illegal-storage-receivers.test/");diff --git a/moli-renderer-v8/src/util.rs b/moli-renderer-v8/src/util.rsindex 8dd09648a..23fc4d069 100644--- a/moli-renderer-v8/src/util.rs+++ b/moli-renderer-v8/src/util.rs@@ -18,7 +18,11 @@ pub use moli_v8_util::{};use moli_webapi_declare::WebApiValue;pub(crate) use moli_webapi_declare::define_array_data_property as define_v8_array_data_property;-use std::{ptr::NonNull, rc::Rc};+use std::{+ cell::{Cell, RefCell},+ ptr::NonNull,+ rc::Rc,+};use url::Url;use widestring::U16String;@@ -26,10 +30,113 @@ const SCRIPT_BASE_URL_HOST_DEFINED_OPTIONS_MARKER: &str = "moli-script-base-url-// Access-check callbacks cannot inspect the global object to rediscover the host:// that property lookup would recursively invoke the same V8 access check. This-// non-owning slot is valid while the context can execute because the matching-// ScriptVm context state retains its `JsContextHostBridgeRef`.+// slot starts non-owning during fallible bootstrap, then a successfully+// published Document realm promotes it to a Context-owned host reference. That+// mirrors ScriptState/Oilpan's retained-realm edge closely enough for Moli's+// non-tracing Rust heap: a retained function or DOM wrapper keeps its native+// Document backing alive, while temporary WindowProxy facades remain+// non-owning and fail closed as soon as the host detaches.+struct ContextHostPointerSlot {+ host_ptr: NonNull<JsContextHost>,+ host_lifecycle: Rc<Cell<ContextHostLifecycle>>,+ retained_realm_owner: RefCell<Option<RetainedDocumentRealmHostOwner>>,+}++struct RetainedDocumentRealmHostOwner {+ host: Option<Rc<RefCell<JsContextHost>>>,+ deferred_release_queue: crate::script_vm::RendererDeferredContextHostReleaseQueue,+ retained_v8_handle_state: Vec<Box<dyn std::any::Any>>,+}++impl Drop for RetainedDocumentRealmHostOwner {+ fn drop(&mut self) {+ if let Some(host) = self.host.take() {+ self.deferred_release_queue+ .defer(host, std::mem::take(&mut self.retained_v8_handle_state));+ }+ }+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum ContextHostLifecycle {+ Active,+ Detached,+ Destroyed,+}++/// Marks a V8 Context whose native Document host has been retired.+///+/// Navigation can keep the stable WindowProxy while replacing its Context and+/// `JsContextHost`; final Page close also parks that proxy on a host-free+/// facade. In both cases retained functions and wrappers can outlive the Rust+/// host, so every raw-pointer entry point must fail closed before inspecting+/// embedder data.#[derive(Debug)]-struct ContextHostPointerSlot(NonNull<JsContextHost>);+struct DisconnectedPageContext;++/// Marks a real Document realm whose browsing-context execution authority has+/// ended while its ordinary JS and DOM objects remain usable if author code+/// still retains them.+#[derive(Debug)]+struct DetachedDocumentPageContext;++/// Active native registries root their objects until teardown. A detached+/// realm instead keeps those objects in its own V8-traced graph, so retaining+/// a Document preserves wrapper identity without a Rust -> V8 -> Rust cycle.+#[derive(Debug)]+pub(crate) enum RealmObjectHandle {+ Strong(v8::Global<v8::Object>),+ Traced(v8::Weak<v8::Object>),+}++impl RealmObjectHandle {+ pub(crate) fn new(scope: &mut v8::PinScope<'_, '_>, object: v8::Local<'_, v8::Object>) -> Self {+ if page_context_is_detached_document(scope.get_current_context()) {+ Self::traced(scope, object)+ } else {+ Self::Strong(v8::Global::new(scope, object))+ }+ }++ fn traced(scope: &mut v8::PinScope<'_, '_>, object: v8::Local<'_, v8::Object>) -> Self {+ const ROOTS: &str = "__moliRetainedRealmObjects";+ let context = object+ .get_creation_context(scope)+ .unwrap_or_else(|| scope.get_current_context());+ let anchor = context.get_extras_binding_object(scope);+ let roots = get_private_value(scope, anchor, ROOTS)+ .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())+ .unwrap_or_else(|| {+ let roots = v8::Array::new(scope, 0);+ roots.set_prototype(scope, v8::null(scope).into());+ set_private_value(scope, anchor, ROOTS, roots.into());+ roots+ });+ roots.set_index(scope, roots.length(), object.into());+ Self::Traced(v8::Weak::new(scope, object))+ }++ pub(crate) fn to_local<'s>(+ &self,+ scope: &mut v8::PinScope<'s, '_>,+ ) -> Option<v8::Local<'s, v8::Object>> {+ match self {+ Self::Strong(object) => Some(v8::Local::new(scope, object)),+ Self::Traced(object) => object.to_local(scope),+ }+ }++ pub(crate) fn retain_in_realm(&mut self, scope: &mut v8::PinScope<'_, '_>) {+ if let Self::Strong(object) = self {+ let object = v8::Local::new(scope, &*object);+ *self = Self::traced(scope, object);+ }+ }++ pub(crate) fn is_strong(&self) -> bool {+ matches!(self, Self::Strong(_))+ }+}/// Materializes the unexposed prototype described by a WebIDL iterator/// FunctionTemplate. The temporary constructor is an implementation detail, so@@ -373,6 +480,9 @@ pub(super) fn context_host_ptr_from_global_bridge(scope: &mut v8::PinScope<'_, '_>,) -> Option<*mut JsContextHost> {let context = scope.get_current_context();+ if page_context_is_disconnected(context) {+ return None;+ }if let Some(host_ptr) = context_host_ptr_from_context_slot(context) {return Some(host_ptr);}@@ -384,24 +494,123 @@ pub(super) fn context_host_ptr_from_global_bridge(pub(super) fn install_context_host_pointer_slot(context: v8::Local<'_, v8::Context>,host_ptr: *mut JsContextHost,+ host_lifecycle: Rc<Cell<ContextHostLifecycle>>,) {let host_ptr =NonNull::new(host_ptr).expect("V8 context JsContextHost pointer should not be null");- let previous = context.set_slot(Rc::new(ContextHostPointerSlot(host_ptr)));assert!(- previous- .as_deref()- .is_none_or(|previous| previous.0 == host_ptr),- "V8 context JsContextHost pointer must not be rebound"+ host_lifecycle.get() == ContextHostLifecycle::Active,+ "a retired JsContextHost must not be installed into a V8 context");+ if let Some(existing) = context.get_slot::<ContextHostPointerSlot>() {+ assert!(+ existing.host_ptr == host_ptr && Rc::ptr_eq(&existing.host_lifecycle, &host_lifecycle),+ "V8 context JsContextHost pointer must not be rebound"+ );+ return;+ }+ let previous = context.set_slot(Rc::new(ContextHostPointerSlot {+ host_ptr,+ host_lifecycle: host_lifecycle.clone(),+ retained_realm_owner: RefCell::new(None),+ }));+ debug_assert!(previous.is_none());}pub(super) fn context_host_ptr_from_context_slot(context: v8::Local<'_, v8::Context>,) -> Option<*mut JsContextHost> {+ if page_context_is_disconnected(context) {+ return None;+ }context.get_slot::<ContextHostPointerSlot>()- .map(|slot| slot.0.as_ptr())+ .map(|slot| slot.host_ptr.as_ptr())+}++pub(crate) fn retain_context_host_for_document_realm(+ context: v8::Local<'_, v8::Context>,+ host: Rc<RefCell<JsContextHost>>,+ deferred_release_queue: crate::script_vm::RendererDeferredContextHostReleaseQueue,+) {+ let slot = context+ .get_slot::<ContextHostPointerSlot>()+ .expect("published Document realm must have a JsContextHost pointer slot");+ let host_ptr = NonNull::new(host.as_ptr())+ .expect("published Document realm JsContextHost pointer should not be null");+ assert_eq!(+ slot.host_ptr, host_ptr,+ "published Document realm must retain its installed JsContextHost"+ );+ assert!(+ slot.host_lifecycle.get() != ContextHostLifecycle::Destroyed,+ "destroyed JsContextHost must not gain a retained realm owner"+ );+ let mut retained = slot.retained_realm_owner.borrow_mut();+ if let Some(existing) = retained.as_ref() {+ assert!(+ existing+ .host+ .as_ref()+ .is_some_and(|existing| Rc::ptr_eq(existing, &host)),+ "Document realm JsContextHost owner must not be rebound"+ );+ return;+ }+ *retained = Some(RetainedDocumentRealmHostOwner {+ host: Some(host),+ deferred_release_queue,+ retained_v8_handle_state: Vec::new(),+ });+}++pub(crate) fn retain_context_v8_handle_state_for_safe_release<T: 'static>(+ context: v8::Local<'_, v8::Context>,+ state: Rc<T>,+) {+ let slot = context+ .get_slot::<ContextHostPointerSlot>()+ .expect("retained Context embedder state requires a Document host slot");+ let mut retained_owner = slot.retained_realm_owner.borrow_mut();+ let retained_owner = retained_owner+ .as_mut()+ .expect("retained Context embedder state requires a published real realm");+ retained_owner+ .retained_v8_handle_state+ .push(Box::new(state));+}++pub(crate) fn page_context_is_disconnected(context: v8::Local<'_, v8::Context>) -> bool {+ context.get_slot::<DisconnectedPageContext>().is_some()+ || context+ .get_slot::<ContextHostPointerSlot>()+ .is_some_and(|slot| match slot.host_lifecycle.get() {+ ContextHostLifecycle::Active => false,+ ContextHostLifecycle::Detached => slot.retained_realm_owner.borrow().is_none(),+ ContextHostLifecycle::Destroyed => true,+ })+}++pub(crate) fn page_context_is_detached_document(context: v8::Local<'_, v8::Context>) -> bool {+ context.get_slot::<DetachedDocumentPageContext>().is_some()+ || context+ .get_slot::<ContextHostPointerSlot>()+ .is_some_and(|slot| slot.host_lifecycle.get() == ContextHostLifecycle::Detached)+}++pub(crate) fn detach_document_page_context(context: v8::Local<'_, v8::Context>) {+ if page_context_is_disconnected(context) || page_context_is_detached_document(context) {+ return;+ }+ let slot = context+ .get_slot::<ContextHostPointerSlot>()+ .expect("detached Document realm must have a JsContextHost pointer slot");+ assert!(+ slot.retained_realm_owner.borrow().is_some(),+ "only a retained real Document realm may enter detached state"+ );+ let previous = context.set_slot(Rc::new(DetachedDocumentPageContext));+ debug_assert!(previous.is_none());}/// Convenience wrapper for callbacks that immediately need the host value.@@ -445,6 +654,13 @@ pub(super) fn context_host_ptr_from_window_object(scope: &mut v8::PinScope<'_, '_>,object: v8::Local<'_, v8::Object>,) -> Option<*mut JsContextHost> {+ if page_context_is_disconnected(scope.get_current_context())+ || object+ .get_creation_context(scope)+ .is_some_and(page_context_is_disconnected)+ {+ return None;+ }if let Some(value) = object.get_internal_field(scope, 0)&& let Ok(external) = v8::Local::<v8::External>::try_from(value){diff --git a/moli-renderer-v8/src/v8_traced_webidl_callback.rs b/moli-renderer-v8/src/v8_traced_webidl_callback.rsindex 7d93d2aa0..7c73670ca 100644--- a/moli-renderer-v8/src/v8_traced_webidl_callback.rs+++ b/moli-renderer-v8/src/v8_traced_webidl_callback.rs@@ -1,4 +1,4 @@-//! V8-traced residence for a Web IDL callback function.+//! V8-traced residence for Web IDL callback functions and interfaces.//!//! Some Web API owners already live as JavaScript objects. Storing their//! callbacks in independent Rust `Global` roots would keep callback-to-owner@@ -11,13 +11,88 @@//! Owners that need exact Window currentness must add that authorization before//! invoking the prepared callback.-use moli_webidl_callback::{PreparedWebIdlCallbackFunction, WebIdlCallbackFunction};+use moli_webidl_callback::{+ PreparedWebIdlCallbackFunction, PreparedWebIdlCallbackInterface, WebIdlCallbackFunction,+ WebIdlCallbackInterface,+};use crate::util::{get_private_value, set_private_value};const CALLBACK_VALUE_SLOT: &str = "__lmV8TracedWebIdlCallbackValue";const CALLBACK_RELEVANT_GLOBAL_SLOT: &str = "__lmV8TracedWebIdlCallbackRelevantGlobal";const CALLBACK_INCUMBENT_GLOBAL_SLOT: &str = "__lmV8TracedWebIdlCallbackIncumbentGlobal";+const CALLBACK_CALLABLE_SLOT: &str = "__lmV8TracedWebIdlCallbackCallableAtConversion";++/// Callback-interface residence owned by a JavaScript wrapper. Context extras+/// retain the original realms even after their WindowProxies are detached.+pub(crate) struct V8TracedWebIdlCallbackInterface<'s> {+ carrier: v8::Local<'s, v8::Object>,+}++impl<'s> V8TracedWebIdlCallbackInterface<'s> {+ pub(crate) fn new(scope: &mut v8::PinScope<'s, '_>, callback: WebIdlCallbackInterface) -> Self {+ let carrier = v8::Object::new(scope);+ let value = callback.value(scope);+ let relevant = callback+ .relevant_context(scope)+ .get_extras_binding_object(scope);+ let incumbent = callback+ .incumbent_context(scope)+ .get_extras_binding_object(scope);+ let callable = v8::Boolean::new(scope, callback.callable_at_conversion());+ set_private_value(scope, carrier, CALLBACK_VALUE_SLOT, value);+ set_private_value(+ scope,+ carrier,+ CALLBACK_RELEVANT_GLOBAL_SLOT,+ relevant.into(),+ );+ set_private_value(+ scope,+ carrier,+ CALLBACK_INCUMBENT_GLOBAL_SLOT,+ incumbent.into(),+ );+ set_private_value(scope, carrier, CALLBACK_CALLABLE_SLOT, callable.into());+ Self { carrier }+ }++ pub(crate) const fn from_object(carrier: v8::Local<'s, v8::Object>) -> Self {+ Self { carrier }+ }++ pub(crate) const fn into_object(self) -> v8::Local<'s, v8::Object> {+ self.carrier+ }++ pub(crate) fn prepare(+ &self,+ scope: &mut v8::PinScope<'s, '_>,+ ) -> PreparedWebIdlCallbackInterface {+ let object = |scope: &mut v8::PinScope<'s, '_>, slot| {+ get_private_value(scope, self.carrier, slot)+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ .expect("a traced callback interface must retain its registration facts")+ };+ let callback = object(scope, CALLBACK_VALUE_SLOT);+ let relevant_context = object(scope, CALLBACK_RELEVANT_GLOBAL_SLOT)+ .get_creation_context(scope)+ .expect("callback relevant realm anchor");+ let incumbent_context = object(scope, CALLBACK_INCUMBENT_GLOBAL_SLOT)+ .get_creation_context(scope)+ .expect("callback incumbent realm anchor");+ let callable = get_private_value(scope, self.carrier, CALLBACK_CALLABLE_SLOT)+ .expect("callback-interface callability at conversion")+ .is_true();+ PreparedWebIdlCallbackInterface::new(+ scope,+ callback,+ relevant_context,+ incumbent_context,+ callable,+ )+ }+}pub(crate) struct V8TracedWebIdlCallbackFunction<'s> {carrier: v8::Local<'s, v8::Object>,diff --git a/moli-webidl-callback/src/callback_interface.rs b/moli-webidl-callback/src/callback_interface.rsindex 8316efc4e..d4c479554 100644--- a/moli-webidl-callback/src/callback_interface.rs+++ b/moli-webidl-callback/src/callback_interface.rs@@ -32,15 +32,13 @@ impl WebIdlCallbackInterface {/// Event dispatch can therefore release all registration-store borrows/// before entering user code and its synchronous reentrancy.pub fn prepare(&self, scope: &mut v8::PinScope<'_, '_>) -> PreparedWebIdlCallbackInterface {- PreparedWebIdlCallbackInterface {- callback: v8::Global::new(scope, v8::Local::new(scope, &self.callback)),- relevant_context: v8::Global::new(scope, v8::Local::new(scope, &self.relevant_context)),- incumbent_context: v8::Global::new(- scope,- v8::Local::new(scope, &self.incumbent_context),- ),- callable_at_conversion: self.callable_at_conversion,- }+ PreparedWebIdlCallbackInterface::new(+ scope,+ v8::Local::new(scope, &self.callback),+ v8::Local::new(scope, &self.relevant_context),+ v8::Local::new(scope, &self.incumbent_context),+ self.callable_at_conversion,+ )}pub fn matches<'s>(@@ -83,6 +81,22 @@ pub struct PreparedWebIdlCallbackInterface {}impl PreparedWebIdlCallbackInterface {+ /// Root a snapshot of callback-interface facts held by a traced owner.+ pub fn new(+ scope: &mut v8::PinScope<'_, '_>,+ callback: v8::Local<'_, v8::Object>,+ relevant_context: v8::Local<'_, v8::Context>,+ incumbent_context: v8::Local<'_, v8::Context>,+ callable_at_conversion: bool,+ ) -> Self {+ Self {+ callback: v8::Global::new(scope, callback),+ relevant_context: v8::Global::new(scope, relevant_context),+ incumbent_context: v8::Global::new(scope, incumbent_context),+ callable_at_conversion,+ }+ }+pub fn callback<'s>(&self, scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Object> {v8::Local::new(scope, &self.callback)}