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(worklet): expose native interfaces and independent module promises
ldm04e2f6caa461a
diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rsindex 71389fde6..39da7d59f 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/finalize.rs@@ -8,6 +8,7 @@ use super::materialize::{enum RealmDependentFinalizer {NodeMixinUnscopables,CryptoSecureContextSurface,+ BaseAudioContextSecureContextSurface,XmlHttpRequestEventTargetState,NotificationPermission,PointerEventSecureContextSurface,@@ -33,6 +34,10 @@ const REALM_DEPENDENT_FINALIZER_ALLOWLIST: &[(&str, RealmDependentFinalizer)] =),// These entries install private realm state, context-conditional surface,// or constructor data whose JavaScript identity must be realm-local.+ (+ "BaseAudioContext",+ RealmDependentFinalizer::BaseAudioContextSecureContextSurface,+ ),("Crypto",RealmDependentFinalizer::CryptoSecureContextSurface,@@ -80,6 +85,9 @@ pub(super) fn finalize_materialized_interface(RealmDependentFinalizer::NodeMixinUnscopables => {finalize_node_mixin_unscopables(scope, prototype);}+ RealmDependentFinalizer::BaseAudioContextSecureContextSurface => {+ crate::context_bootstrap::web_audio_runtime::finalize_base_audio_context_realm_bindings(scope, prototype)?;+ }RealmDependentFinalizer::CryptoSecureContextSurface => {crate::context_bootstrap::crypto::finalize_crypto_realm_bindings(scope, prototype)?;}@@ -140,6 +148,7 @@ mod tests {"Element","DocumentType","CharacterData",+ "BaseAudioContext","Crypto","XMLHttpRequestEventTarget","Notification",diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rsindex 40ca57a34..d47353d18 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs@@ -102,6 +102,8 @@ const SECURE_CONTEXT_ONLY_INTERFACE_NAMES: &[&str] = &["SubtleCrypto","CryptoKey","IdleDetector",+ "Worklet",+ "AudioWorklet","Clipboard","ClipboardItem","Cache",diff --git a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs b/moli-renderer-v8/src/context_bootstrap/runtime_state.rsindex 2d2a88a4a..77cf7aaa0 100644--- a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs+++ b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs@@ -2063,6 +2063,14 @@ pub(crate) fn set_interface_prototype_constructor<'s>();}+pub(crate) fn window_realm_secure_context_available<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ window: v8::Local<'s, v8::Object>,+) -> bool {+ get_private_value(scope, window, WINDOW_SECURE_CONTEXT_AVAILABLE_SLOT)+ .is_some_and(|value| value.is_true())+}+fn install_window_runtime_state<'s>(scope: &mut v8::PinScope<'s, '_>,global: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rsindex 472137b39..0f3304f01 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs@@ -1183,6 +1183,14 @@ const CONSTRUCTOR_SPECS_AFTER_STREAMS: &[ConstructorSpec] = &[interface: web_api_interfaces::AudioContext::DESCRIPTOR,kind: ConstructorKind::AudioContext,},+ ConstructorSpec {+ interface: web_api_interfaces::Worklet::DESCRIPTOR,+ kind: ConstructorKind::Illegal,+ },+ ConstructorSpec {+ interface: web_api_interfaces::AudioWorklet::DESCRIPTOR,+ kind: ConstructorKind::Illegal,+ },ConstructorSpec {interface: web_api_interfaces::AudioWorkletNode::DESCRIPTOR,kind: ConstructorKind::AudioWorkletNode,diff --git a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rsindex 39009103a..a802ab4a5 100644--- a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs+++ b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs@@ -6,8 +6,7 @@ use super::media_queries::{use super::*;use crate::native_bridge::throw_dom_exception;use crate::util::{- array_push_value, call_object_method, get_private_value, object_string_property,- set_private_value, set_symbol_to_string_tag,+ call_object_method, get_private_value, object_string_property, set_private_value,};use crate::web_api_interfaces;use crate::webidl;@@ -23,11 +22,12 @@ const AUDIO_CONTEXT_LISTENERS_SLOT: &str = "__moliAudioContextListeners";const AUDIO_CONTEXT_MODULES_SLOT: &str = "__moliAudioContextModules";const AUDIO_CONTEXT_MODULE_LIST_SLOT: &str = "__moliAudioContextModuleList";const AUDIO_CONTEXT_PROCESSORS_SLOT: &str = "__moliAudioContextProcessors";+const AUDIO_CONTEXT_WORKLET_SLOT: &str = "__moliAudioContextWorklet";const AUDIO_WORKLET_CONTEXT_SLOT: &str = "__moliAudioWorkletContext";const AUDIO_WORKLET_MODULE_CONTEXT_SLOT: &str = "__moliAudioWorkletModuleContext";const AUDIO_WORKLET_MODULE_WORKER_SLOT: &str = "__moliAudioWorkletModuleWorker";-const AUDIO_WORKLET_MODULE_PROMISE_SLOT: &str = "__moliAudioWorkletModulePromise";-const AUDIO_WORKLET_MODULE_RESOLVER_SLOT: &str = "__moliAudioWorkletModuleResolver";+const AUDIO_WORKLET_MODULE_RESOLVERS_SLOT: &str = "__moliAudioWorkletModuleResolvers";+const AUDIO_WORKLET_MODULE_ERROR_SLOT: &str = "__moliAudioWorkletModuleError";const AUDIO_WORKLET_MODULE_LOADED_SLOT: &str = "__moliAudioWorkletModuleLoaded";const AUDIO_WORKLET_MODULE_SETTLED_SLOT: &str = "__moliAudioWorkletModuleSettled";const AUDIO_WORKLET_CALLBACK_MODULE_SLOT: &str = "__moliAudioWorkletCallbackModule";@@ -51,8 +51,6 @@ struct AudioContextObjectDeclaration<'scope> {state: &'static str,#[webapi(data_property)]destination: v8::Local<'scope, v8::Object>,- #[webapi(data_property = "audioWorklet")]- audio_worklet: v8::Local<'scope, v8::Object>,#[webapi(slot = SIMPLE_EVENT_TARGET_SLOT, value = AUDIO_CONTEXT_LISTENERS_SLOT)]event_target_slot: (),#[webapi(slot = AUDIO_CONTEXT_MODULES_SLOT)]@@ -66,10 +64,10 @@ struct AudioContextObjectDeclaration<'scope> {#[derive(WebApiObject)]#[webapi(interface = web_api_interfaces::AudioWorklet)]struct AudioWorkletObjectDeclaration<'scope> {+ #[webapi(prototype)]+ prototype: v8::Local<'scope, v8::Object>,#[webapi(slot = AUDIO_WORKLET_CONTEXT_SLOT)]context: v8::Local<'scope, v8::Object>,- #[webapi(method = "addModule", length = 1, callback = audio_worklet_add_module_callback)]- add_module: (),}#[derive(WebApiObject)]@@ -88,10 +86,8 @@ struct AudioWorkletModuleStateDeclaration<'scope> {context: v8::Local<'scope, v8::Object>,#[webapi(slot = AUDIO_WORKLET_MODULE_WORKER_SLOT)]worker: v8::Local<'scope, v8::Object>,- #[webapi(slot = AUDIO_WORKLET_MODULE_PROMISE_SLOT)]- promise: v8::Local<'scope, v8::Promise>,- #[webapi(slot = AUDIO_WORKLET_MODULE_RESOLVER_SLOT)]- resolver: v8::Local<'scope, v8::PromiseResolver>,+ #[webapi(slot = AUDIO_WORKLET_MODULE_RESOLVERS_SLOT)]+ resolvers: v8::Local<'scope, v8::Array>,#[webapi(slot = AUDIO_WORKLET_MODULE_LOADED_SLOT)]loaded: bool,#[webapi(slot = AUDIO_WORKLET_MODULE_SETTLED_SLOT)]@@ -480,6 +476,10 @@ pub(in crate::context_bootstrap) fn install_web_audio_template_bindings<'s>(graph::install(scope, template);}match interface_name {+ "Worklet" => WorkletPrototypeDeclaration::initialize_prototype_template(+ scope,+ template.prototype_template(scope),+ ),"AudioParam" => audio_param::install(scope, template),"BiquadFilterNode" => biquad::install(scope, template),"BaseAudioContext" => {@@ -528,17 +528,12 @@ fn audio_context_constructor_callback<'s>(let modules = new_web_audio_map_object(scope);let module_list = v8::Array::new(scope, 0);let processors = new_web_audio_map_object(scope);- let audio_worklet = AudioWorkletObjectDeclaration::new(context)- .bind(scope)- .expect("AudioWorklet declaration should bind");- set_symbol_to_string_tag(scope, audio_worklet, "AudioWorklet");AudioContextObjectDeclaration::new(0.0,44_100.0,"running",destination,- audio_worklet,modules,module_list,processors,@@ -579,20 +574,12 @@ fn audio_context_close_callback<'s>(module_state,AUDIO_WORKLET_MODULE_SETTLED_SLOT,) {- set_audio_worklet_module_bool_slot(+ let error = new_dom_exception_value(scope,- module_state,- AUDIO_WORKLET_MODULE_SETTLED_SLOT,- true,+ "AudioWorklet module loading was aborted.",+ "AbortError",);- if let Some(resolver) = audio_worklet_module_resolver(scope, module_state) {- let error = new_dom_exception_value(- scope,- "AudioWorklet module loading was aborted.",- "AbortError",- );- let _ = resolver.reject(scope, error);- }+ settle_audio_worklet_module(scope, module_state, Err(error));}if let Some(worker) =web_audio_object_slot(scope, module_state, AUDIO_WORKLET_MODULE_WORKER_SLOT)@@ -627,76 +614,184 @@ fn audio_context_close_callback<'s>(}}-fn audio_worklet_add_module_callback<'s>(+#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::Worklet, enumerable, receiver)]+struct WorkletPrototypeDeclaration {+ #[webapi(method = "addModule", length = 1, returns_promise, callback = audio_worklet_add_module_callback)]+ add_module: (),+}++#[derive(Default, WebApiObject)]+#[webapi(fragment, prototype = "BaseAudioContext", enumerable, receiver = web_api_interfaces::BaseAudioContext::is_instance)]+struct BaseAudioContextSecureAttributes {+ #[webapi(accessor_property = "audioWorklet", getter = audio_worklet_getter)]+ audio_worklet: (),+}++pub(super) fn finalize_base_audio_context_realm_bindings<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ prototype: v8::Local<'s, v8::Object>,+) -> Result<()> {+ let global = scope.get_current_context().global(scope);+ if super::runtime_state::window_realm_secure_context_available(scope, global) {+ BaseAudioContextSecureAttributes::default()+ .initialize(scope, prototype)+ .map_err(|error| anyhow!(error))?;+ }+ Ok(())+}++fn audio_worklet_getter<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'s, v8::Value>,) {- let worklet = args.this();- let Some(context) = web_audio_object_slot(scope, worklet, AUDIO_WORKLET_CONTEXT_SLOT) else {- let error = type_error_value(- scope,- "AudioWorklet.addModule called on incompatible receiver.",- )- .unwrap_or_else(|| v8::undefined(scope).into());- set_rejected_promise_return(scope, &mut rv, error);+ let context = args.this();+ if let Some(worklet) = web_audio_object_slot(scope, context, AUDIO_CONTEXT_WORKLET_SLOT) {+ rv.set(worklet.into());+ return;+ }+ let Some(realm) = context.get_creation_context(scope) else {return;};- let Some(module_url) = resolve_audio_worklet_module_url(scope, args.get(0)) else {- let error = type_error_value(scope, "AudioWorklet.addModule module URL is invalid.")- .unwrap_or_else(|| v8::undefined(scope).into());- set_rejected_promise_return(scope, &mut rv, error);+ let scope = &mut v8::ContextScope::new(scope, realm);+ let Ok(prototype) = ensure_intrinsic_interface_prototype(scope, "AudioWorklet") else {return;};- let credentials = match audio_worklet_credentials(scope, &args) {- Ok(credentials) => credentials,- Err(message) => {- let error =- type_error_value(scope, &message).unwrap_or_else(|| v8::undefined(scope).into());- set_rejected_promise_return(scope, &mut rv, error);- return;+ let worklet = AudioWorkletObjectDeclaration::new(prototype, context)+ .bind(scope)+ .expect("AudioWorklet declaration should bind");+ set_private_value(scope, context, AUDIO_CONTEXT_WORKLET_SLOT, worklet.into());+ rv.set(worklet.into());+}++#[derive(Clone, Copy, Default, webidl::WebIdlEnum)]+#[webidl(name = "RequestCredentials", rename_all = "kebab-case")]+enum WorkletCredentials {+ Omit,+ #[default]+ SameOrigin,+ Include,+}++impl WorkletCredentials {+ fn as_str(self) -> &'static str {+ match self {+ Self::Omit => "omit",+ Self::SameOrigin => "same-origin",+ Self::Include => "include",}+ }+}++#[derive(Default, webidl::WebIdlDictionary)]+#[webidl(prefix = "WorkletOptions")]+struct WorkletOptions {+ #[webidl(converter = "enum", default = WorkletCredentials::SameOrigin)]+ credentials: WorkletCredentials,+}++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "Worklet.addModule")]+struct WorkletAddModuleArgs {+ #[webidl(required, converter = "usv_string")]+ module_url: String,+ #[webidl(with = worklet_options_arg)]+ options: WorkletOptions,+}++fn worklet_options_arg<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ index: i32,+) -> Result<WorkletOptions, webidl::WebIdlError> {+ webidl::parse_dictionary(+ scope,+ args.get(index),+ webidl::Context::argument("Worklet.addModule", 2),+ )+ .map(Option::unwrap_or_default)+}++fn audio_worklet_add_module_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ let Some(parsed) = webidl::parse_args::<WorkletAddModuleArgs>(scope, &args) else {+ return;};- let Some(modules) = web_audio_object_slot(scope, context, AUDIO_CONTEXT_MODULES_SLOT) else {- let error = type_error_value(scope, "AudioWorklet context state is unavailable.")- .unwrap_or_else(|| v8::undefined(scope).into());- set_rejected_promise_return(scope, &mut rv, error);+ let worklet = args.this();+ let Some(context) = web_audio_object_slot(scope, worklet, AUDIO_WORKLET_CONTEXT_SLOT) else {+ throw_type_error(scope, "AudioWorklet context state is unavailable.");return;};- if let Some(existing_module) = map_get_object(scope, modules, &module_url)- && let Some(promise) =- get_private_value(scope, existing_module, AUDIO_WORKLET_MODULE_PROMISE_SLOT)- .and_then(|value| v8::Local::<v8::Promise>::try_from(value).ok())- {- rv.set(promise.into());+ // Argument conversion failures use the method's realm. The operation's+ // Promise, URL resolution and workers use the Worklet's relevant realm.+ let Some(realm) = worklet.get_creation_context(scope) else {return;- }-+ };+ let scope = &mut v8::ContextScope::new(scope, realm);let Some(resolver) = v8::PromiseResolver::new(scope) else {- rv.set_undefined();return;};let promise = resolver.get_promise(scope);- let Some(worker) = create_audio_worklet_module_worker(scope, &module_url, credentials) else {+ rv.set(promise.into());+ let Some(module_url) = resolve_audio_worklet_module_url(scope, &parsed.module_url) else {+ let error = new_dom_exception_value(+ scope,+ "AudioWorklet.addModule module URL is invalid.",+ "SyntaxError",+ );+ let _ = resolver.reject(scope, error);+ return;+ };+ let Some(modules) = web_audio_object_slot(scope, context, AUDIO_CONTEXT_MODULES_SLOT) else {+ let error = v8::Exception::type_error(+ scope,+ v8str(scope, "AudioWorklet context state is unavailable."),+ );+ let _ = resolver.reject(scope, error);+ return;+ };+ if let Some(module_state) = map_get_object(scope, modules, &module_url) {+ if audio_worklet_module_bool_slot(scope, module_state, AUDIO_WORKLET_MODULE_SETTLED_SLOT) {+ if audio_worklet_module_bool_slot(scope, module_state, AUDIO_WORKLET_MODULE_LOADED_SLOT)+ {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ } else if let Some(error) =+ get_private_value(scope, module_state, AUDIO_WORKLET_MODULE_ERROR_SLOT)+ {+ let _ = resolver.reject(scope, error);+ }+ } else if let Some(resolvers) =+ web_audio_array_slot(scope, module_state, AUDIO_WORKLET_MODULE_RESOLVERS_SLOT)+ {+ let key = v8_string(scope, &resolvers.length().to_string()).expect("array index");+ let _ = resolvers.create_data_property(scope, key.into(), resolver.into());+ }+ return;+ }+ let Some(worker) =+ create_audio_worklet_module_worker(scope, &module_url, parsed.options.credentials.as_str())+ else {let error = type_error_value(scope, "AudioWorklet module failed.").unwrap_or_else(|| v8::undefined(scope).into());let _ = resolver.reject(scope, error);- rv.set(promise.into());return;};-+ let resolvers = v8::Array::new_with_elements(scope, &[resolver.into()]);let module_state =- AudioWorkletModuleStateDeclaration::new(context, worker, promise, resolver, false, false)+ AudioWorkletModuleStateDeclaration::new(context, worker, resolvers, false, false).bind(scope).expect("AudioWorklet module state declaration should bind");install_audio_worklet_worker_callbacks(scope, worker, module_state);let _ = map_set_object(scope, modules, &module_url, module_state);if let Some(module_list) = web_audio_array_slot(scope, context, AUDIO_CONTEXT_MODULE_LIST_SLOT){- array_push_value(scope, module_list, module_state.into());+ let key = v8_string(scope, &module_list.length().to_string()).expect("array index");+ let _ = module_list.create_data_property(scope, key.into(), module_state.into());}-- rv.set(promise.into());}fn install_audio_worklet_worker_callbacks<'s>(@@ -756,35 +851,12 @@ fn audio_worklet_worker_message_callback<'s>(};let _ = map_set_object(scope, processors, &name, module_state);}- "module-loaded" => {- if audio_worklet_module_bool_slot(- scope,- module_state,- AUDIO_WORKLET_MODULE_SETTLED_SLOT,- ) {- return;- }- set_audio_worklet_module_bool_slot(- scope,- module_state,- AUDIO_WORKLET_MODULE_LOADED_SLOT,- true,- );- set_audio_worklet_module_bool_slot(- scope,- module_state,- AUDIO_WORKLET_MODULE_SETTLED_SLOT,- true,- );- if let Some(resolver) = audio_worklet_module_resolver(scope, module_state) {- let _ = resolver.resolve(scope, v8::undefined(scope).into());- }- }+ "module-loaded" => settle_audio_worklet_module(scope, module_state, Ok(())),"processor-error" => {let message = object_string_property(scope, message, "message").unwrap_or_else(|| "AudioWorklet processor failed.".to_owned());let error = error_value(scope, &message).unwrap_or_else(|| v8::undefined(scope).into());- fail_audio_worklet_module(scope, module_state, error);+ settle_audio_worklet_module(scope, module_state, Err(error));}_ => {}}@@ -793,7 +865,7 @@ fn audio_worklet_worker_message_callback<'s>(fn audio_worklet_worker_error_callback<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'s, v8::Value>,+ mut rv: v8::ReturnValue<'s, v8::Value>,) {let Some(module_state) = audio_worklet_callback_module_state(scope, &args) else {return;@@ -807,7 +879,10 @@ fn audio_worklet_worker_error_callback<'s>(}).unwrap_or_else(|| "AudioWorklet module failed.".to_owned());let error = error_value(scope, &message).unwrap_or_else(|| v8::undefined(scope).into());- fail_audio_worklet_module(scope, module_state, error);+ settle_audio_worklet_module(scope, module_state, Err(error));+ // This internal worker failure is reported through addModule's Promise.+ // Cancel the handled error instead of reporting it again on Window.+ rv.set_bool(false);}fn audio_worklet_node_constructor_callback<'s>(@@ -884,28 +959,6 @@ fn audio_worklet_node_constructor_callback<'s>(rv.set(node.into());}-fn set_rejected_promise_return<'s>(- scope: &mut v8::PinScope<'s, '_>,- rv: &mut v8::ReturnValue<'s, v8::Value>,- error: v8::Local<'s, v8::Value>,-) {- if let Some(promise) = rejected_promise(scope, error) {- rv.set(promise.into());- } else {- rv.set(v8::undefined(scope).into());- }-}--fn rejected_promise<'s>(- scope: &mut v8::PinScope<'s, '_>,- error: v8::Local<'s, v8::Value>,-) -> Option<v8::Local<'s, v8::Promise>> {- let resolver = v8::PromiseResolver::new(scope)?;- let promise = resolver.get_promise(scope);- let _ = resolver.reject(scope, error);- Some(promise)-}-fn resolved_undefined_promise<'s>(scope: &mut v8::PinScope<'s, '_>,) -> Option<v8::Local<'s, v8::Promise>> {@@ -958,50 +1011,23 @@ fn map_set_object<'s>(fn resolve_audio_worklet_module_url(scope: &mut v8::PinScope<'_, '_>,- value: v8::Local<'_, v8::Value>,+ input: &str,) -> Option<String> {- let input = value.to_string(scope)?.to_rust_string_lossy(scope);- let base_url = if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) {- let host = unsafe { &*host_ptr };- super::worker_host::worker_constructor_base_url(host)- } else {- let global = scope.get_current_context().global(scope);- let location = object_property_as_object(scope, global, "location")?;- let href = object_string_property(scope, location, "href")?;- url::Url::parse(&href).ok()?- };- base_url.join(&input).ok().map(|url| url.to_string())-}+ use crate::native_bridge::OwnerDispatchScope;-fn audio_worklet_credentials(- scope: &mut v8::PinScope<'_, '_>,- args: &v8::FunctionCallbackArguments<'_>,-) -> std::result::Result<&'static str, String> {- let value = args.get(1);- if value.is_undefined() || value.is_null() {- return Ok("same-origin");- }- let Ok(options) = v8::Local::<v8::Object>::try_from(value) else {- return Ok("same-origin");- };- let Some(credentials) = options.get(scope, v8str(scope, "credentials").into()) else {- return Ok("same-origin");- };- if credentials.is_undefined() {- return Ok("same-origin");- }- let Some(credentials) = credentials.to_string(scope) else {- return Err("AudioWorklet.addModule options.credentials is invalid.".to_owned());+ let host_ptr = context_host_ptr_from_global_bridge(scope)?;+ // SAFETY: the bridge owns the host for the lifetime of the callback.+ let host = unsafe { &*host_ptr };+ let global = scope.get_current_context().global(scope);+ let document = match super::navigation_window::runtime_window_dispatch_scope(scope, global)? {+ OwnerDispatchScope::Top => host.document_handle(),+ OwnerDispatchScope::Child(handle) => host.child_browsing_context_document_handle(handle)?,+ OwnerDispatchScope::LightweightPopup(id) => host.lightweight_popup_document_handle(id)?,};- let credentials = credentials.to_rust_string_lossy(scope);- match credentials.as_str() {- "omit" => Ok("omit"),- "same-origin" => Ok("same-origin"),- "include" => Ok("include"),- _ => Err(format!(- "The provided value '{credentials}' is not a valid enum value of type RequestCredentials."- )),- }+ host.document_base_url_for_handle(document)+ .join(input)+ .ok()+ .map(|url| url.to_string())}fn create_audio_worklet_module_worker<'s>(@@ -1176,10 +1202,10 @@ fn audio_worklet_callback_module_state<'s>(web_audio_object_slot(scope, data, AUDIO_WORKLET_CALLBACK_MODULE_SLOT)}-fn fail_audio_worklet_module<'s>(+fn settle_audio_worklet_module<'s>(scope: &mut v8::PinScope<'s, '_>,module_state: v8::Local<'s, v8::Object>,- error: v8::Local<'s, v8::Value>,+ result: Result<(), v8::Local<'s, v8::Value>>,) {if audio_worklet_module_bool_slot(scope, module_state, AUDIO_WORKLET_MODULE_SETTLED_SLOT) {return;@@ -1190,8 +1216,45 @@ fn fail_audio_worklet_module<'s>(AUDIO_WORKLET_MODULE_SETTLED_SLOT,true,);- if let Some(resolver) = audio_worklet_module_resolver(scope, module_state) {- let _ = resolver.reject(scope, error);+ set_audio_worklet_module_bool_slot(+ scope,+ module_state,+ AUDIO_WORKLET_MODULE_LOADED_SLOT,+ result.is_ok(),+ );+ if let Err(error) = result {+ set_private_value(scope, module_state, AUDIO_WORKLET_MODULE_ERROR_SLOT, error);+ }+ let Some(resolvers) =+ web_audio_array_slot(scope, module_state, AUDIO_WORKLET_MODULE_RESOLVERS_SLOT)+ else {+ return;+ };+ // Drop the state's references before settling, and never invoke author+ // Promise.then / constructor properties to join a module response.+ set_private_value(+ scope,+ module_state,+ AUDIO_WORKLET_MODULE_RESOLVERS_SLOT,+ v8::undefined(scope).into(),+ );+ for index in 0..resolvers.length() {+ let Some(value) = resolvers.get_index(scope, index) else {+ continue;+ };+ let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {+ continue;+ };+ // Only native PromiseResolvers are written to this private array.+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(object) };+ match result {+ Ok(()) => {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+ Err(error) => {+ let _ = resolver.reject(scope, error);+ }+ }}}@@ -1215,15 +1278,6 @@ fn set_audio_worklet_module_bool_slot<'s>(set_private_value(scope, object, slot, value.into());}-fn audio_worklet_module_resolver<'s>(- scope: &mut v8::PinScope<'s, '_>,- object: v8::Local<'s, v8::Object>,-) -> Option<v8::Local<'s, v8::PromiseResolver>> {- get_private_value(scope, object, AUDIO_WORKLET_MODULE_RESOLVER_SLOT)- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())- .map(|object| unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(object) })-}-fn dynamics_compressor_reduction_getter_callback<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,@@ -1272,6 +1326,22 @@ pub(in crate::context_bootstrap) fn offline_audio_context_constructor_callback<'let context = args.this();let destination = audio_destination_node(scope, context);let compressors = v8::Array::new(scope, 0);+ let modules = new_web_audio_map_object(scope);+ let module_list = v8::Array::new(scope, 0);+ let processors = new_web_audio_map_object(scope);+ set_private_value(scope, context, AUDIO_CONTEXT_MODULES_SLOT, modules.into());+ set_private_value(+ scope,+ context,+ AUDIO_CONTEXT_MODULE_LIST_SLOT,+ module_list.into(),+ );+ set_private_value(+ scope,+ context,+ AUDIO_CONTEXT_PROCESSORS_SLOT,+ processors.into(),+ );OfflineAudioContextObjectDeclaration::new(0.0,length,diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker/audio_worklet_and_message_ports.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker/audio_worklet_and_message_ports.rsindex 0f7da7ac8..14b86962c 100644--- a/moli-renderer-v8/src/runtime/page_vm/tests/worker/audio_worklet_and_message_ports.rs+++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker/audio_worklet_and_message_ports.rs@@ -227,7 +227,14 @@ async fn audio_worklet_close_rejects_pending_add_module_response() {globalThis.__audioWorkletCloseDone = false;const context = new AudioContext();globalThis.__audioWorkletCloseContext = context;- context.audioWorklet.addModule({module_url_literal}).then(+ const first = context.audioWorklet.addModule({module_url_literal});+ const second = context.audioWorklet.addModule({module_url_literal});+ Promise.allSettled([first, second]).then(results => {{+ if (first === second || results.some(result => result.status !== "rejected" || result.reason.name !== "AbortError")) {{+ throw new Error("Every pending caller must independently reject on close");+ }}+ throw results[0].reason;+ }}).then(() => {{globalThis.__audioWorkletCloseResult = "resolved";globalThis.__audioWorkletCloseDone = true;@@ -1447,3 +1454,47 @@ async fn worker_owned_messageport_options_transfer_null_clone_path_responds() {}).await;}++#[tokio::test]+async fn worklet_module_promises_preserve_independent_native_waiters() {+ run_page_vm_async_test(async move {+ let mut page_vm = test_page_vm_with_document_url(Url::parse("https://worklet-promises.test/").unwrap());+ let local_executor = page_vm.local_executor.clone();+ let result = local_executor.run(async move {+ page_vm.vm_mut().eval(&format!("({}).then(value => globalThis.__workletDone = value, error => globalThis.__workletDone = String(error));", include_str!("../../../../script_vm/tests/worklet_module_promises.js")))?;+ drive_websocket_until_done(&mut page_vm, "String(globalThis.__workletDone !== undefined)", "Worklet module waiters should settle").await?;+ page_vm.vm_mut().eval("JSON.stringify(__nodeReplacementResults.failures)")+ }).await.expect("Worklet module fixture should complete");+ assert_eq!(result, "[]");+ }).await;+}++#[tokio::test]+async fn borrowed_worklet_add_module_uses_receiver_document_base() {+ run_page_vm_async_test(async move {+ let (base_url, request_rx, server) = spawn_shared_worker_script_capture_http_server(+ "registerProcessor('receiver-base', class extends AudioWorkletProcessor {});",+ ).await;+ let mut page_vm = test_page_vm_with_document_url(Url::parse(&format!("{base_url}/main/page.html")).unwrap());+ let base = serde_json::to_string(&format!("{base_url}/worklet/")).unwrap();+ let local_executor = page_vm.local_executor.clone();+ let result = local_executor.run(async move {+ page_vm.vm_mut().eval(&format!(r#"+ const frame = document.createElement('iframe'); document.body.append(frame);+ const other = frame.contentWindow;+ const base = other.document.createElement('base'); base.href = {base}; other.document.head.append(base);+ const context = new other.AudioContext();+ Worklet.prototype.addModule.call(context.audioWorklet, 'entry.js').then(() => {{+ globalThis.__receiverBaseResult = String(new other.AudioWorkletNode(context, 'receiver-base') instanceof other.AudioWorkletNode);+ return context.close();+ }}).catch(error => globalThis.__receiverBaseResult = String(error));+ "#))?;+ drive_websocket_until_done(&mut page_vm, "String(globalThis.__receiverBaseResult !== undefined)", "borrowed addModule should settle").await?;+ page_vm.vm_mut().eval("__receiverBaseResult")+ }).await.expect("receiver base URL test should complete");+ assert_eq!(result, "true");+ let request = request_rx.await.expect("module request");+ assert!(request.starts_with("GET /worklet/entry.js "), "{request}");+ server.await.expect("server should finish");+ }).await;+}diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex 730f32681..7cf085e16 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -2156,6 +2156,7 @@ mod webidl_receivers;mod webidl_trusted_types;mod websocket;mod window_execution_context;+mod worklet_interfaces;mod string_timers;diff --git a/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.js b/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.jsnew file mode 100644index 000000000..e0fa5cb21--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.js@@ -0,0 +1,88 @@+(async () => {+ const rows = [], assert = (ok, message) => { if (!ok) throw Error(message); };+ const check = async (name, run) => { try { await run(); rows.push({ name, pass: true }); } catch (error) { rows.push({ name, pass: false, message: String(error) }); } };+ const realms = [['main', window], ['child', document.getElementById('child').contentWindow]];+ for (const [label, w] of realms) {+ if (!w.isSecureContext) {+ await check(label + '/insecure', () => assert(!('Worklet' in w) && !('AudioWorklet' in w) && !('audioWorklet' in w.BaseAudioContext.prototype) && !('audioWorklet' in new w.OfflineAudioContext(1,1,44100)), 'secure globals and attribute hidden'));+ continue;+ }+ for (const name of ['Worklet', 'AudioWorklet']) {+ await check(label + '/' + name, () => {+ const C = w[name], parent = name === 'AudioWorklet' ? w.Worklet : w.Object;+ const d = Object.getOwnPropertyDescriptor(w, name);+ assert(typeof C === 'function' && C.name === name && C.length === 0, 'constructor metadata');+ assert(d.writable && d.configurable && !d.enumerable, 'global descriptor');+ assert(Object.getPrototypeOf(C.prototype) === parent.prototype && Object.getPrototypeOf(C) === (parent === w.Object ? w.Function.prototype : parent), 'native inheritance');+ const tag = Object.getOwnPropertyDescriptor(C.prototype, Symbol.toStringTag);+ assert(tag.value === name && tag.configurable && !tag.writable && !tag.enumerable, 'prototype tag');+ for (const call of [() => C(), () => new C()]) { let error; try { call(); } catch (e) { error = e; } assert(error instanceof w.TypeError, 'illegal constructor'); }+ });+ }+ await check(label + '/receiver', async () => {+ const method = w.Worklet.prototype.addModule, d = Object.getOwnPropertyDescriptor(w.Worklet.prototype, 'addModule');+ assert(method.length === 1 && d.enumerable && d.configurable && d.writable, 'shared operation descriptor');+ let conversions = 0, traps = 0; const trap = () => { traps++; throw Error('author trap'); };+ const url = { toString() { conversions++; return 'data:text/javascript,'; } }, options = { get credentials() { conversions++; return 'same-origin'; } };+ const revoked = Proxy.revocable({}, {}); revoked.revoke();+ for (const receiver of [null, {}, w.Worklet.prototype, w.AudioWorklet.prototype, Object.create(w.Worklet.prototype), new Proxy({}, { get: trap, getPrototypeOf: trap }), revoked.proxy]) {+ const promise = method.call(receiver, url, options); assert(promise instanceof w.Promise, 'callee Promise');+ let error; try { await promise; } catch (e) { error = e; } assert(error instanceof w.TypeError, 'callee TypeError rejection');+ }+ assert(conversions === 0 && traps === 0, 'receiver validation precedes author callbacks');+ });+ let context;+ try {+ await check(label + '/native-factory', () => {+ const C = w.AudioWorklet, descriptor = Object.getOwnPropertyDescriptor(w, 'AudioWorklet'); let reads = 0;+ Object.defineProperty(w, 'AudioWorklet', { configurable: true, get() { reads++; throw Error('author constructor'); } });+ try { context = new w.AudioContext(); } finally { if (descriptor) Object.defineProperty(w, 'AudioWorklet', descriptor); else delete w.AudioWorklet; }+ const worklet = context.audioWorklet;+ const d = Object.getOwnPropertyDescriptor(w.BaseAudioContext.prototype, 'audioWorklet');+ assert(d && typeof d.get === 'function' && d.set === undefined && d.enumerable && d.configurable && !Object.hasOwn(context, 'audioWorklet'), 'shared readonly attribute');+ const offline = new w.OfflineAudioContext(1, 1, 44100);+ assert(Object.getPrototypeOf(offline.audioWorklet) === C.prototype && offline.audioWorklet === offline.audioWorklet, 'offline worklet');+ assert(d.get.call(context) === worklet, 'genuine receiver');+ for (const value of [{}, Object.create(context), new Proxy(context, {})]) { let error; try {d.get.call(value);} catch(e) {error=e;} assert(error instanceof w.TypeError, 'getter receiver'); }+ assert(Object.getPrototypeOf(worklet) === C.prototype && worklet instanceof w.Worklet, 'native derived prototype');+ assert(worklet === context.audioWorklet && !Object.hasOwn(worklet, 'addModule') && worklet.addModule === w.Worklet.prototype.addModule && reads === 0, 'shared operation and intrinsic factory');+ });+ await check(label + '/argument-conversion', async () => {+ const worklet = context.audioWorklet;+ for (const args of [[], [Symbol()], ['data:text/javascript,', 7], ['data:text/javascript,', {credentials:'invalid'}]]) {+ let error; const promise=worklet.addModule(...args); assert(promise instanceof w.Promise, 'conversion rejection is Promise');+ try { await promise; } catch (e) { error=e; } assert(error instanceof w.TypeError, 'invalid arguments');+ }+ const sentinel = {}, order=[]; let error;+ const promise=worklet.addModule({toString(){order.push('url');return 'data:text/javascript,';}},{get credentials(){order.push('credentials');return {toString(){order.push('string');throw sentinel;}};}});+ try { await promise; } catch (e) {error=e;}+ assert(error===sentinel && order.join()==='url,credentials,string', 'dictionary order and original exception');+ });+ await check(label + '/invalid-url', async () => {+ let error;+ try { await context.audioWorklet.addModule('https://['); } catch(e) {error=e;}+ assert(error instanceof w.DOMException && error.name === 'SyntaxError', 'invalid URL DOMException');+ const sentinel = {};+ try { await context.audioWorklet.addModule('https://[', {get credentials(){throw sentinel;}}); } catch(e) {error=e;}+ assert(error === sentinel, 'dictionary conversion before URL parsing');+ });+ await check(label + '/cross-realm', async () => {+ const other = realms.find(([,r]) => r !== w)[1];+ const otherContext = new other.AudioContext();+ try {+ const getter = Object.getOwnPropertyDescriptor(w.BaseAudioContext.prototype, 'audioWorklet').get;+ const receiver = getter.call(otherContext);+ assert(Object.getPrototypeOf(receiver) === other.AudioWorklet.prototype, 'getter uses receiver realm');+ const p = w.Worklet.prototype.addModule.call(receiver, 'https://[');+ let error; try {await p;} catch(e) {error=e;}+ assert(p instanceof other.Promise && error instanceof other.DOMException && error.name === 'SyntaxError', 'valid receiver realm');+ const invalid = w.Worklet.prototype.addModule.call(receiver, Symbol());+ try {await invalid;} catch(e) {error=e;}+ assert(invalid instanceof w.Promise && error instanceof w.TypeError, 'conversion rejection callee realm');+ } finally {await otherContext.close();}+ });+ } finally { if (context) await context.close(); }+ }+ globalThis.__nodeReplacementResults={rows,failures:rows.filter(row=>!row.pass),passed:rows.filter(row=>row.pass).length,total:rows.length};+ return rows.every(row=>row.pass);+})()diff --git a/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.rs b/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.rsnew file mode 100644index 000000000..a107c15c1--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/worklet_interfaces.rs@@ -0,0 +1,21 @@+use super::*;++#[test]+fn worklet_interfaces_preserve_realms_brands_and_secure_exposure() {+ for url in [+ "https://worklet-interfaces.test/",+ "http://worklet-interfaces.test/",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm(url);+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")+ .unwrap();+ vm.eval(&format!("({}).then(value => globalThis.__workletDone = value, error => globalThis.__workletDone = String(error));", include_str!("worklet_interfaces.js"))).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("JSON.stringify(__nodeReplacementResults.failures)")+ .unwrap(),+ "[]",+ "{url}"+ );+ assert_eq!(vm.eval("__workletDone").unwrap(), "true", "{url}");+ }+}diff --git a/moli-renderer-v8/src/script_vm/tests/worklet_module_promises.js b/moli-renderer-v8/src/script_vm/tests/worklet_module_promises.jsnew file mode 100644index 000000000..48d5f85b0--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/worklet_module_promises.js@@ -0,0 +1,49 @@+(async () => {+ const rows = [], assert = (ok, message) => { if (!ok) throw Error(message); };+ const check = async (name, run) => { try { await run(); rows.push({ name, pass: true }); } catch (error) { rows.push({ name, pass: false, message: String(error) }); } };+ const context = new AudioContext(), worklet = context.audioWorklet;+ const source = text => 'data:text/javascript,' + encodeURIComponent(text);+ const errors = [], onError = event => errors.push(event.message);+ addEventListener('error', onError);+ try {+ await check('pending-and-completed-module-promises', async () => {+ const url = source('registerProcessor("fresh-promise", class extends AudioWorkletProcessor {});');+ const first = worklet.addModule(url); let reads=0;+ const poison = () => {reads++; throw Error('public Promise property');};+ Object.defineProperties(first, {then:{get:poison,configurable:true}, constructor:{get:poison,configurable:true}});+ let second;+ // A second call appends a native waiter; inherited array setters must not run.+ Object.defineProperty(Array.prototype, '1', {configurable:true, set:poison});+ try {second = worklet.addModule(url);} finally {delete Array.prototype[1];delete first.then;delete first.constructor;}+ assert(reads===0 && first!==second, 'independent pending Promise without author hooks');+ const values = await Promise.all([first, second]);+ assert(values.every(value => value===undefined), 'all callers fulfilled');+ Object.defineProperties(first, {then:{get:poison,configurable:true}, constructor:{get:poison,configurable:true}});+ let third;+ try {third=worklet.addModule(url);} finally {delete first.then;delete first.constructor;}+ assert(reads===0 && third!==first && third!==second, 'independent completed Promise');+ assert(await third === undefined, 'completed response reused');+ assert(new AudioWorkletNode(context, 'fresh-promise') instanceof AudioWorkletNode, 'processor registration retained');+ });+ await check('failed-module-promises', async () => {+ const url=source('export {');+ const first=worklet.addModule(url), second=worklet.addModule(url);+ assert(first!==second, 'independent failed pending Promise');+ const results=await Promise.allSettled([first,second]);+ assert(results.every(result=>result.status==='rejected'), 'all failed waiters settle');+ const third=worklet.addModule(url);assert(third!==first && third!==second, 'independent rejected cached Promise');+ const [result]=await Promise.allSettled([third]);assert(result.status==='rejected', 'cached failure settles');+ assert(errors.length === 0, 'module rejection does not report internal Worker error on Window');+ });+ await check('offline-worklet-module', async () => {+ const offline=new OfflineAudioContext(1,1,44100);+ const url=source('registerProcessor("offline-module", class extends AudioWorkletProcessor {});');+ await offline.audioWorklet.addModule(url);+ const node=new AudioWorkletNode(offline, 'offline-module');+ assert(node instanceof AudioWorkletNode, 'offline processor registered');+ node.connect(offline.destination);+ });+ } finally {removeEventListener('error', onError);await context.close();}+ globalThis.__nodeReplacementResults={rows,failures:rows.filter(row=>!row.pass),passed:rows.filter(row=>row.pass).length,total:rows.length};+ return rows.every(row=>row.pass);+})()diff --git a/moli-renderer-v8/src/util.rs b/moli-renderer-v8/src/util.rsindex a47c10134..3b9cdb8b3 100644--- a/moli-renderer-v8/src/util.rs+++ b/moli-renderer-v8/src/util.rs@@ -13,8 +13,8 @@ pub use moli_v8_util::{object_own_static_string_property, object_property_as_array, object_property_as_object,object_string_property, private_key, register_intrinsic_interface,registered_intrinsic_constructor, registered_intrinsic_prototype, set_null_prototype,- set_private_value, set_symbol_to_string_tag, throw_range_error, throw_type_error,- v8_json_parse, v8_string, v8str, walk_object_chain,+ set_private_value, throw_range_error, throw_type_error, v8_json_parse, v8_string, v8str,+ walk_object_chain,};use moli_webapi_declare::WebApiValue;pub(crate) use moli_webapi_declare::define_array_data_property as define_v8_array_data_property;diff --git a/moli-renderer-v8/src/web_api_interfaces.rs b/moli-renderer-v8/src/web_api_interfaces.rsindex 7f531fa94..7e4bb8f88 100644--- a/moli-renderer-v8/src/web_api_interfaces.rs+++ b/moli-renderer-v8/src/web_api_interfaces.rs@@ -35,7 +35,8 @@ interfaces! {AudioContext: BaseAudioContext;AudioDestinationNode;AudioParam;- AudioWorklet;+ Worklet;+ AudioWorklet: Worklet;AudioWorkletNode;BaseAudioContext: EventTarget;BatteryManager;diff --git a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs b/moli-renderer-v8/src/worker/thread/tests/postmessage.rsindex 6220e689e..6a50f1173 100644--- a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs+++ b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs@@ -1889,6 +1889,24 @@ async fn worker_self_close() {// ─── Error propagation ──────────────────────────────────────────────+#[tokio::test]+async fn worker_does_not_expose_window_worklet_interfaces() {+ ensure_v8();+ let mut handle = spawn_worker(+ "postMessage({Worklet: 'Worklet' in self, AudioWorklet: 'AudioWorklet' in self}); close();"+ .to_owned(),+ "https://worklet-worker.test/worker.js".into(),+ );+ let message = timeout(TIMEOUT, handle.recv())+ .await+ .expect("timed out")+ .expect("channel closed");+ assert_eq!(+ expect_post_json(message),+ r#"{"Worklet":false,"AudioWorklet":false}"#+ );+}+#[tokio::test]async fn worker_error_propagation() {ensure_v8();