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): project events across Realms of the same Window
ldm0e1f2169f6852
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rsindex cd55429f3..8891569b5 100644--- a/moli-renderer-v8/src/context_bootstrap.rs+++ b/moli-renderer-v8/src/context_bootstrap.rs@@ -280,7 +280,7 @@ pub(crate) use self::events::{event_is_mouse_event, event_private_value, initialize_event_object, initialize_event_wrapper,mark_agent_submit_event, mark_event_trusted, new_event_state, new_event_wrapper,set_event_composed_path, set_event_internal_flag, set_event_private_value, set_event_trusted,- submit_event_submitter_value,+ submit_event_submitter_value, window_event_callback_values,};pub(crate) use self::file_api::{DataTransferStringCallbackTask, DataTransferStringCallbackTaskEffect,diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rsindex d09f6f0ee..20029ef31 100644--- a/moli-renderer-v8/src/context_bootstrap/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/events.rs@@ -497,7 +497,7 @@ pub(super) fn track_event_track_getter_function<'s>(pub(crate) use wrappers::{event_attribute, event_bool_attribute, event_private_value, initialize_event_wrapper,- new_event_state, new_event_wrapper, set_event_private_value,+ new_event_state, new_event_wrapper, set_event_private_value, window_event_callback_values,};pub(in crate::context_bootstrap) use message::message_event_init_callback;diff --git a/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rsindex 917d2caeb..234413262 100644--- a/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs@@ -153,6 +153,38 @@ pub(crate) fn new_event_wrapper<'s>(Some(wrapper)}+/// Project another Realm of the same live Window through the existing weak+/// Event cache. The dispatch state stays shared and same-world identity stays+/// intact. Foreign-Window callbacks retain their existing behavior: resolving+/// an isolated world of another target Window requires an alias/world resolver+/// that this path does not yet provide.+pub(crate) fn window_event_callback_values<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Value>,+ event: v8::Local<'s, v8::Object>,+ context: v8::Local<'s, v8::Context>,+) -> Option<(v8::Local<'s, v8::Value>, v8::Local<'s, v8::Object>)> {+ let Ok(target) = v8::Local::<v8::Object>::try_from(receiver) else {+ return Some((receiver, event));+ };+ let Some(target) =+ super::super::shared_event_targets::window_target_in_realm(scope, target, context)+ else {+ return Some((receiver, event));+ };+ if world_wrappers::belongs_to_world(scope, event, context) {+ return Some((target.into(), event));+ }+ let backing = event_backing(scope, event);+ let wrapper = if let Some(wrapper) = world_wrappers::get(scope, backing, context) {+ wrapper+ } else {+ let scope = &mut v8::ContextScope::new(scope, context);+ new_event_wrapper(scope, backing)?+ };+ Some((target.into(), wrapper))+}+fn bind_attribute<'s>(scope: &mut v8::PinScope<'s, '_>,getters: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rsindex b048e80e3..2a696f2a9 100644--- a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs+++ b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs@@ -60,6 +60,9 @@ pub(super) fn target_in_realm<'s>(target: v8::Local<'s, v8::Object>,context: v8::Local<'s, v8::Context>,) -> v8::Local<'s, v8::Object> {+ if let Some(window) = window_target_in_realm(scope, target, context) {+ return window;+ }let Some(owner) = get_private_object(scope, target, OWNER) else {return target;};@@ -85,6 +88,37 @@ pub(super) fn target_in_realm<'s>(.unwrap_or(target)}+/// Only another Realm of this exact live Window can replace a real global.+/// Cross-Document aliases keep their existing behavior. In particular, the+/// current parent/top alias path has no target-Window isolated-world resolver;+/// this helper must not manufacture one by returning the callback global.+pub(super) fn window_target_in_realm<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+ context: v8::Local<'s, v8::Context>,+) -> Option<v8::Local<'s, v8::Object>> {+ let target_context = target.get_creation_context(scope)?;+ if !target.strict_equals(target_context.global(scope).into()) {+ return None;+ }+ let host_ptr = crate::util::context_host_ptr_from_context_slot(target_context)?;+ if crate::util::context_host_ptr_from_context_slot(context) != Some(host_ptr) {+ return None;+ }+ let host = unsafe { &*host_ptr };+ let target_identity =+ host.window_execution_context_identity_for_access_check(target_context)?;+ let destination_identity = host.window_execution_context_identity_for_access_check(context)?;+ if target_identity.owner() != destination_identity.owner()+ || target_identity.dispatch_scope() != destination_identity.dispatch_scope()+ || !host.window_execution_context_identity_is_current(target_identity)+ || !host.window_execution_context_identity_is_current(destination_identity)+ {+ return None;+ }+ Some(context.global(scope))+}+pub(super) fn install_handlers<'s>(scope: &mut v8::PinScope<'s, '_>,target: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/host/events.rs b/moli-renderer-v8/src/host/events.rsindex cc42aa084..a938f4059 100644--- a/moli-renderer-v8/src/host/events.rs+++ b/moli-renderer-v8/src/host/events.rs@@ -155,6 +155,23 @@ pub(crate) fn invoke_prepared_event_callback<'s>(arguments: &[v8::Local<'s, v8::Value>],) -> Option<v8::Global<v8::Value>> {let receiver = event_target_receiver(scope, host_ptr, target, event);+ let has_event_argument = arguments.len() == 1 && arguments[0].strict_equals(event.into());+ let (receiver, event) = if matches!(+ target,+ EventTargetHandle::Window | EventTargetHandle::ChildWindow(_)+ ) {+ let context = callback.relevant_context(scope);+ crate::context_bootstrap::window_event_callback_values(scope, receiver, event, context)?+ } else {+ (receiver, event)+ };+ // Window.onerror's five arguments are JS values, not an Event conversion.+ let event_arguments = [event.into()];+ let arguments = if has_event_argument {+ &event_arguments+ } else {+ arguments+ };let _dom_debugger_pause = unsafe { &*host_ptr }.schedule_dom_debugger_event_listener_pause_for_target(event_type, target);invoke_prepared_event_callback_with_receiver(diff --git a/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs b/moli-renderer-v8/src/script_vm/tests/window_execution_context.rsindex 43ee7ba06..52fc6a15b 100644--- a/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs+++ b/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs@@ -574,3 +574,287 @@ fn borrowed_fetch_uses_receiver_realm_and_keeps_reaction_realm_independent() {.abort_subresource_fetch(keepalive_id));}++#[tokio::test(flavor = "current_thread")]+async fn window_event_callbacks_project_same_window_realms_in_both_layout_modes() {+ for policy in [+ moli_page_types::LayoutPolicy::Mock,+ moli_page_types::LayoutPolicy::OnDemand,+ ] {+ let mut vm = new_storage_test_vm("https://window-event-realms.test/");+ vm.set_layout_policy(policy);+ vm.eval(+ r#"+ globalThis.defaultFacts = [];+ globalThis.original = null;+ addEventListener('window-realm-probe', function(event) {+ defaultFacts.push([+ this === window, event === original, event instanceof Event,+ event.target === window, event.currentTarget === window,+ event.composedPath()[0] === window, window.event === event+ ]);+ });+ 'ready'+ "#,+ )+ .unwrap();+ let isolated = vm+ .create_isolated_world("window-event-listeners", false)+ .unwrap();+ vm.eval_in_isolated_context(+ isolated,+ r#"+ globalThis.isolatedFacts = [];+ globalThis.savedEvent = null;+ addEventListener('window-realm-probe', function(event) {+ savedEvent = event;+ isolatedFacts.push([+ this === window, event instanceof Event,+ event.target === window, event.currentTarget === window,+ event.composedPath()[0] === window, window.event === event,+ event.defaultOnly === undefined+ ]);+ event.preventDefault();+ });+ const objectListener = {+ handleEvent(event) {+ isolatedFacts.push([+ this === objectListener, event === savedEvent,+ event.defaultPrevented, event.currentTarget === window+ ]);+ }+ };+ addEventListener('window-realm-probe', objectListener);+ 'ready'+ "#,+ )+ .unwrap();+ let builds = vm.layout_pass_observability_for_test().1;+ assert_eq!(+ vm.eval(+ r#"+ original = new Event('window-realm-probe', {cancelable: true});+ original.defaultOnly = 'default';+ JSON.stringify([+ dispatchEvent(original), original.defaultPrevented,+ original.currentTarget === null, original.composedPath().length === 0+ ])+ "#+ )+ .unwrap(),+ "[false,true,true,true]",+ "{policy:?}"+ );+ assert_eq!(+ vm.eval("JSON.stringify(defaultFacts)").unwrap(),+ "[[true,true,true,true,true,true,true]]",+ "{policy:?}"+ );+ assert_eq!(+ vm.eval_in_isolated_context(isolated, "JSON.stringify(isolatedFacts)")+ .unwrap(),+ "[[true,true,true,true,true,true,true],[true,true,true,true]]",+ "{policy:?}"+ );+ assert_eq!(vm.eval_in_isolated_context(isolated,+ "JSON.stringify([savedEvent.currentTarget === null, savedEvent.composedPath().length === 0, savedEvent.defaultPrevented])"+ ).unwrap(), "[true,true,true]", "{policy:?}");+ assert_eq!(+ vm.layout_pass_observability_for_test().1,+ builds,+ "event Realm conversion must not request layout: {policy:?}"+ );++ vm.destroy_isolated_world_context(isolated);+ assert_eq!(vm.eval(r#"+ original = new Event('window-realm-probe', {cancelable: true});+ JSON.stringify([dispatchEvent(original), original.defaultPrevented, defaultFacts.length])+ "#).unwrap(), "[true,false,2]", "retired isolated listeners: {policy:?}");+ assert_eq!(+ vm.layout_pass_observability_for_test().1,+ builds,+ "Realm retirement and dispatch must not request layout: {policy:?}"+ );+ }+}++#[tokio::test(flavor = "current_thread")]+async fn borrowed_default_world_window_callback_keeps_target_window_and_event_identity() {+ for policy in [+ moli_page_types::LayoutPolicy::Mock,+ moli_page_types::LayoutPolicy::OnDemand,+ ] {+ let mut vm = new_storage_test_vm("https://borrowed-window-event.test/");+ vm.set_layout_policy(policy);+ vm.eval(+ r#"+ globalThis.frame = document.createElement('iframe');+ (document.body || document.documentElement || document).appendChild(frame);+ 'ready'+ "#,+ )+ .unwrap();+ materialize_single_child_default_realm_for_test(&mut vm, "borrowed Window callback");+ vm.eval(+ r#"+ globalThis.borrowedFacts = [];+ globalThis.original = null;+ const child = frame.contentWindow;+ addEventListener('borrowed-window-probe', child.Function('event', `+ parent.borrowedFacts.push([+ this === parent, this !== window, event === parent.original,+ event.target === parent, event.currentTarget === parent,+ event.composedPath()[0] === parent,+ event instanceof parent.Event, !(event instanceof Event),+ window.event === event+ ]);+ `));+ 'ready'+ "#,+ )+ .unwrap();+ let builds = vm.layout_pass_observability_for_test().1;+ assert_eq!(+ vm.eval(+ r#"+ original = new Event('borrowed-window-probe');+ dispatchEvent(original);+ JSON.stringify(borrowedFacts)+ "#+ )+ .unwrap(),+ "[[true,true,true,true,true,true,true,true,true]]",+ "{policy:?}"+ );+ assert_eq!(+ vm.layout_pass_observability_for_test().1,+ builds,+ "borrowed callback must not obtain geometry to resolve its Window: {policy:?}"+ );+ }+}++#[tokio::test(flavor = "current_thread")]+async fn native_window_error_events_preserve_type_and_onerror_arguments_in_isolated_worlds() {+ for policy in [+ moli_page_types::LayoutPolicy::Mock,+ moli_page_types::LayoutPolicy::OnDemand,+ ] {+ let mut vm = new_storage_test_vm("https://window-error-event-realms.test/");+ vm.set_layout_policy(policy);+ vm.eval("globalThis.defaultErrorEvent = null;").unwrap();+ let isolated = vm+ .create_isolated_world("window-error-listeners", false)+ .unwrap();+ vm.eval_in_isolated_context(+ isolated,+ r#"+ globalThis.errorFacts = {listener: [], handler: []};+ globalThis.savedErrorEvent = null;+ globalThis.handlerEvent = null;+ globalThis.handlerError = null;+ globalThis.handlerEventIsErrorEvent = false;+ globalThis.onErrorCallback = function(message, source, line, column, error) {+ handlerEvent = window.event;+ handlerError = error;+ handlerEventIsErrorEvent = handlerEvent instanceof ErrorEvent;+ errorFacts.handler.push([+ this === window, arguments.length === 5,+ message.includes('native-window-error'), typeof source === 'string',+ Number.isFinite(line), Number.isFinite(column),+ error === handlerEvent.error, window.event === handlerEvent+ ]);+ return true;+ };+ "#,+ )+ .unwrap();+ let context_ptr = {+ let world = vm+ .page_isolated_world_contexts+ .context(isolated)+ .expect("isolated error listener world should be tracked");+ &world.context as *const _+ };+ let onerror_callback = vm+ .with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _host_ptr| {+ let global = scope.get_current_context().global(scope);+ let key = v8::String::new(scope, "onErrorCallback").unwrap();+ let callback = global.get(scope, key.into()).unwrap();+ let callback = v8::Local::<v8::Function>::try_from(callback)+ .expect("isolated onerror callback should be callable");+ Ok(v8::Global::new(scope, callback))+ })+ .unwrap();+ // Top-level onerror is stored on the target Window's global. Install+ // the borrowed function through that Window's public setter while+ // preserving the function's isolated relevant Realm.+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _host_ptr| {+ let global = scope.get_current_context().global(scope);+ let key = v8::String::new(scope, "onerror").unwrap();+ let callback = v8::Local::new(scope, &onerror_callback);+ assert_eq!(global.set(scope, key.into(), callback.into()), Some(true));+ let installed = global.get(scope, key.into()).unwrap();+ assert!(+ installed.strict_equals(callback.into()),+ "the target Window must expose the exact borrowed onerror callback"+ );+ Ok(())+ })+ .unwrap();+ drop(onerror_callback);+ vm.eval("addEventListener('error', event => { defaultErrorEvent = event; });")+ .unwrap();+ vm.eval_in_isolated_context(+ isolated,+ r#"+ addEventListener('error', function(event) {+ savedErrorEvent = event;+ errorFacts.listener.push([+ this === window, event instanceof ErrorEvent, event instanceof Event,+ event.isTrusted, event.target === window, event.currentTarget === window,+ event.composedPath()[0] === window,+ event.error.message === 'native-window-error'+ ]);+ });+ "#,+ )+ .unwrap();+ let builds = vm.layout_pass_observability_for_test().1;+ assert_eq!(+ vm.eval(+ r#"+ reportError(new Error('native-window-error'));+ JSON.stringify([+ defaultErrorEvent instanceof ErrorEvent,+ defaultErrorEvent.isTrusted,+ defaultErrorEvent.defaultPrevented+ ])+ "#,+ )+ .unwrap(),+ "[true,true,true]",+ "{policy:?}"+ );+ assert_eq!(+ vm.eval_in_isolated_context(+ isolated,+ r#"JSON.stringify({+ listener: errorFacts.listener,+ handler: errorFacts.handler,+ handlerEventIsErrorEvent,+ sameEvent: handlerEvent === savedErrorEvent,+ sameError: handlerError === savedErrorEvent.error+ })"#,+ )+ .unwrap(),+ r#"{"listener":[[true,true,true,true,true,true,true,true]],"handler":[[true,true,true,true,true,true,true,true]],"handlerEventIsErrorEvent":true,"sameEvent":true,"sameError":true}"#,+ "native ErrorEvent projection must preserve its subclass and the five onerror arguments: {policy:?}"+ );+ assert_eq!(+ vm.layout_pass_observability_for_test().1,+ builds,+ "native exception reporting must not request layout: {policy:?}"+ );+ }+}