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(webaudio): expose native audio event payloads
ldm0ff5361ae316a
diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rsindex 7cb26fbe1..92a6363fa 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs@@ -941,6 +941,18 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(ConstructorKind::AbstractRange => build_abstract_range_template(scope),ConstructorKind::Range => build_range_constructor_template(scope),ConstructorKind::StaticRange => build_static_range_constructor_template(scope),+ ConstructorKind::AudioProcessingEvent => {+ super::super::events::audio::build_audio_event_template(+ scope,+ super::super::events::audio::AudioEventKind::Processing,+ )+ }+ ConstructorKind::OfflineAudioCompletionEvent => {+ super::super::events::audio::build_audio_event_template(+ scope,+ super::super::events::audio::AudioEventKind::Completion,+ )+ }ConstructorKind::Url => build_url_constructor_template(scope),ConstructorKind::UrlSearchParams => build_url_search_params_constructor_template(scope),ConstructorKind::FormData => build_form_data_constructor_template(scope),diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rsindex ea7b8d594..e0991322e 100644--- a/moli-renderer-v8/src/context_bootstrap/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/events.rs@@ -11,6 +11,8 @@ mod subclasses;mod value;mod wrappers;+pub(in crate::context_bootstrap) mod audio;+pub(in crate::context_bootstrap) use device::{device_motion_event_constructor, device_orientation_event_constructor,install_device_event_template_bindings,diff --git a/moli-renderer-v8/src/context_bootstrap/events/audio.rs b/moli-renderer-v8/src/context_bootstrap/events/audio.rsnew file mode 100644index 000000000..7d67ee0c7--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/events/audio.rs@@ -0,0 +1,247 @@+//! Constructible event payloads that do not require an animation or recording backend.++use super::{+ define_event_property, event_private_value, initialize_event_object_with_type,+ initialize_event_wrapper, new_event_state, set_event_private_value,+};+use crate::{+ util::{new_null_prototype_object, throw_type_error, v8str},+ web_api_interfaces, webidl,+};+use moli_webapi_declare::WebApiFunctionTemplate;++const RENDERED_BUFFER_SLOT: &str = "__moliAudioCompletionRenderedBuffer";+const INPUT_BUFFER_SLOT: &str = "__moliAudioProcessingInputBuffer";+const OUTPUT_BUFFER_SLOT: &str = "__moliAudioProcessingOutputBuffer";+const PLAYBACK_TIME_SLOT: &str = "__moliAudioProcessingPlaybackTime";++#[derive(Clone, Copy)]+pub(in crate::context_bootstrap) enum AudioEventKind {+ Processing,+ Completion,+}+impl AudioEventKind {+ fn name(self) -> &'static str {+ match self {+ Self::Processing => "AudioProcessingEvent",+ Self::Completion => "OfflineAudioCompletionEvent",+ }+ }+ fn length(self) -> i32 {+ 2+ }+}+#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::AudioProcessingEvent, enumerable, receiver)]+struct AudioProcessingEventPrototypeDeclaration {+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, INPUT_BUFFER_SLOT))]+ input_buffer: (),+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, OUTPUT_BUFFER_SLOT))]+ output_buffer: (),+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, PLAYBACK_TIME_SLOT))]+ playback_time: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::OfflineAudioCompletionEvent, enumerable, receiver)]+struct OfflineAudioCompletionEventPrototypeDeclaration {+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, RENDERED_BUFFER_SLOT))]+ rendered_buffer: (),+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "AudioProcessingEventInit")]+struct AudioProcessingEventInit<'s> {+ #[webidl(default = false)]+ bubbles: bool,+ #[webidl(default = false)]+ cancelable: bool,+ #[webidl(default = false)]+ composed: bool,+ #[webidl(with = audio_buffer_member)]+ input_buffer: v8::Local<'s, v8::Object>,+ #[webidl(with = audio_buffer_member)]+ output_buffer: v8::Local<'s, v8::Object>,+ #[webidl(required, converter = "double")]+ playback_time: f64,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "OfflineAudioCompletionEventInit")]+struct OfflineAudioCompletionEventInit<'s> {+ #[webidl(default = false)]+ bubbles: bool,+ #[webidl(default = false)]+ cancelable: bool,+ #[webidl(default = false)]+ composed: bool,+ #[webidl(with = audio_buffer_member)]+ rendered_buffer: v8::Local<'s, v8::Object>,+}++fn audio_buffer_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ name: &'static str,+) -> Result<v8::Local<'s, v8::Object>, webidl::WebIdlError> {+ let prefix = if name == "renderedBuffer" {+ "OfflineAudioCompletionEventInit"+ } else {+ "AudioProcessingEventInit"+ };+ let context = webidl::Context::member(prefix, name);+ let value = webidl::property_result(scope, object, name, context)?+ .filter(|value| !value.is_undefined())+ .ok_or_else(|| webidl::WebIdlError::missing_required(context))?;+ let buffer = v8::Local::<v8::Object>::try_from(value)+ .map_err(|_| webidl::WebIdlError::cannot_convert(context, "AudioBuffer"))?;+ if !web_api_interfaces::AudioBuffer::is_instance(scope, buffer) {+ return Err(webidl::WebIdlError::cannot_convert(context, "AudioBuffer"));+ }+ Ok(buffer)+}++fn payload_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let key = args.data().to_rust_string_lossy(scope);+ if let Some(value) = event_private_value(scope, args.this(), &key) {+ rv.set(value);+ }+}++pub(in crate::context_bootstrap) fn build_audio_event_template<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ kind: AudioEventKind,+) -> v8::Local<'s, v8::FunctionTemplate> {+ let template = v8::FunctionTemplate::builder(audio_event_constructor)+ .data(v8::Integer::new(scope, kind as i32).into())+ .length(2)+ .build(scope);+ let prototype = template.prototype_template(scope);+ match kind {+ AudioEventKind::Processing => {+ AudioProcessingEventPrototypeDeclaration::initialize_prototype_template(+ scope, prototype,+ )+ }+ AudioEventKind::Completion => {+ OfflineAudioCompletionEventPrototypeDeclaration::initialize_prototype_template(+ scope, prototype,+ )+ }+ }+ template+}+fn audio_event_constructor<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let kind = match args.data().int32_value(scope) {+ Some(0) => AudioEventKind::Processing,+ Some(1) => AudioEventKind::Completion,+ _ => return,+ };+ if !args.is_construct_call() {+ throw_type_error(scope, &format!("{} requires 'new'.", kind.name()));+ return;+ }+ if args.length() < kind.length() {+ throw_type_error(+ scope,+ &format!("{} requires {} arguments.", kind.name(), kind.length()),+ );+ return;+ }+ let Some(event_type) = args.get(0).to_string(scope) else {+ return;+ };+ let state = new_event_state(scope);+ let result = (|| -> Result<(), webidl::WebIdlError> {+ let dictionary =+ webidl::dictionary_arg(&args, 1, webidl::Context::argument(kind.name(), 2))?+ .unwrap_or_else(|| new_null_prototype_object(scope));+ let (bubbles, cancelable, composed) = match kind {+ AudioEventKind::Processing => {+ let parsed =+ webidl::parse_dictionary_object::<AudioProcessingEventInit>(scope, dictionary)?;+ set_event_private_value(+ scope,+ state,+ INPUT_BUFFER_SLOT,+ parsed.input_buffer.into(),+ );+ set_event_private_value(+ scope,+ state,+ OUTPUT_BUFFER_SLOT,+ parsed.output_buffer.into(),+ );+ set_event_private_value(+ scope,+ state,+ PLAYBACK_TIME_SLOT,+ v8::Number::new(scope, parsed.playback_time).into(),+ );+ (parsed.bubbles, parsed.cancelable, parsed.composed)+ }+ AudioEventKind::Completion => {+ let parsed = webidl::parse_dictionary_object::<OfflineAudioCompletionEventInit>(+ scope, dictionary,+ )?;+ set_event_private_value(+ scope,+ state,+ RENDERED_BUFFER_SLOT,+ parsed.rendered_buffer.into(),+ );+ (parsed.bubbles, parsed.cancelable, parsed.composed)+ }+ };+ initialize_event_object_with_type(scope, state, event_type, bubbles, cancelable);+ define_event_property(+ scope,+ state,+ "composed",+ v8::Boolean::new(scope, composed).into(),+ );+ Ok(())+ })();+ if let Err(error) = result {+ webidl::throw_error(scope, &error);+ return;+ }+ web_api_interfaces::initialize(scope, state, kind.name())+ .expect("value event brand should initialize");+ if initialize_event_wrapper(scope, args.this(), state).is_some() {+ rv.set(args.this().into());+ }+}++/// Create a trusted native completion payload without consulting public+/// constructors or converting a synthetic author-visible dictionary.+pub(in crate::context_bootstrap) fn new_offline_audio_completion_event<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ rendered_buffer: v8::Local<'s, v8::Object>,+) -> Option<v8::Local<'s, v8::Object>> {+ let prototype =+ crate::context_bootstrap::exposed_interfaces::ensure_intrinsic_interface_prototype(+ scope,+ "OfflineAudioCompletionEvent",+ )+ .ok()?;+ let state = new_event_state(scope);+ super::initialize_event_object(scope, state, "complete", false, false);+ set_event_private_value(scope, state, RENDERED_BUFFER_SLOT, rendered_buffer.into());+ web_api_interfaces::initialize(scope, state, "OfflineAudioCompletionEvent").ok()?;+ let event = v8::Object::new(scope);+ if event.set_prototype(scope, prototype.into()) != Some(true) {+ return None;+ }+ initialize_event_wrapper(scope, event, state)?;+ super::mark_event_trusted(scope, event);+ Some(event)+}diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rsindex 0f3304f01..0f1d0f1aa 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs@@ -1231,6 +1231,14 @@ const CONSTRUCTOR_SPECS_AFTER_STREAMS: &[ConstructorSpec] = &[interface: web_api_interfaces::AudioBuffer::DESCRIPTOR,kind: ConstructorKind::AudioBuffer,},+ ConstructorSpec {+ interface: web_api_interfaces::AudioProcessingEvent::DESCRIPTOR,+ kind: ConstructorKind::AudioProcessingEvent,+ },+ ConstructorSpec {+ interface: web_api_interfaces::OfflineAudioCompletionEvent::DESCRIPTOR,+ kind: ConstructorKind::OfflineAudioCompletionEvent,+ },ConstructorSpec {interface: web_api_interfaces::AbstractRange::DESCRIPTOR,kind: ConstructorKind::AbstractRange,diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rsindex 3e6ab7e6b..d62842dc0 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs@@ -79,6 +79,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {File,FileReader,FileReaderSync,+ AudioProcessingEvent,+ OfflineAudioCompletionEvent,XmlSerializer,AbortController,BroadcastChannel,diff --git a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rsindex a802ab4a5..2137b13a3 100644--- a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs+++ b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs@@ -249,17 +249,6 @@ struct OfflineAudioCompletePayloadDeclaration<'scope> {rendered_buffer: v8::Local<'scope, v8::Object>,}-#[derive(WebApiObject)]-#[webapi(- interface = web_api_interfaces::OfflineAudioCompletionEvent,- prototype = "Object",)]-struct OfflineAudioCompletionEventDeclaration<'scope> {- #[webapi(data_property = "type")]- event_type: &'static str,- #[webapi(data_property = "renderedBuffer")]- rendered_buffer: v8::Local<'scope, v8::Object>,-}-#[derive(Default, WebApiObject)]#[webapi(interface = web_api_interfaces::AudioDestinationNode)]struct AudioDestinationNodeObjectDeclaration {}@@ -1503,9 +1492,14 @@ fn offline_audio_context_complete_microtask_callback<'s>(};mark_context_compressors_rendered(scope, context);- let event = OfflineAudioCompletionEventDeclaration::new("complete", rendered_buffer)- .bind(scope)- .expect("OfflineAudio completion event declaration should bind");+ let Some(realm) = context.get_creation_context(scope) else {+ return;+ };+ let scope = &mut v8::ContextScope::new(scope, realm);+ let Some(event) = events::audio::new_offline_audio_completion_event(scope, rendered_buffer)+ else {+ return;+ };let _ = dispatch_simple_event_target_event(scope,context,diff --git a/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.js b/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.jsnew file mode 100644index 000000000..1218680dd--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.js@@ -0,0 +1,59 @@+(async()=>{+ const completionFlags=[],rows=[],assert=(ok,message)=>{if(!ok)throw Error(message);},check=async(name,fn)=>{try{await fn();rows.push({name,pass:true});}catch(error){rows.push({name,pass:false,message:String(error)});}},errorFrom=fn=>{try{fn();}catch(error){return error;}throw Error('expected exception');};+ const input=await new OfflineAudioContext(1,8,8000).startRendering(),output=await new OfflineAudioContext(1,16,8000).startRendering(),realms=[['main',window],['child',document.getElementById('child').contentWindow]];+ for(const [label,w] of realms){+ const specs=[['AudioProcessingEvent',{inputBuffer:input,outputBuffer:output,playbackTime:1.25},['inputBuffer','outputBuffer','playbackTime']],['OfflineAudioCompletionEvent',{renderedBuffer:input},['renderedBuffer']]];+ for(const [name,payload,members] of specs){+ const init=()=>({...payload,bubbles:true,cancelable:true,composed:true});+ await check(label+'/'+name+'/interface',()=>{+ const C=w[name],d=Object.getOwnPropertyDescriptor(w,name);assert(typeof C==='function'&&C.name===name&&C.length===2,'constructor');+ assert(d.writable&&d.configurable&&!d.enumerable,'global descriptor');assert(Object.getPrototypeOf(C)===w.Event&&Object.getPrototypeOf(C.prototype)===w.Event.prototype&&C.prototype.constructor===C,'Event inheritance');+ assert(errorFrom(()=>C('test',init())) instanceof w.TypeError,'requires new');for(const args of [[],['test'],['test',null],['test',{}],['test',1]])assert(errorFrom(()=>new C(...args)) instanceof w.TypeError,'required dictionary and members');+ });+ await check(label+'/'+name+'/payload',()=>{+ const C=w[name],event=new C('payload\ud800',init());assert(event instanceof C&&event instanceof w.Event&&Object.prototype.toString.call(event)==='[object '+name+']','event brand');+ assert(event.type==='payload\ud800'&&event.bubbles&&event.cancelable&&event.composed&&!event.isTrusted,'EventInit and UTF-16');+ for(const key of members){assert(event[key]===payload[key]&&!Object.hasOwn(event,key),'native readonly payload '+key);Reflect.set(event,key,null);assert(event[key]===payload[key],'readonly setter');}+ class Sub extends C{};const sub=new Sub('test',init());assert(sub instanceof Sub&&sub instanceof C&&sub.type==='test','subclass');+ Object.freeze(event);for(const key of members)assert(event[key]===payload[key],'freeze preserves payload');+ });+ await check(label+'/'+name+'/dictionary conversion',()=>{+ const order=[],dictionary=Object.create(null);for(const key of ['bubbles','cancelable','composed',...members])Object.defineProperty(dictionary,key,{get(){order.push(key);return key in payload?payload[key]:true;}});+ const event=new w[name]({toString(){order.push('type');return 'test';}},dictionary);assert(order.join()==='type,bubbles,cancelable,composed,'+members.join(),'dictionary lexical order');+ assert(event.type==='test','converted type');+ const sentinel={};assert(errorFrom(()=>new w[name]({toString(){throw sentinel;}},new Proxy({},{get(){throw Error('dictionary prematurely read');}})))===sentinel,'type before dictionary');+ for(const key of ['bubbles','cancelable','composed',...members]){const bad=init();Object.defineProperty(bad,key,{get(){throw sentinel;}});assert(errorFrom(()=>new w[name]('test',bad))===sentinel,'preserve getter exception '+key);}+ for(const key of members){const missing=init();delete missing[key];assert(errorFrom(()=>new w[name]('test',missing)) instanceof w.TypeError,'missing required '+key);}+ });+ await check(label+'/'+name+'/buffer brands',()=>{+ for(const key of members.filter(k=>k.endsWith('Buffer'))){let traps=0;const revoked=Proxy.revocable(input,{});revoked.revoke();for(const buffer of [undefined,null,{},Object.create(input),new Proxy(input,{get(){traps++;throw Error('author proxy trap');}}),revoked.proxy])assert(errorFrom(()=>new w[name]('test',{...init(),[key]:buffer})) instanceof w.TypeError,'non-null native AudioBuffer required');assert(traps===0,'no author Proxy traps');}+ });+ await check(label+'/'+name+'/EventTarget dispatch',()=>{+ const event=new w[name]('test',init()),target=new w.EventTarget();let count=0;target.addEventListener('test',function(received){assert(received===event&&received.target===target&&received.currentTarget===target&&this===target&&received.eventPhase===w.Event.AT_TARGET,'native dispatch identity');count++;received.preventDefault();});+ assert(target.dispatchEvent(event)===false&&count===1&&event.defaultPrevented&&event.currentTarget===null&&!event.isTrusted,'Event dispatch and cancellation');for(const key of members)assert(event[key]===payload[key],'dispatch preserves payload');+ });+ for(const key of members)await check(label+'/'+name+'/'+key+'/receiver',()=>{+ const C=w[name],d=Object.getOwnPropertyDescriptor(C.prototype,key),fn=d.get;assert(d.enumerable&&d.configurable&&d.set===undefined&&fn.name==='get '+key&&fn.length===0,'readonly getter descriptor');+ const event=new C('test',init()),trap=()=>{throw Error('author trap');},revoked=Proxy.revocable(event,{});revoked.revoke();+ for(const receiver of [null,{},C.prototype,Object.create(event),new Proxy(event,{get:trap,getPrototypeOf:trap}),revoked.proxy])assert(errorFrom(()=>fn.call(receiver)) instanceof w.TypeError,'native receiver in callee realm');+ const foreign=new window[name]('test',init());assert(fn.call(foreign)===payload[key],'genuine foreign event');Object.setPrototypeOf(foreign,null);assert(fn.call(foreign)===payload[key],'brand independent of prototype');+ });+ }+ await check(label+'/AudioProcessingEvent/restricted playbackTime',()=>{+ for(const value of [NaN,Infinity,-Infinity,Symbol(),1n])assert(errorFrom(()=>new w.AudioProcessingEvent('test',{inputBuffer:input,outputBuffer:output,playbackTime:value})) instanceof w.TypeError,'restricted double');+ const event=new w.AudioProcessingEvent('test',{inputBuffer:input,outputBuffer:output,playbackTime:{valueOf(){return -1.5;}}});assert(event.playbackTime===-1.5,'negative finite payload preserved');+ });+ for(const mode of ['native','borrowed','replaced-global'])await check(label+'/actual offline completion/'+mode,async()=>{+ const C=w.OfflineAudioCompletionEvent,E=w.Event,context=new w.OfflineAudioContext(1,8,8000),observations={},completed=new Promise(resolve=>{context.addEventListener('complete',function(event){observations.listener={event,target:event.target,current:event.currentTarget,receiver:this,phase:event.eventPhase,trusted:event.isTrusted};});context.oncomplete=function(event){observations.handler={event,target:event.target,current:event.currentTarget,receiver:this};resolve();};});+ let rendered;try{+ if(mode==='replaced-global'){w.OfflineAudioCompletionEvent=function(){throw Error('author constructor');};w.Event=function(){throw Error('author Event');};}+ rendered=await (mode==='borrowed'?window.OfflineAudioContext.prototype.startRendering.call(context):context.startRendering());await completed;+ }finally{w.OfflineAudioCompletionEvent=C;w.Event=E;}+ const a=observations.listener,b=observations.handler,event=a.event;assert(event===b.event&&event instanceof C&&event instanceof E&&Object.getPrototypeOf(event)===C.prototype,'native completion event in context realm');+ assert(a.target===context&&a.current===context&&a.receiver===context&&a.phase===E.AT_TARGET&&a.trusted&&b.target===context&&b.current===context&&b.receiver===context,'trusted complete dispatch identity');+ completionFlags.push({realm:label,mode,bubbles:event.bubbles,cancelable:event.cancelable,composed:event.composed});+ assert(event.type==='complete'&&typeof event.bubbles==='boolean'&&!event.cancelable&&!event.composed&&event.currentTarget===null&&event.renderedBuffer===rendered,'complete payload and cleanup '+JSON.stringify({type:event.type,bubbles:event.bubbles,cancelable:event.cancelable,composed:event.composed,currentIsNull:event.currentTarget===null,sameBuffer:event.renderedBuffer===rendered}));+ });+ }+ globalThis.__audioEventResults={completionFlags,rows,passed:rows.filter(r=>r.pass).length,total:rows.length,failures:rows.filter(r=>!r.pass)};return rows.every(r=>r.pass);+})()diff --git a/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.rs b/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.rsnew file mode 100644index 000000000..e71e07258--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/audio_event_interfaces.rs@@ -0,0 +1,30 @@+use super::*;++#[test]+fn audio_events_have_native_payloads_receivers_and_dispatch() {+ let mut vm = new_storage_page_task_executor_test_vm("https://audio-event-interfaces.test/");+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")+ .unwrap();+ vm.eval(&format!("({}).then(value => globalThis.__audioEventDone = value, error => globalThis.__audioEventDone = String(error));", include_str!("audio_event_interfaces.js"))).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("JSON.stringify(__audioEventResults.failures)")+ .unwrap(),+ "[]"+ );+ assert_eq!(vm.eval("__audioEventDone").unwrap(), "true");+}++#[test]+fn offline_completion_uses_the_default_fire_event_flags() {+ let mut vm = new_storage_page_task_executor_test_vm("https://audio-complete-flags.test/");+ vm.eval(r#"(() => {+ const context = new OfflineAudioContext(1,8,8000);+ context.oncomplete = event => globalThis.__completeFlags = [event.bubbles,event.cancelable,event.composed,event.isTrusted,event instanceof OfflineAudioCompletionEvent].join('|');+ context.startRendering();+ })()"#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("__completeFlags")+ .unwrap(),+ "false|false|false|true|true"+ );+}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rsindex f47e2e819..04a35a608 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs@@ -2481,7 +2481,7 @@ fn web_audio_declared_objects_keep_brands_and_hidden_properties() {assert_eq!(result,- r#"{"completion":{"tag":"[object Object]","ctor":"Object","type":"complete","renderedBufferTag":"[object AudioBuffer]","renderedBufferCtor":"AudioBuffer","renderedBufferLength":32,"renderedBufferSampleRate":8000,"renderedBufferDuration":0.004,"renderedBufferEnumerable":false,"targetIsContext":true,"currentTargetIsContext":true},"ctxTag":"[object OfflineAudioContext]","ctxCtor":"OfflineAudioContext","ctxLength":32,"ctxSampleRate":8000,"ctxState":"closed","lengthEnumerable":false,"destinationTag":"[object AudioDestinationNode]","destinationCtor":"AudioDestinationNode","destinationKeys":"","oscTag":"[object OscillatorNode]","oscCtor":"OscillatorNode","oscKeys":"","oscType":"sine","frequencyTag":"[object AudioParam]","frequencyCtor":"AudioParam","frequencyValue":123,"frequencyEnumerable":false,"setValueAtTimeType":"function","compTag":"[object DynamicsCompressorNode]","compCtor":"DynamicsCompressorNode","compKeys":"","thresholdTag":"[object AudioParam]","reduction":0,"reductionOwn":false,"promiseTag":"[object Promise]"}"#+ r#"{"completion":{"tag":"[object OfflineAudioCompletionEvent]","ctor":"OfflineAudioCompletionEvent","type":"complete","renderedBufferTag":"[object AudioBuffer]","renderedBufferCtor":"AudioBuffer","renderedBufferLength":32,"renderedBufferSampleRate":8000,"renderedBufferDuration":0.004,"renderedBufferEnumerable":false,"targetIsContext":true,"currentTargetIsContext":true},"ctxTag":"[object OfflineAudioContext]","ctxCtor":"OfflineAudioContext","ctxLength":32,"ctxSampleRate":8000,"ctxState":"closed","lengthEnumerable":false,"destinationTag":"[object AudioDestinationNode]","destinationCtor":"AudioDestinationNode","destinationKeys":"","oscTag":"[object OscillatorNode]","oscCtor":"OscillatorNode","oscKeys":"","oscType":"sine","frequencyTag":"[object AudioParam]","frequencyCtor":"AudioParam","frequencyValue":123,"frequencyEnumerable":false,"setValueAtTimeType":"function","compTag":"[object DynamicsCompressorNode]","compCtor":"DynamicsCompressorNode","compKeys":"","thresholdTag":"[object AudioParam]","reduction":0,"reductionOwn":false,"promiseTag":"[object Promise]"}"#);}diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex 699018b72..3dffa9512 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -2144,6 +2144,8 @@ mod element_click;mod event_receivers;mod headers_list;mod http_fixture;++mod audio_event_interfaces;mod import_meta;mod indexed_db;mod inspector_unwrap;diff --git a/moli-renderer-v8/src/web_api_interfaces.rs b/moli-renderer-v8/src/web_api_interfaces.rsindex 7e4bb8f88..5acca2d26 100644--- a/moli-renderer-v8/src/web_api_interfaces.rs+++ b/moli-renderer-v8/src/web_api_interfaces.rs@@ -323,6 +323,7 @@ interfaces! {Notification: EventTarget;NotificationEvent: ExtendableEvent;OfflineAudioCompletionEvent: Event;+ AudioProcessingEvent: Event;OfflineAudioContext: BaseAudioContext;OffscreenCanvas;OffscreenCanvasRenderingContext2D;