Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.js
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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;