Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(dom): inherit EventTarget operations from its prototype

ldm04bce04758537
diff --git a/moli-renderer-v8/src/context_bootstrap/constructors/core.rs b/moli-renderer-v8/src/context_bootstrap/constructors/core.rs
index 3131f0fdc..f1e06ff12 100644
--- a/moli-renderer-v8/src/context_bootstrap/constructors/core.rs
+++ b/moli-renderer-v8/src/context_bootstrap/constructors/core.rs
@@ -1,4 +1,4 @@
-use super::super::media_queries::install_simple_event_target_methods;
+use super::super::media_queries::initialize_simple_event_target;
use super::*;
pub(in crate::context_bootstrap) fn event_target_constructor_callback<'s>(
@@ -14,7 +14,7 @@ pub(in crate::context_bootstrap) fn event_target_constructor_callback<'s>(
return;
}
let target = args.this();
- install_simple_event_target_methods(scope, target);
+ initialize_simple_event_target(scope, target);
rv.set(target.into());
}
diff --git a/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs b/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs
index 328dd95c4..19181224a 100644
--- a/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs
+++ b/moli-renderer-v8/src/context_bootstrap/file_api/file_reader/state.rs
@@ -162,6 +162,9 @@ pub(in crate::context_bootstrap::file_api::file_reader) fn initialize_file_reade
FileReaderObjectDeclaration::default()
.initialize(scope, reader)
.expect("FileReader declaration should initialize");
+ crate::context_bootstrap::media_queries::bind_simple_event_target_dispatch_identity(
+ scope, reader, reader,
+ );
}
pub(in crate::context_bootstrap::file_api::file_reader) fn file_reader_ready_state<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries.rs b/moli-renderer-v8/src/context_bootstrap/media_queries.rs
index 73ac3159f..46822e9ae 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries.rs
@@ -11,9 +11,10 @@ pub(super) use self::evaluation::{
pub(in crate::context_bootstrap) use self::events::dispatch_media_query_list_event;
pub(crate) use self::events::{
SimpleObjectEventListenerInspectorSnapshot, SimpleObjectEventListenerSnapshot,
- dispatch_simple_event_target_event, dispatch_simple_event_target_event_collecting_errors,
- initialize_simple_event_target, install_simple_event_target_handlers,
- install_simple_event_target_methods, invoke_simple_event_listener, is_simple_event_target,
+ bind_simple_event_target_dispatch_identity, dispatch_simple_event_target_event,
+ dispatch_simple_event_target_event_collecting_errors, initialize_simple_event_target,
+ install_simple_event_target_handlers, install_simple_event_target_methods,
+ invoke_simple_event_listener, is_simple_event_target,
simple_event_target_add_event_listener_callback, simple_event_target_dispatch_event_callback,
simple_event_target_handler_getter_callback, simple_event_target_handler_setter_callback,
simple_event_target_inspector_listener_snapshots,
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
index d128e1130..b5e4bcda1 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
@@ -13,9 +13,10 @@ pub(in crate::context_bootstrap) use media_query_list::{
};
pub(crate) use simple_event_target::{
SimpleObjectEventListenerInspectorSnapshot, SimpleObjectEventListenerSnapshot,
- dispatch_simple_event_target_event, dispatch_simple_event_target_event_collecting_errors,
- initialize_simple_event_target, install_simple_event_target_handlers,
- install_simple_event_target_methods, invoke_simple_event_listener, is_simple_event_target,
+ bind_simple_event_target_dispatch_identity, dispatch_simple_event_target_event,
+ dispatch_simple_event_target_event_collecting_errors, initialize_simple_event_target,
+ install_simple_event_target_handlers, install_simple_event_target_methods,
+ invoke_simple_event_listener, is_simple_event_target,
simple_event_target_add_event_listener_callback, simple_event_target_dispatch_event_callback,
simple_event_target_handler_getter_callback, simple_event_target_handler_setter_callback,
simple_event_target_inspector_listener_snapshots,
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs
index cd26f66db..a4743c728 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target.rs
@@ -33,5 +33,8 @@ pub(crate) use listeners::{
simple_object_event_target_remove_listener,
simple_object_event_target_remove_listener_for_target,
};
-pub(crate) use state::{initialize_simple_event_target, is_simple_event_target};
+pub(crate) use state::{
+ bind_simple_event_target_dispatch_identity, initialize_simple_event_target,
+ is_simple_event_target,
+};
use state::{simple_event_target_receiver, simple_object_event_listener_registry};
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs
index bea948728..0ddaaf281 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/state.rs
@@ -2,6 +2,17 @@ use super::*;
use crate::context_bootstrap::shared_event_targets::shared_target_owner;
use crate::util::{get_private_object, new_null_prototype_object, set_private_value};
+const DISPATCH_IDENTITY_SLOT: &str = "__moliSimpleEventTargetDispatchIdentity";
+
+pub(crate) fn bind_simple_event_target_dispatch_identity<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ target: v8::Local<'s, v8::Object>,
+ identity: v8::Local<'s, v8::Object>,
+) {
+ let target = moli_webapi_declare::web_api_object_target(scope, target).unwrap_or(target);
+ set_private_value(scope, target, DISPATCH_IDENTITY_SLOT, identity.into());
+}
+
pub(crate) fn initialize_simple_event_target<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
@@ -31,12 +42,15 @@ pub(super) fn simple_event_target_receiver<'s>(
) -> Option<v8::Local<'s, v8::Object>> {
// Resolve registered native Proxies only for the simple-target branch.
// DOM and Window targets keep their existing receiver resolution.
- let target = if target.is_proxy() {
+ let native_target = if target.is_proxy() {
moli_webapi_declare::web_api_object_target(scope, target)?
} else {
target
};
- simple_object_event_listener_registry(scope, target).map(|_| target)
+ simple_object_event_listener_registry(scope, native_target)?;
+ // Native producers can retain a fixed public identity independently of
+ // listener storage. Other native aliases dispatch on their own wrapper.
+ Some(get_private_object(scope, native_target, DISPATCH_IDENTITY_SLOT).unwrap_or(target))
}
pub(super) fn simple_object_event_listener_registry<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
index cc605b1ec..4b93b1169 100644
--- a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
+++ b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
@@ -27,6 +27,9 @@ pub(super) fn shared_target_owner<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
) -> v8::Local<'s, v8::Object> {
+ // Native aliases share the backing registry while dispatch keeps the
+ // original wrapper for callback this and Event.target.
+ let target = moli_webapi_declare::web_api_object_target(scope, target).unwrap_or(target);
get_private_object(scope, target, OWNER).unwrap_or(target)
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs
new file mode 100644
index 000000000..6720e8925
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs
@@ -0,0 +1,77 @@
+use super::*;
+
+#[test]
+fn event_target_prototype_methods_preserve_native_state_and_realm_semantics() {
+ let mut vm = new_parsed_test_vm(
+ "https://event-target-prototype.test/",
+ "<!doctype html><iframe id=child></iframe>",
+ );
+ let result = vm
+ .eval(include_str!(
+ "../../../../tests/fixtures/event-target-prototype.js"
+ ))
+ .expect("EventTarget prototype matrix should complete");
+ assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "158");
+ assert_eq!(
+ result,
+ "true",
+ "{}",
+ vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")
+ .unwrap(),
+ );
+}
+
+#[test]
+fn event_target_prototype_methods_accept_registered_native_proxies() {
+ let mut vm = new_storage_html_test_vm("https://event-target-native-proxy.test/");
+ vm.eval(
+ r#"
+ globalThis.nativeTarget = new EventTarget();
+ globalThis.nativeTargetTraps = 0;
+ globalThis.nativeTargetProxy = new Proxy(nativeTarget, {
+ get() {nativeTargetTraps++; throw new Error('get trap');},
+ getPrototypeOf() {nativeTargetTraps++; throw new Error('prototype trap');}
+ });
+ true;
+ "#,
+ )
+ .unwrap();
+ 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, "nativeTargetProxy").unwrap();
+ let value = global.get(scope, key.into()).unwrap();
+ let proxy = v8::Local::<v8::Proxy>::try_from(value).unwrap();
+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();
+ assert!(crate::web_api_interfaces::EventTarget::is_instance(
+ scope,
+ proxy.into()
+ ));
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!(
+ vm.eval(
+ r#"(() => {
+ const {addEventListener: add, removeEventListener: remove, dispatchEvent: dispatch} = EventTarget.prototype;
+ let calls = 0;
+ function listener(event) {
+ if (this === nativeTargetProxy && event.target === nativeTargetProxy && event.currentTarget === nativeTargetProxy) calls++;
+ }
+ add.call(nativeTargetProxy, 'x', listener);
+ if (!dispatch.call(nativeTargetProxy, new Event('x')) || calls !== 1) return false;
+ remove.call(nativeTargetProxy, 'x', listener);
+ dispatch.call(nativeTargetProxy, new Event('x'));
+ if (calls !== 1 || nativeTargetTraps !== 0) return false;
+ const author = new Proxy(nativeTargetProxy, {});
+ let conversions = 0;
+ const type = {toString() {conversions++; return 'x';}};
+ for (const call of [() => add.call(author, type, null), () => remove.call(author, type, null), () => dispatch.call(author, new Event('x'))]) {
+ try { call(); return false; } catch (error) { if (!(error instanceof TypeError)) return false; }
+ }
+ return conversions === 0 && nativeTargetTraps === 0;
+ })()"#,
+ )
+ .unwrap(),
+ "true",
+ );
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
index ae5fdfaf6..679f7204c 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
@@ -85,4 +85,5 @@ mod video_codec_support;
mod event_prototype_attributes;
+mod event_target_prototype;
mod named_node_map_receivers;
diff --git a/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rs b/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rs
new file mode 100644
index 000000000..0c0ff090e
--- /dev/null
+++ b/moli-renderer-v8/src/worker/thread/tests/event_target_prototype.rs
@@ -0,0 +1,16 @@
+use super::*;
+
+#[tokio::test]
+async fn worker_event_target_prototype_methods_preserve_native_state() {
+ ensure_v8();
+ let probe = include_str!("../../../../tests/fixtures/event-target-prototype.js");
+ let mut handle = spawn_worker(
+ format!("{probe}\npostMessage(__uiEventResults); close();"),
+ "https://event-target-prototype.test/worker.js".into(),
+ );
+ let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
+ let result: serde_json::Value = serde_json::from_str(&expect_post_json(message)).unwrap();
+ assert_eq!(result["complete"], true, "{result}");
+ assert_eq!(result["total"], 56, "{result}");
+ assert_eq!(result["passed"], result["total"], "{result}");
+}
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index 8de684e76..23219eb47 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -1,6 +1,7 @@
mod abort_signal_events;
mod callback_execution;
mod error_reporting_guard;
+mod event_target_prototype;
mod text_codecs;
use std::pin::pin;
use std::sync::Arc;
diff --git a/moli-renderer-v8/tests/fixtures/event-target-prototype.js b/moli-renderer-v8/tests/fixtures/event-target-prototype.js
new file mode 100644
index 000000000..e4cc364f1
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/event-target-prototype.js
@@ -0,0 +1,217 @@
+(() => {
+ const own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+ const typeError = (body, realm) => {
+ try { body(); return false; } catch (error) { return error instanceof realm.TypeError; }
+ };
+ globalThis.eventTargetPrototypeProbe = (realm = globalThis, peers = [['self', realm]]) => {
+ const rows = [], observations = {};
+ const check = (name, body) => {
+ try { rows.push({name, passed: body() === true}); }
+ catch (error) { rows.push({name, passed: false, error: String(error)}); }
+ };
+ const C = realm.EventTarget, prototype = C.prototype;
+ const names = ['addEventListener', 'removeEventListener', 'dispatchEvent'];
+ const descriptors = Object.fromEntries(names.map(name => [name, Object.getOwnPropertyDescriptor(prototype, name)]));
+ const add = prototype.addEventListener, remove = prototype.removeEventListener, dispatch = prototype.dispatchEvent;
+ const event = type => new realm.Event(type, {cancelable: true});
+ const make = () => new C();
+ for (const [name, length] of [['addEventListener', 2], ['removeEventListener', 2], ['dispatchEvent', 1]]) {
+ check(`${name} prototype descriptor`, () => {
+ const d = descriptors[name];
+ return d.writable && d.enumerable && d.configurable && d.value.name === name &&
+ d.value.length === length && Object.getPrototypeOf(d.value) === realm.Function.prototype;
+ });
+ check(`${name} is inherited with canonical identity`, () => {
+ const a = make(), b = make();
+ return !own(a, name) && !own(b, name) && a[name] === descriptors[name].value && a[name] === b[name];
+ });
+ check(`${name} follows author prototype replacement`, () => {
+ const before = make(), replacement = () => 'author';
+ try {
+ Object.defineProperty(prototype, name, {...descriptors[name], value: replacement});
+ const after = make();
+ return before[name] === replacement && after[name] === replacement && !own(after, name);
+ } finally { Object.defineProperty(prototype, name, descriptors[name]); }
+ });
+ check(`${name} deletion does not materialize own methods`, () => {
+ try {
+ delete prototype[name];
+ const target = make();
+ let calls = 0; const callback = () => {calls++;};
+ add.call(target, 'x', callback); dispatch.call(target, event('x')); remove.call(target, 'x', callback);
+ return !(name in target) && !own(target, name) && calls === 1;
+ } finally { Object.defineProperty(prototype, name, descriptors[name]); }
+ });
+ }
+ check('constructor requirements and ignored arguments', () => {
+ let conversions = 0;
+ const ignored = {toString() {conversions++; throw 1;}};
+ return C.length === 0 && typeError(() => C(), realm) &&
+ new C(ignored) instanceof C && conversions === 0;
+ });
+ check('native state is private and per-instance', () => {
+ const a = make(), b = make(); let calls = 0;
+ add.call(a, 'x', () => {calls++;});
+ dispatch.call(b, event('x')); dispatch.call(a, event('x'));
+ return Reflect.ownKeys(a).length === 0 && Reflect.ownKeys(b).length === 0 && calls === 1;
+ });
+ check('listener call has target identity and native event state', () => {
+ const target = make(), e = event('x'); let observed = false;
+ add.call(target, 'x', function(received) {
+ observed = received === e && this === target && e.target === target &&
+ e.currentTarget === target && e.eventPhase === 2 && e.composedPath().length === 1 &&
+ e.composedPath()[0] === target && !e.isTrusted;
+ });
+ const result = dispatch.call(target, e);
+ return observed && result && e.target === target && e.currentTarget === null &&
+ e.eventPhase === 0 && e.composedPath().length === 0;
+ });
+ check('frozen target retains mutable native listener state', () => {
+ const target = Object.freeze(make()); let calls = 0;
+ const callback = () => {calls++;};
+ add.call(target, 'x', callback); dispatch.call(target, event('x'));
+ remove.call(target, 'x', callback); dispatch.call(target, event('x'));
+ return calls === 1 && Reflect.ownKeys(target).length === 0;
+ });
+ check('prototype removal preserves native receiver and state', () => {
+ const target = make(); Object.setPrototypeOf(target, null); let calls = 0;
+ add.call(target, 'x', function(e) {if (e.target === target && this === target) calls++;});
+ return dispatch.call(target, event('x')) && calls === 1;
+ });
+ check('subclass overrides are not shadowed by native own methods', () => {
+ let registrations = 0, calls = 0;
+ class Derived extends C {
+ addEventListener(...args) {registrations++; return add.apply(this, args);}
+ }
+ const target = new Derived();
+ target.addEventListener('x', () => {calls++;});
+ return target instanceof Derived && !own(target, 'addEventListener') &&
+ target.dispatchEvent(event('x')) && registrations === 1 && calls === 1;
+ });
+ check('custom newTarget prototype preserves branding and listener state', () => {
+ function NewTarget() {}
+ const custom = {marker: 1}; NewTarget.prototype = custom;
+ const target = Reflect.construct(C, [], NewTarget); let calls = 0;
+ add.call(target, 'x', function(e) {if (this === target && e.target === target) calls++;});
+ dispatch.call(target, event('x'));
+ return Object.getPrototypeOf(target) === custom && target.marker === 1 &&
+ names.every(name => !own(target, name)) && calls === 1;
+ });
+ check('constructor does not consult prototype method getters', () => {
+ let reads = 0;
+ try {
+ for (const name of names) Object.defineProperty(prototype, name, {configurable: true, get() {reads++; throw 1;}});
+ const target = make(); let calls = 0;
+ add.call(target, 'x', () => {calls++;}); dispatch.call(target, event('x'));
+ return reads === 0 && calls === 1 && names.every(name => !own(target, name));
+ } finally { for (const name of names) Object.defineProperty(prototype, name, descriptors[name]); }
+ });
+ check('once and duplicate identity are preserved', () => {
+ const target = make(); let calls = 0; const callback = () => {calls++;};
+ add.call(target, 'x', callback, {once: true}); add.call(target, 'x', callback, {once: false});
+ dispatch.call(target, event('x')); dispatch.call(target, event('x'));
+ return calls === 1;
+ });
+ check('capture order and matching removal are preserved', () => {
+ const target = make(), trace = [], capture = () => trace.push('capture');
+ add.call(target, 'x', () => trace.push('bubble')); add.call(target, 'x', capture, true);
+ dispatch.call(target, event('x')); remove.call(target, 'x', capture, true);
+ dispatch.call(target, event('x'));
+ observations.captureOrder = trace.join(',');
+ return observations.captureOrder === 'capture,bubble,bubble';
+ });
+ check('cancellation and passive listeners are preserved', () => {
+ const a = make(), b = make(), ea = event('x'), eb = event('x');
+ add.call(a, 'x', e => e.preventDefault());
+ add.call(b, 'x', e => e.preventDefault(), {passive: true});
+ return dispatch.call(a, ea) === false && ea.defaultPrevented &&
+ dispatch.call(b, eb) === true && !eb.defaultPrevented;
+ });
+ check('AbortSignal removes listeners from native state', () => {
+ const target = make(), controller = new realm.AbortController(); let calls = 0;
+ add.call(target, 'x', () => {calls++;}, {signal: controller.signal});
+ dispatch.call(target, event('x')); controller.abort(); dispatch.call(target, event('x'));
+ return calls === 1;
+ });
+ check('callback interface lookup remains dynamic', () => {
+ const target = make(), trace = [], listener = {handleEvent() {if (this === listener) trace.push('first');}};
+ add.call(target, 'x', listener); dispatch.call(target, event('x'));
+ listener.handleEvent = function() {if (this === listener) trace.push('second');};
+ dispatch.call(target, event('x')); remove.call(target, 'x', listener); dispatch.call(target, event('x'));
+ return trace.join(',') === 'first,second';
+ });
+ check('listener Proxy is callable without making a Proxy receiver valid', () => {
+ const target = make(); let calls = 0;
+ const callback = new Proxy(() => {}, {apply(_fn, receiver, args) {
+ if (receiver === target && args[0].target === target) calls++;
+ }});
+ add.call(target, 'x', callback); dispatch.call(target, event('x'));
+ return calls === 1;
+ });
+ check('stopImmediatePropagation stops later target listeners', () => {
+ const target = make(), trace = [];
+ add.call(target, 'x', e => {trace.push('first'); e.stopImmediatePropagation();});
+ add.call(target, 'x', () => trace.push('second')); dispatch.call(target, event('x'));
+ return trace.join(',') === 'first';
+ });
+ check('listener removal during dispatch preserves live registration state', () => {
+ const target = make(), trace = [], later = () => trace.push('later');
+ add.call(target, 'x', () => {trace.push('first'); remove.call(target, 'x', later);});
+ add.call(target, 'x', later); dispatch.call(target, event('x'));
+ return trace.join(',') === 'first';
+ });
+ for (const name of names) {
+ check(`${name} enforces required argument count in callee realm`, () =>
+ typeError(() => descriptors[name].value.call(make()), realm));
+ }
+ for (const [label, receiver] of [['null', null], ['undefined', undefined]]) {
+ check(`${label} receiver maps to the callee global EventTarget`, () => {
+ const type = 'event-target-global-' + label;
+ let calls = 0;
+ const callback = function(e) {if (this === realm && e.target === realm) calls++;};
+ try {
+ add.call(receiver, type, callback);
+ const result = dispatch.call(receiver, new realm.Event(type));
+ remove.call(receiver, type, callback);
+ dispatch.call(receiver, new realm.Event(type));
+ return result === true && calls === 1;
+ } finally { remove.call(realm, type, callback); }
+ });
+ }
+ for (const [ownerName, owner] of peers) {
+ const target = new owner.EventTarget(); let traps = 0;
+ const proxy = new Proxy(target, {get() {traps++;}, getPrototypeOf() {traps++;}, has() {traps++;}});
+ const revoked = Proxy.revocable(target, {}); revoked.revoke();
+ const invalid = [['plain', {}], ['prototype', owner.EventTarget.prototype],
+ ['forged', Object.create(owner.EventTarget.prototype)], ['inherited instance', Object.create(target)],
+ ['author Proxy', proxy], ['revoked Proxy', revoked.proxy], ['number', 1]];
+ for (const [label, receiver] of invalid) {
+ for (const name of names) {
+ check(`${ownerName} ${name} rejects ${label} before conversion in callee realm`, () => {
+ let conversions = 0;
+ const type = {toString() {conversions++; return 'x';}};
+ const args = name === 'dispatchEvent' ? [event('x')] : [type, null];
+ return typeError(() => descriptors[name].value.call(receiver, ...args), realm) && conversions === 0;
+ });
+ }
+ }
+ check(`${ownerName} receiver brand check does not execute traps`, () => traps === 0);
+ check(`${ownerName} borrowed methods preserve target identity and dispatch`, () => {
+ const e = new owner.Event('borrowed', {cancelable: true}); let calls = 0;
+ function listener(received) {if (this === target && received === e && e.target === target) calls++;}
+ add.call(target, 'borrowed', listener); const result = dispatch.call(target, e);
+ remove.call(target, 'borrowed', listener); dispatch.call(target, new owner.Event('borrowed'));
+ return result && calls === 1;
+ });
+ }
+ return {complete: true, total: rows.length, passed: rows.filter(row => row.passed).length, rows, observations};
+ };
+ const realms = typeof document === 'undefined' ? [['worker', globalThis]] :
+ [['top', globalThis], ['child', document.querySelector('#child').contentWindow]];
+ const probes = realms.map(([name, realm]) => [name, eventTargetPrototypeProbe(realm, realms)]);
+ const rows = probes.flatMap(([name, probe]) => probe.rows.map(row => ({...row, name: `${name}: ${row.name}`})));
+ const observations = Object.fromEntries(probes.map(([name, probe]) => [name, probe.observations]));
+ globalThis.__uiEventResults = {complete: true, total: rows.length,
+ passed: rows.filter(row => row.passed).length, rows, observations};
+ return rows.every(row => row.passed);
+})()