Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(webrtc): implement ICE and data channel event constructors
ldm0fa6daec422d9
diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rsindex 9346b7760..cec46ed2a 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs@@ -61,7 +61,9 @@ use super::super::{offline_audio_context_constructor_callback,},webrtc::{- rtc_ice_candidate_constructor_callback, rtc_peer_connection_constructor_callback,+ rtc_data_channel_event_constructor_callback, rtc_ice_candidate_constructor_callback,+ rtc_peer_connection_constructor_callback,+ rtc_peer_connection_ice_event_constructor_callback,rtc_session_description_constructor_callback,},websocket::{@@ -600,6 +602,16 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(.length(1).build(scope)}+ ConstructorKind::RtcPeerConnectionIceEvent => {+ v8::FunctionTemplate::builder(rtc_peer_connection_ice_event_constructor_callback)+ .length(1)+ .build(scope)+ }+ ConstructorKind::RtcDataChannelEvent => {+ v8::FunctionTemplate::builder(rtc_data_channel_event_constructor_callback)+ .length(2)+ .build(scope)+ }ConstructorKind::Navigator| ConstructorKind::WorkerNavigator| ConstructorKind::Permissionsdiff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rsindex 73659b7a6..2c1ba1669 100644--- a/moli-renderer-v8/src/context_bootstrap/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/events.rs@@ -349,6 +349,7 @@ pub(super) use base::{event_target_getter_function, event_type_getter_function, set_event_dispatch_fields,set_event_initialized,};+pub(in crate::context_bootstrap) use init::parse_event_init;pub(super) use kind::EventSubclassKind;pub(super) use methods::{event_cancel_bubble_getter_function, event_cancel_bubble_setter_function,diff --git a/moli-renderer-v8/src/context_bootstrap/events/init.rs b/moli-renderer-v8/src/context_bootstrap/events/init.rsindex d268a971e..0cc8271ce 100644--- a/moli-renderer-v8/src/context_bootstrap/events/init.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/init.rs@@ -94,10 +94,16 @@ pub(super) fn read_event_init<'s>(scope: &mut v8::PinScope<'s, '_>,args: &v8::FunctionCallbackArguments<'s>,) -> (bool, bool, bool) {- let Some(init) = webidl::optional_object_arg(args, 1) else {- return (false, false, false);+ parse_event_init(scope, webidl::optional_object_arg(args, 1)).unwrap_or((false, false, false))+}++pub(in crate::context_bootstrap) fn parse_event_init<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+) -> Result<(bool, bool, bool), webidl::WebIdlError> {+ let Some(init) = init else {+ return Ok((false, false, false));};webidl::parse_dictionary_object::<EventInitMembers>(scope, init).map(|parsed| (parsed.bubbles, parsed.cancelable, parsed.composed))- .unwrap_or((false, false, false))}diff --git a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs b/moli-renderer-v8/src/context_bootstrap/runtime_state.rsindex 9cd930550..2d2a88a4a 100644--- a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs+++ b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs@@ -1933,6 +1933,8 @@ pub(crate) fn finish_context_bootstrap(("RTCPeerConnection", "RTCPeerConnection"),("RTCIceCandidate", "RTCIceCandidate"),("RTCSessionDescription", "RTCSessionDescription"),+ ("RTCPeerConnectionIceEvent", "RTCPeerConnectionIceEvent"),+ ("RTCDataChannelEvent", "RTCDataChannelEvent"),("RTCRtpReceiver", "RTCRtpReceiver"),("RTCDataChannel", "RTCDataChannel"),("Blob", "Blob"),diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rsindex 32550392d..1822a1e6f 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs@@ -867,6 +867,14 @@ const CONSTRUCTOR_SPECS_AFTER_STREAMS: &[ConstructorSpec] = &[interface: web_api_interfaces::RTCSessionDescription::DESCRIPTOR,kind: ConstructorKind::RtcSessionDescription,},+ ConstructorSpec {+ interface: web_api_interfaces::RTCPeerConnectionIceEvent::DESCRIPTOR,+ kind: ConstructorKind::RtcPeerConnectionIceEvent,+ },+ ConstructorSpec {+ interface: web_api_interfaces::RTCDataChannelEvent::DESCRIPTOR,+ kind: ConstructorKind::RtcDataChannelEvent,+ },ConstructorSpec {interface: web_api_interfaces::RTCRtpReceiver::DESCRIPTOR,kind: ConstructorKind::Illegal,diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rsindex 93db2156a..93a222a1e 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs@@ -90,6 +90,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {RtcPeerConnection,RtcIceCandidate,RtcSessionDescription,+ RtcPeerConnectionIceEvent,+ RtcDataChannelEvent,Navigator,WorkerNavigator,Permissions,diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc.rs b/moli-renderer-v8/src/context_bootstrap/webrtc.rsindex 3392fb8cc..6a08991f6 100644--- a/moli-renderer-v8/src/context_bootstrap/webrtc.rs+++ b/moli-renderer-v8/src/context_bootstrap/webrtc.rs@@ -5,9 +5,13 @@ use crate::util::{use crate::web_api_interfaces;use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};+mod events;mod ice_candidate;mod ice_candidate_parser;mod session_description;+pub(in crate::context_bootstrap) use events::{+ rtc_data_channel_event_constructor_callback, rtc_peer_connection_ice_event_constructor_callback,+};pub(in crate::context_bootstrap) use ice_candidate::rtc_ice_candidate_constructor_callback;pub(in crate::context_bootstrap) use session_description::rtc_session_description_constructor_callback;@@ -203,6 +207,9 @@ pub(in crate::context_bootstrap) fn install_webrtc_template_bindings<'s>() {let prototype = template.prototype_template(scope);match interface_name {+ "RTCPeerConnectionIceEvent" | "RTCDataChannelEvent" => {+ events::install_event_template_bindings(scope, template, interface_name)+ }"RTCIceCandidate" => {ice_candidate::install_ice_candidate_template_bindings(scope, template)}diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/events.rsnew file mode 100644index 000000000..23b2d54df--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/events.rs@@ -0,0 +1,220 @@+use super::{ice_candidate::ice_candidate_receiver_branded, rtc_data_channel_receiver_branded};+use crate::web_api_interfaces;+use crate::{+ context_bootstrap::events::{initialize_event_object_with_type, parse_event_init},+ util::{+ apply_webidl_constructor_prototype_fallback, callback_data_index_value, callback_data_item,+ get_private_value, throw_type_error, v8str,+ },+ webidl::{self, WebIdlConverter},+};+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};++const ICE_EVENT_CANDIDATE_SLOT: &str = "__moliRtcIceEventCandidate";+const ICE_EVENT_URL_SLOT: &str = "__moliRtcIceEventUrl";+const DATA_CHANNEL_EVENT_CHANNEL_SLOT: &str = "__moliRtcDataChannelEventChannel";+const EVENT_MEMBER_SLOTS: &[&str] = &[+ ICE_EVENT_CANDIDATE_SLOT,+ ICE_EVENT_URL_SLOT,+ DATA_CHANNEL_EVENT_CHANNEL_SLOT,+];++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::RTCPeerConnectionIceEvent)]+struct IceEventObjectDeclaration<'scope> {+ #[webapi(data_property, enumerable)]+ composed: bool,+ #[webapi(slot = ICE_EVENT_CANDIDATE_SLOT)]+ candidate: v8::Local<'scope, v8::Value>,+ #[webapi(slot = ICE_EVENT_URL_SLOT)]+ url: v8::Local<'scope, v8::Value>,+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::RTCDataChannelEvent)]+struct DataChannelEventObjectDeclaration<'scope> {+ #[webapi(data_property, enumerable)]+ composed: bool,+ #[webapi(slot = DATA_CHANNEL_EVENT_CHANNEL_SLOT)]+ channel: v8::Local<'scope, v8::Value>,+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::RTCPeerConnectionIceEvent, receiver, enumerable)]+struct IceEventPrototypeDeclaration {+ #[webapi(accessor_property, getter = event_member_getter, data = callback_data_index_value(scope, 0))]+ candidate: (),+ #[webapi(accessor_property, getter = event_member_getter, data = callback_data_index_value(scope, 1))]+ url: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::RTCDataChannelEvent, receiver, enumerable)]+struct DataChannelEventPrototypeDeclaration {+ #[webapi(accessor_property, getter = event_member_getter, data = callback_data_index_value(scope, 2))]+ channel: (),+}++pub(super) fn install_event_template_bindings<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ template: v8::Local<'s, v8::FunctionTemplate>,+ interface_name: &str,+) {+ let prototype = template.prototype_template(scope);+ match interface_name {+ "RTCPeerConnectionIceEvent" => {+ IceEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)+ }+ "RTCDataChannelEvent" => {+ DataChannelEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)+ }+ _ => unreachable!("unsupported WebRTC event interface"),+ }+}++pub(in crate::context_bootstrap) fn rtc_peer_connection_ice_event_constructor_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'s, v8::Value>,+) {+ construct_event(scope, args, rv, false);+}++pub(in crate::context_bootstrap) fn rtc_data_channel_event_constructor_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ rv: v8::ReturnValue<'s, v8::Value>,+) {+ construct_event(scope, args, rv, true);+}++fn construct_event<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+ is_data_channel_event: bool,+) {+ let (name, required_arguments, member) = if is_data_channel_event {+ ("RTCDataChannelEvent", 2, "channel")+ } else {+ ("RTCPeerConnectionIceEvent", 1, "candidate")+ };+ if !args.is_construct_call() || args.length() < required_arguments {+ throw_type_error(+ scope,+ &format!("{name} requires 'new' and {required_arguments} argument(s)."),+ );+ return;+ }+ if args.get(0).is_symbol() {+ throw_type_error(scope, "Cannot convert a Symbol to a DOMString.");+ return;+ }+ // Retain the DOMString in V8 instead of replacing lone UTF-16 surrogates.+ let Some(event_type) = args.get(0).to_string(scope) else {+ return;+ };+ let init = match webidl::dictionary_arg(&args, 1, webidl::Context::argument(name, 2)) {+ Ok(init) => init,+ Err(error) => {+ webidl::throw_error(scope, &error);+ return;+ }+ };+ // Convert inherited EventInit members before the subclass's own members.+ let (bubbles, cancelable, composed) = match parse_event_init(scope, init) {+ Ok(flags) => flags,+ Err(error) => {+ webidl::throw_error(scope, &error);+ return;+ }+ };+ let value = if let Some(init) = init {+ let Some(value) = init.get(scope, v8str(scope, member).into()) else {+ return;+ };+ value+ } else {+ v8::undefined(scope).into()+ };+ let value = if !is_data_channel_event && value.is_null_or_undefined() {+ v8::null(scope).into()+ } else {+ let branded = v8::Local::<v8::Object>::try_from(value)+ .ok()+ .is_some_and(|object| {+ if is_data_channel_event {+ rtc_data_channel_receiver_branded(scope, object)+ } else {+ ice_candidate_receiver_branded(scope, object)+ }+ });+ if !branded {+ throw_type_error(+ scope,+ &format!(+ "{name}.{member} must be a genuine {} object.",+ if is_data_channel_event {+ "RTCDataChannel"+ } else {+ "RTCIceCandidate"+ }+ ),+ );+ return;+ }+ value+ };+ let mut url = v8::null(scope).into();+ if !is_data_channel_event && let Some(init) = init {+ let Some(raw) = init.get(scope, v8str(scope, "url").into()) else {+ return;+ };+ if !raw.is_null_or_undefined() {+ let converted = match webidl::UsvString::convert(+ scope,+ raw,+ webidl::Context::member("RTCPeerConnectionIceEventInit", "url"),+ &Default::default(),+ ) {+ Ok(value) => value.0,+ Err(error) => {+ webidl::throw_error(scope, &error);+ return;+ }+ };+ let Some(converted) = v8::String::new(scope, &converted) else {+ return;+ };+ url = converted.into();+ }+ }+ let event = args.this();+ initialize_event_object_with_type(scope, event, event_type, bubbles, cancelable);+ let initialized = if is_data_channel_event {+ DataChannelEventObjectDeclaration::new(composed, value).initialize(scope, event)+ } else {+ IceEventObjectDeclaration::new(composed, value, url).initialize(scope, event)+ };+ if initialized.is_err() {+ return;+ }+ apply_webidl_constructor_prototype_fallback(scope, event, args.new_target(), name);+ rv.set(event.into());+}++fn event_member_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ let Some(slot) = callback_data_item(scope, &args, EVENT_MEMBER_SLOTS, "WebRTC event attribute")+ else {+ return;+ };+ if let Some(value) = get_private_value(scope, args.this(), slot) {+ rv.set(value);+ } else {+ throw_type_error(scope, "Illegal invocation");+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rsindex 4dae57aa3..d48729509 100644--- a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs@@ -202,6 +202,13 @@ fn parse_candidate_init<'s>(Some(values)}+pub(super) fn ice_candidate_receiver_branded<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+) -> bool {+ web_api_interfaces::RTCIceCandidate::is_instance(scope, receiver)+}+fn candidate_values<'s>(scope: &mut v8::PinScope<'s, '_>,receiver: v8::Local<'s, v8::Object>,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.rsindex 774887d01..860caba5a 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@@ -53,6 +53,7 @@ mod trusted_types;mod value_events;mod web_audio;mod webrtc;+mod webrtc_events;mod window_legacy_objects;mod worker_listener_invocation;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/webrtc_events.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/webrtc_events.rsnew file mode 100644index 000000000..11ef1720b--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/webrtc_events.rs@@ -0,0 +1,235 @@+use super::*;++#[test]+fn webrtc_ice_event_constructor_preserves_candidates_and_converts_nullable_urls() {+ let mut vm = new_storage_test_vm("http://webrtc-ice-event.test/");+ let result = vm+ .eval(+ r#"+ (() => {+ const rejects = fn => {+ try { fn(); return false; } catch (error) { return error instanceof TypeError; }+ };+ const candidate = new RTCIceCandidate({sdpMid: 'audio'});+ const rawType = 'ice\ud800\0\udc00';+ const event = new RTCPeerConnectionIceEvent(rawType, {candidate, url: 'turn:\ud800'});+ const checks = [RTCPeerConnectionIceEvent.length === 1,+ rejects(() => new RTCPeerConnectionIceEvent()),+ rejects(() => RTCPeerConnectionIceEvent('ice')),+ rejects(() => new RTCPeerConnectionIceEvent(Symbol())),+ event.type === rawType, event.candidate === candidate, event.url === 'turn:\ufffd',+ new RTCPeerConnectionIceEvent(undefined).type === 'undefined',+ new RTCPeerConnectionIceEvent(null).type === 'null'];+ for (const init of [undefined, null, {}, {candidate: null, url: null},+ {candidate: undefined, url: undefined}]) {+ const empty = new RTCPeerConnectionIceEvent('ice', init);+ checks.push(empty.candidate === null, empty.url === null,+ !empty.bubbles, !empty.cancelable, !empty.composed);+ }+ for (const url of ['', false, 4, 5n, ['not a URL']]) {+ checks.push(new RTCPeerConnectionIceEvent('ice', {url}).url === String(url));+ }+ for (const init of [true, 1, 'init', Symbol(), 1n, {url: Symbol()},+ {candidate: {}}, {candidate: false}, {candidate: 1},+ {candidate: Object.create(candidate)}, {candidate: new Proxy(candidate, {})}]) {+ checks.push(rejects(() => new RTCPeerConnectionIceEvent('ice', init)));+ }+ Object.setPrototypeOf(candidate, null);+ checks.push(new RTCPeerConnectionIceEvent('ice', {candidate}).candidate === candidate);+ return checks.every(Boolean) || JSON.stringify(checks);+ })()+ "#,+ )+ .expect(+ "ICE events should preserve candidate identity and the DOMString/USVString distinction",+ );+ assert_eq!(result, "true");+}++#[test]+fn webrtc_data_channel_event_requires_a_genuine_channel_and_checks_arity_first() {+ let mut vm = new_storage_test_vm("https://webrtc-data-channel-event.test/");+ let result = vm.eval(r#"+ (() => {+ const rejects = fn => {+ try { fn(); return false; } catch (error) { return error instanceof TypeError; }+ };+ const peer = new RTCPeerConnection();+ const channel = peer.createDataChannel('test');+ const event = new RTCDataChannelEvent('channel', {channel});+ let converted = false;+ const checks = [RTCDataChannelEvent.length === 2, event.channel === channel,+ rejects(() => RTCDataChannelEvent('channel', {channel})),+ rejects(() => new RTCDataChannelEvent()),+ rejects(() => new RTCDataChannelEvent({toString() { converted = true; return 'channel'; }})),+ !converted];+ for (const init of [undefined, null, {}, {channel: null}, {channel: undefined},+ false, 1, 'init', Symbol(), 1n, {channel: {}},+ {channel: Object.create(RTCDataChannel.prototype)},+ {channel: Object.create(channel)}, {channel: new Proxy(channel, {})},+ {channel: new RTCIceCandidate({sdpMid: 'audio'})}]) {+ checks.push(rejects(() => new RTCDataChannelEvent('channel', init)));+ }+ Object.defineProperty(RTCDataChannel, Symbol.hasInstance, {+ configurable: true, value() { throw new Error('must not use instanceof'); }+ });+ try {+ checks.push(rejects(() => new RTCDataChannelEvent('channel', {channel: {}})),+ new RTCDataChannelEvent('channel', {channel}).channel === channel);+ } finally { delete RTCDataChannel[Symbol.hasInstance]; }+ Object.setPrototypeOf(channel, null);+ checks.push(new RTCDataChannelEvent('channel', {channel}).channel === channel);+ peer.close();+ return checks.every(Boolean) || JSON.stringify(checks);+ })()+ "#).expect("data channel events should validate arity before conversion and use native interface branding");+ assert_eq!(result, "true");+}++#[test]+fn webrtc_event_dictionary_conversion_reads_inherited_members_first_and_preserves_exceptions() {+ let mut vm = new_storage_test_vm("https://webrtc-event-conversion.test/");+ let result = vm.eval(r#"+ (() => {+ const candidate = new RTCIceCandidate({sdpMid: 'audio'});+ const peer = new RTCPeerConnection();+ const channel = peer.createDataChannel('test');+ const checks = [];+ for (const [Ctor, ownMembers] of [+ [RTCPeerConnectionIceEvent, ['candidate', 'url']], [RTCDataChannelEvent, ['channel']]+ ]) {+ const names = ['bubbles', 'cancelable', 'composed', ...ownMembers];+ const reads = [];+ const dictionary = Object.create({bubbles: [], cancelable: 1, composed: 'yes',+ candidate, channel, url: 'url'});+ const event = new Ctor({toString() { reads.push('type'); return 'converted'; }},+ new Proxy(dictionary, {get(object, name) { reads.push(name); return object[name]; }}));+ checks.push(reads.join(',') === ['type', ...names].join(','),+ event.type === 'converted', event.bubbles, event.cancelable, event.composed);+ const sentinel = new RangeError('original getter failure');+ for (const name of names) {+ const bad = {candidate, channel};+ Object.defineProperty(bad, name, {get() { throw sentinel; }});+ try { new Ctor('event', bad); checks.push(false); }+ catch (error) { checks.push(error === sentinel); }+ }+ try { new Ctor({toString() { throw sentinel; }}, {candidate, channel}); checks.push(false); }+ catch (error) { checks.push(error === sentinel); }+ }+ const sentinel = new RangeError('URL conversion');+ try {+ new RTCPeerConnectionIceEvent('ice', {url: {toString() { throw sentinel; }}});+ checks.push(false);+ } catch (error) { checks.push(error === sentinel); }+ let urlRead = false;+ try {+ new RTCPeerConnectionIceEvent('ice', {candidate: {}, get url() { urlRead = true; return ''; }});+ checks.push(false);+ } catch (error) { checks.push(error instanceof TypeError, !urlRead); }+ Object.defineProperty(Object.prototype, 'bubbles', {+ configurable: true, get() { throw sentinel; }+ });+ try {+ checks.push(new RTCPeerConnectionIceEvent('ice', null).candidate === null);+ try { new RTCDataChannelEvent('channel', null); checks.push(false); }+ catch (error) { checks.push(error instanceof TypeError); }+ } finally { delete Object.prototype.bubbles; }+ peer.close();+ return checks.every(Boolean) || JSON.stringify(checks);+ })()+ "#).expect("WebRTC event dictionaries should convert EventInit first without swallowing getters or exceptions");+ assert_eq!(result, "true");+}++#[test]+fn webrtc_event_members_are_readonly_branded_and_survive_dispatch_and_reinitialization() {+ let mut vm = new_storage_test_vm("https://webrtc-event-dispatch.test/");+ let result = vm.eval(r#"+ (() => {+ const candidate = new RTCIceCandidate({sdpMid: 'audio'});+ const peer = new RTCPeerConnection();+ const channel = peer.createDataChannel('test');+ const checks = [];+ const rejects = fn => {+ try { fn(); return false; } catch (error) { return error instanceof TypeError; }+ };+ for (const [Ctor, members] of [+ [RTCPeerConnectionIceEvent, {candidate, url: 'turn:server'}], [RTCDataChannelEvent, {channel}]+ ]) {+ const event = new Ctor('test', {...members, bubbles: true, cancelable: true, composed: true});+ checks.push(event instanceof Ctor, event instanceof Event,+ Object.getPrototypeOf(Ctor.prototype) === Event.prototype,+ Object.prototype.toString.call(event) === '[object ' + Ctor.name + ']',+ event.isTrusted === false, typeof event.timeStamp === 'number');+ for (const [name, original] of Object.entries(members)) {+ const descriptor = Object.getOwnPropertyDescriptor(Ctor.prototype, name);+ if (!descriptor) return 'missing:' + name;+ checks.push(!Object.hasOwn(event, name), descriptor.enumerable, descriptor.configurable,+ descriptor.get.name === 'get ' + name, descriptor.get.length === 0, !descriptor.set);+ event[name] = 'changed';+ checks.push(event[name] === original, rejects(() => { 'use strict'; event[name] = null; }));+ for (const fake of [undefined, null, {}, Ctor.prototype, new Event('test'),+ Object.create(event), new Proxy(event, {})]) {+ checks.push(rejects(() => descriptor.get.call(fake)));+ }+ }+ const target = new EventTarget();+ let delivered = false;+ target.addEventListener('test', received => {+ delivered = received === event && received.target === target && received.currentTarget === target;+ received.preventDefault();+ });+ checks.push(target.dispatchEvent(event) === false, delivered, event.defaultPrevented,+ event.isTrusted === false, event.currentTarget === null);+ event.initEvent('again', false, false);+ checks.push(event.type === 'again', !event.defaultPrevented, !event.bubbles, !event.cancelable);+ for (const [name, original] of Object.entries(members)) checks.push(event[name] === original);+ }+ peer.close();+ return checks.every(Boolean) || JSON.stringify(checks);+ })()+ "#).expect("WebRTC event attributes should retain native identity through normal Event operations");+ assert_eq!(result, "true");+}++#[test]+fn webrtc_event_constructors_support_subclasses_foreign_members_and_new_target_realms() {+ let mut vm = new_parsed_test_vm(+ "https://webrtc-event-realms.test/",+ "<!doctype html><iframe></iframe>",+ );+ let result = vm.eval(r#"+ (() => {+ const child = document.querySelector('iframe').contentWindow;+ const foreignPeer = new child.RTCPeerConnection();+ const candidate = new child.RTCIceCandidate({sdpMid: 'foreign'});+ const channel = foreignPeer.createDataChannel('foreign');+ const checks = [];+ for (const [name, member, value] of [+ ['RTCPeerConnectionIceEvent', 'candidate', candidate], ['RTCDataChannelEvent', 'channel', channel]+ ]) {+ const Ctor = window[name];+ const init = {[member]: value};+ class Derived extends Ctor {}+ const derived = new Derived('event', init);+ const foreign = new child[name]('event', init);+ const newTarget = child.Function('');+ newTarget.prototype = 0;+ let prototypeReads = 0;+ const target = new Proxy(newTarget, {get(object, name) {+ if (name === 'prototype') prototypeReads++;+ return Reflect.get(object, name);+ }});+ const fallback = Reflect.construct(Ctor, ['event', init], target);+ checks.push(derived instanceof Derived, derived instanceof Ctor,+ derived[member] === value, foreign[member] === value,+ Object.getOwnPropertyDescriptor(Ctor.prototype, member).get.call(foreign) === value,+ Object.getPrototypeOf(fallback) === child[name].prototype, fallback[member] === value,+ prototypeReads === 1);+ }+ foreignPeer.close();+ return checks.every(Boolean) || JSON.stringify(checks);+ })()+ "#).expect("WebRTC event constructors should preserve genuine cross-realm members and NewTarget semantics");+ assert_eq!(result, "true");+}diff --git a/moli-renderer-v8/src/web_api_interfaces.rs b/moli-renderer-v8/src/web_api_interfaces.rsindex ee32e318c..e8181b337 100644--- a/moli-renderer-v8/src/web_api_interfaces.rs+++ b/moli-renderer-v8/src/web_api_interfaces.rs@@ -353,6 +353,8 @@ interfaces! {RTCDataChannel: EventTarget;RTCIceCandidate;RTCPeerConnection: EventTarget;+ RTCPeerConnectionIceEvent: Event;+ RTCDataChannelEvent: Event;RTCRtpReceiver;RTCSessionDescription;RadioNodeList: NodeList;diff --git a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs b/moli-renderer-v8/src/worker/thread/tests/postmessage.rsindex da0568719..bdb53b404 100644--- a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs+++ b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs@@ -71,6 +71,21 @@ async fn worker_console_capture_does_not_serialize_or_coerce_page_objects() {}}+#[tokio::test]+async fn worker_does_not_expose_window_only_webrtc_event_interfaces() {+ ensure_v8();+ let mut handle = spawn_worker(+ r#"postMessage([typeof RTCPeerConnectionIceEvent, typeof RTCDataChannelEvent]); close();"#+ .into(),+ "test://webrtc-event-exposure".into(),+ );+ let msg = timeout(TIMEOUT, handle.recv())+ .await+ .expect("timed out waiting for worker WebRTC event exposure")+ .expect("channel closed");+ assert_eq!(expect_post_json(msg), r#"["undefined","undefined"]"#);+}+#[tokio::test]async fn worker_postmessage_to_parent() {ensure_v8();