Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(workers): inherit EventTarget across worker global scopes

ldm0b75e26fca272
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index 74ca8de5c..eb7eacabd 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -585,6 +585,13 @@ pub(crate) fn install_worker_lazy_exposed_interfaces<'s>(
.map_err(|error| anyhow!("failed to initialize worker caches accessor: {error}"))
}
+pub(crate) fn prepare_worker_event_target_template<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ realm_kind: exposed_interfaces::RealmKind,
+) -> Result<v8::Local<'s, v8::FunctionTemplate>> {
+ exposed_interfaces::prepare_worker_event_target_template(scope, realm_kind, constructor_specs())
+}
+
pub(in crate::context_bootstrap) fn build_profiled_exposed_interface_template<'s>(
scope: &mut v8::PinScope<'s, '_, ()>,
spec: self::specs::ConstructorSpec,
diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs
index cce5e6d81..51f8f2668 100644
--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs
+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs
@@ -64,11 +64,7 @@ pub(in crate::context_bootstrap) fn install_worker_exposed_interfaces<'s>(
secure_context: bool,
specs: Vec<ConstructorSpec>,
) -> Result<()> {
- let registry = ExposedInterfaceTemplateRegistry::install(
- scope,
- specs,
- TemplateBuildProfile::for_realm(realm_kind),
- )?;
+ let registry = worker_interface_template_registry(scope, realm_kind, specs)?;
IntrinsicInterfaceRegistry::initialize_for_current_context(scope, registry.len(), realm_kind)?;
for metadata in registry.metadata_entries() {
@@ -100,6 +96,36 @@ pub(in crate::context_bootstrap) fn install_worker_exposed_interfaces<'s>(
Ok(())
}
+pub(in crate::context_bootstrap) fn prepare_worker_event_target_template<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ realm_kind: RealmKind,
+ specs: Vec<ConstructorSpec>,
+) -> Result<v8::Local<'s, v8::FunctionTemplate>> {
+ let registry = worker_interface_template_registry(scope, realm_kind, specs)?;
+ let event_target_id = registry
+ .id_by_name("EventTarget")
+ .ok_or_else(|| anyhow!("worker interface registry is missing EventTarget"))?;
+ registry.get_or_build_template(scope, event_target_id)
+}
+
+fn worker_interface_template_registry<C>(
+ scope: &mut v8::PinScope<'_, '_, C>,
+ realm_kind: RealmKind,
+ specs: Vec<ConstructorSpec>,
+) -> Result<Rc<ExposedInterfaceTemplateRegistry>> {
+ let expected_profile = TemplateBuildProfile::for_realm(realm_kind);
+ if let Some(registry) = ExposedInterfaceTemplateRegistry::current(scope) {
+ if registry.profile() != expected_profile {
+ return Err(anyhow!(
+ "worker interface registry profile mismatch: expected {expected_profile:?}, got {:?}",
+ registry.profile()
+ ));
+ }
+ return Ok(registry);
+ }
+ ExposedInterfaceTemplateRegistry::install(scope, specs, expected_profile)
+}
+
pub(crate) fn filter_window_exposed_interfaces(
scope: &mut v8::PinScope<'_, '_>,
global: v8::Local<'_, v8::Object>,
diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs
index edc261971..eb9e78fc3 100644
--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs
+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/mod.rs
@@ -12,6 +12,7 @@ pub(super) use install::{
filter_window_exposed_interfaces, initialize_realm_interface_registry,
install_interface_template_metadata, install_window_exposed_interfaces,
install_worker_exposed_interfaces, is_lazy_exposed_interface,
+ prepare_worker_event_target_template,
};
#[cfg(test)]
pub(crate) use install::{
diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/template_registry.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/template_registry.rs
index 6345c3798..411057fd3 100644
--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/template_registry.rs
+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/template_registry.rs
@@ -81,8 +81,12 @@ impl ExposedInterfaceTemplateRegistry {
.ok_or_else(|| anyhow!("exposed interface template registry was already installed"))
}
- pub(super) fn current(scope: &mut v8::PinScope<'_, '_>) -> Option<Rc<Self>> {
- scope.get_slot::<Rc<Self>>().cloned()
+ pub(super) fn current<C>(scope: &mut v8::PinScope<'_, '_, C>) -> Option<Rc<Self>> {
+ scope.as_mut().get_slot::<Rc<Self>>().cloned()
+ }
+
+ pub(super) const fn profile(&self) -> TemplateBuildProfile {
+ self.profile
}
pub(super) fn metadata(&self, id: InterfaceId) -> Option<ExposedInterfaceMetadata> {
diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs
index 986ae5d54..703e69e15 100644
--- a/moli-renderer-v8/src/worker/global_scope/mod.rs
+++ b/moli-renderer-v8/src/worker/global_scope/mod.rs
@@ -2965,6 +2965,7 @@ pub(super) fn install_worker_global_scope<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
state: Rc<RefCell<WorkerGlobalState>>,
+ worker_templates: Option<&PreparedWorkerGlobalScopeTemplates>,
) -> Result<()> {
// Store state pointer as an external on the global so callbacks can find it.
let state_ptr = Rc::into_raw(state.clone()) as *mut c_void;
@@ -2992,18 +2993,8 @@ pub(super) fn install_worker_global_scope<'s>(
.initialize(scope, global)
.map_err(|error| anyhow!("failed to initialize worker global bootstrap properties: {error}"))?;
install_worker_performance(scope, global)?;
- install_worker_global_scope_constructors(scope, global, &global_kind)?;
- let realm_kind = match &global_kind {
- super::thread::WorkerGlobalKind::Dedicated { .. } => {
- crate::context_bootstrap::exposed_interfaces::RealmKind::DedicatedWorker
- }
- super::thread::WorkerGlobalKind::Shared { .. } => {
- crate::context_bootstrap::exposed_interfaces::RealmKind::SharedWorker
- }
- super::thread::WorkerGlobalKind::Service { .. } => {
- crate::context_bootstrap::exposed_interfaces::RealmKind::ServiceWorker
- }
- };
+ install_worker_global_scope_constructors(scope, global, &global_kind, worker_templates)?;
+ let (_, realm_kind) = worker_global_scope_interface(&global_kind);
crate::context_bootstrap::install_worker_lazy_exposed_interfaces(
scope,
global,
@@ -5473,104 +5464,144 @@ fn worker_create_image_bitmap_callback<'s>(
rv.set(promise.into());
}
-fn install_worker_global_scope_constructors<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- global: v8::Local<'s, v8::Object>,
+pub(super) struct PreparedWorkerGlobalScopeTemplates {
+ event_target: v8::Global<v8::FunctionTemplate>,
+ worker: v8::Global<v8::FunctionTemplate>,
+ specific_worker: v8::Global<v8::FunctionTemplate>,
+}
+
+impl PreparedWorkerGlobalScopeTemplates {
+ pub(super) fn global_template<'s>(
+ &self,
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ ) -> v8::Local<'s, v8::ObjectTemplate> {
+ v8::Local::new(scope, &self.specific_worker).instance_template(scope)
+ }
+}
+
+fn worker_global_scope_interface(
global_kind: &super::thread::WorkerGlobalKind,
-) -> Result<()> {
- let interface = match global_kind {
- super::thread::WorkerGlobalKind::Dedicated { .. } => "DedicatedWorkerGlobalScope",
- super::thread::WorkerGlobalKind::Shared { .. } => "SharedWorkerGlobalScope",
- super::thread::WorkerGlobalKind::Service { .. } => "ServiceWorkerGlobalScope",
- };
- web_api_interfaces::initialize(scope, global, interface)?;
- let worker_ctor = worker_scope_constructor(scope, "WorkerGlobalScope")?;
- let worker_proto = constructor_prototype(scope, worker_ctor, "WorkerGlobalScope")?;
- set_worker_to_string_tag(scope, worker_proto, "WorkerGlobalScope");
- WorkerGlobalScopeConstructorGlobalDeclaration::new(worker_ctor)
- .initialize(scope, global)
- .map_err(|error| anyhow!("failed to initialize WorkerGlobalScope global: {error}"))?;
+) -> (
+ &'static str,
+ crate::context_bootstrap::exposed_interfaces::RealmKind,
+) {
+ use crate::context_bootstrap::exposed_interfaces::RealmKind;
match global_kind {
super::thread::WorkerGlobalKind::Dedicated { .. } => {
- install_dedicated_worker_global_constructor(scope, global, worker_ctor, worker_proto)?
+ ("DedicatedWorkerGlobalScope", RealmKind::DedicatedWorker)
}
super::thread::WorkerGlobalKind::Shared { .. } => {
- install_shared_worker_global_constructor(scope, global, worker_ctor, worker_proto)?
+ ("SharedWorkerGlobalScope", RealmKind::SharedWorker)
}
super::thread::WorkerGlobalKind::Service { .. } => {
- install_service_worker_global_constructor(scope, global, worker_ctor, worker_proto)?
+ ("ServiceWorkerGlobalScope", RealmKind::ServiceWorker)
}
}
- Ok(())
}
-fn install_dedicated_worker_global_constructor<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- global: v8::Local<'s, v8::Object>,
- worker_ctor: v8::Local<'s, v8::Function>,
- worker_proto: v8::Local<'s, v8::Object>,
-) -> Result<()> {
- let dedicated_ctor = worker_scope_constructor(scope, "DedicatedWorkerGlobalScope")?;
- let dedicated_proto =
- constructor_prototype(scope, dedicated_ctor, "DedicatedWorkerGlobalScope")?;
- let _ = dedicated_proto.set_prototype(scope, worker_proto.into());
- let _ = dedicated_ctor.set_prototype(scope, worker_ctor.into());
- set_worker_to_string_tag(scope, dedicated_proto, "DedicatedWorkerGlobalScope");
- DedicatedWorkerGlobalMethodsDeclaration::default()
- .initialize(scope, dedicated_proto)
- .map_err(|error| {
- anyhow!("failed to initialize DedicatedWorkerGlobalScope methods: {error}")
- })?;
- DedicatedWorkerGlobalScopeConstructorGlobalDeclaration::new(dedicated_ctor)
- .initialize(scope, global)
- .map_err(|error| {
- anyhow!("failed to initialize DedicatedWorkerGlobalScope global: {error}")
- })?;
- let _ = global.set_prototype(scope, dedicated_proto.into());
- Ok(())
+pub(super) fn prepare_worker_global_scope_templates<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ global_kind: &super::thread::WorkerGlobalKind,
+) -> Result<PreparedWorkerGlobalScopeTemplates> {
+ let (interface, realm_kind) = worker_global_scope_interface(global_kind);
+ let event_target =
+ crate::context_bootstrap::prepare_worker_event_target_template(scope, realm_kind)?;
+ // Every object in a [Global] object's prototype chain has an immutable
+ // prototype. Install the inherited templates before creating the context.
+ event_target.prototype_template(scope).set_immutable_proto();
+
+ let worker = worker_global_scope_template(scope, "WorkerGlobalScope");
+ worker.inherit(event_target);
+ let specific_worker = worker_global_scope_template(scope, interface);
+ specific_worker.inherit(worker);
+ specific_worker
+ .instance_template(scope)
+ .set_immutable_proto();
+
+ Ok(PreparedWorkerGlobalScopeTemplates {
+ event_target: v8::Global::new(scope, event_target),
+ worker: v8::Global::new(scope, worker),
+ specific_worker: v8::Global::new(scope, specific_worker),
+ })
}
-fn install_shared_worker_global_constructor<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- global: v8::Local<'s, v8::Object>,
- worker_ctor: v8::Local<'s, v8::Function>,
- worker_proto: v8::Local<'s, v8::Object>,
-) -> Result<()> {
- let shared_ctor = worker_scope_constructor(scope, "SharedWorkerGlobalScope")?;
- let shared_proto = constructor_prototype(scope, shared_ctor, "SharedWorkerGlobalScope")?;
- let _ = shared_proto.set_prototype(scope, worker_proto.into());
- let _ = shared_ctor.set_prototype(scope, worker_ctor.into());
- set_worker_to_string_tag(scope, shared_proto, "SharedWorkerGlobalScope");
- SharedWorkerGlobalMethodsDeclaration::default()
- .initialize(scope, shared_proto)
- .map_err(|error| {
- anyhow!("failed to initialize SharedWorkerGlobalScope methods: {error}")
- })?;
- SharedWorkerGlobalScopeConstructorGlobalDeclaration::new(shared_ctor)
- .initialize(scope, global)
- .map_err(|error| anyhow!("failed to initialize SharedWorkerGlobalScope global: {error}"))?;
- let _ = global.set_prototype(scope, shared_proto.into());
- Ok(())
+fn worker_global_scope_template<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ name: &'static str,
+) -> v8::Local<'s, v8::FunctionTemplate> {
+ let template =
+ v8::FunctionTemplate::builder(worker_global_scope_constructor_callback).build(scope);
+ template.set_class_name(v8str(scope, name));
+ template.prototype_template(scope).set_immutable_proto();
+ template
}
-fn install_service_worker_global_constructor<'s>(
+fn install_worker_global_scope_constructors<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
- worker_ctor: v8::Local<'s, v8::Function>,
- worker_proto: v8::Local<'s, v8::Object>,
+ global_kind: &super::thread::WorkerGlobalKind,
+ worker_templates: Option<&PreparedWorkerGlobalScopeTemplates>,
) -> Result<()> {
- let service_ctor = worker_scope_constructor(scope, "ServiceWorkerGlobalScope")?;
- let service_proto = constructor_prototype(scope, service_ctor, "ServiceWorkerGlobalScope")?;
- let _ = service_proto.set_prototype(scope, worker_proto.into());
- let _ = service_ctor.set_prototype(scope, worker_ctor.into());
- set_worker_to_string_tag(scope, service_proto, "ServiceWorkerGlobalScope");
- ServiceWorkerGlobalScopeConstructorGlobalDeclaration::new(service_ctor)
+ let (interface, _) = worker_global_scope_interface(global_kind);
+ web_api_interfaces::initialize(scope, global, interface)?;
+ let templates = worker_templates.ok_or_else(|| {
+ anyhow!("worker global scope templates were not prepared before context creation")
+ })?;
+ let event_target_template = v8::Local::new(scope, &templates.event_target);
+ let event_target_ctor = event_target_template
+ .get_function(scope)
+ .ok_or_else(|| anyhow!("failed to instantiate worker EventTarget constructor"))?;
+ let worker_template = v8::Local::new(scope, &templates.worker);
+ let worker_ctor = worker_template
+ .get_function(scope)
+ .ok_or_else(|| anyhow!("failed to instantiate WorkerGlobalScope constructor"))?;
+ worker_ctor
+ .set_prototype(scope, event_target_ctor.into())
+ .unwrap_or(false)
+ .then_some(())
+ .ok_or_else(|| anyhow!("failed to inherit worker EventTarget constructor"))?;
+ let worker_proto = constructor_prototype(scope, worker_ctor, "WorkerGlobalScope")?;
+ set_worker_to_string_tag(scope, worker_proto, "WorkerGlobalScope");
+ WorkerGlobalScopeConstructorGlobalDeclaration::new(worker_ctor)
.initialize(scope, global)
- .map_err(|error| {
- anyhow!("failed to initialize ServiceWorkerGlobalScope global: {error}")
- })?;
- ensure_worker_interface_constructor(scope, "NavigationPreloadManager")?;
- let _ = global.set_prototype(scope, service_proto.into());
+ .map_err(|error| anyhow!("failed to initialize WorkerGlobalScope global: {error}"))?;
+
+ let specific_template = v8::Local::new(scope, &templates.specific_worker);
+ let specific_ctor = specific_template
+ .get_function(scope)
+ .ok_or_else(|| anyhow!("failed to instantiate {interface} constructor"))?;
+ specific_ctor
+ .set_prototype(scope, worker_ctor.into())
+ .unwrap_or(false)
+ .then_some(())
+ .ok_or_else(|| anyhow!("failed to inherit {interface} constructor"))?;
+ let specific_proto = constructor_prototype(scope, specific_ctor, interface)?;
+ set_worker_to_string_tag(scope, specific_proto, interface);
+ match global_kind {
+ super::thread::WorkerGlobalKind::Dedicated { .. } => {
+ DedicatedWorkerGlobalMethodsDeclaration::default().initialize(scope, specific_proto)?;
+ DedicatedWorkerGlobalScopeConstructorGlobalDeclaration::new(specific_ctor)
+ .initialize(scope, global)?;
+ }
+ super::thread::WorkerGlobalKind::Shared { .. } => {
+ SharedWorkerGlobalMethodsDeclaration::default().initialize(scope, specific_proto)?;
+ SharedWorkerGlobalScopeConstructorGlobalDeclaration::new(specific_ctor)
+ .initialize(scope, global)?;
+ }
+ super::thread::WorkerGlobalKind::Service { .. } => {
+ ServiceWorkerGlobalScopeConstructorGlobalDeclaration::new(specific_ctor)
+ .initialize(scope, global)?;
+ ensure_worker_interface_constructor(scope, "NavigationPreloadManager")?;
+ }
+ }
+ if !global
+ .get_prototype(scope)
+ .is_some_and(|prototype| prototype.strict_equals(specific_proto.into()))
+ {
+ return Err(anyhow!(
+ "worker global template did not install {interface}.prototype"
+ ));
+ }
Ok(())
}
diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs
index 9e5a69ccb..e0a49b698 100644
--- a/moli-renderer-v8/src/worker/thread/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/mod.rs
@@ -89,7 +89,7 @@ use super::global_scope::{
fulfill_pending_worker_csp_report, fulfill_pending_worker_fetch,
fulfill_pending_worker_fetch_response, fulfill_pending_worker_xhr,
fulfill_pending_worker_xhr_response, install_worker_global_scope,
- service_worker_fetch_handler_type,
+ prepare_worker_global_scope_templates, service_worker_fetch_handler_type,
};
use super::handle::{
WorkerBootstrapCompletion, WorkerBootstrapFailure, WorkerBootstrapSuccess,
@@ -1759,7 +1759,31 @@ async fn worker_main(
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
*isolate_handle.lock() = Some(scope.thread_safe_handle());
- let ctx = v8::Context::new(scope, Default::default());
+ let worker_templates =
+ match prepare_worker_global_scope_templates(scope, &state.borrow().global_kind) {
+ Ok(templates) => Some(templates),
+ Err(error) => {
+ tracing::error!(
+ url = %script_url,
+ error = %error,
+ "failed to prepare worker global templates"
+ );
+ bootstrap_completion
+ .mark_install_global_failure(&script_url, error.to_string());
+ install_global_failed = true;
+ None
+ }
+ };
+ let global_template = worker_templates
+ .as_ref()
+ .map(|templates| templates.global_template(scope));
+ let ctx = v8::Context::new(
+ scope,
+ v8::ContextOptions {
+ global_template,
+ ..Default::default()
+ },
+ );
crate::resource_owner::install_resource_owner_for_context(ctx, resource_owner_id);
crate::context_bootstrap::set_indexed_db_manager_for_context(
ctx,
@@ -1778,17 +1802,21 @@ async fn worker_main(
let scope = &mut v8::ContextScope::new(scope, ctx);
let global = ctx.global(scope);
- if let Err(e) = install_worker_global_scope(scope, global, state.clone()) {
- tracing::error!(url = %script_url, error = %e, "failed to install worker global scope");
- bootstrap_completion.mark_install_global_failure(&script_url, e.to_string());
- install_global_failed = true;
- } else if script_kind == WorkerScriptKind::Classic {
- let referrer_policy = { state.borrow().referrer_policy.clone() };
- install_classic_worker_dynamic_module_runtime(
- scope,
- referrer_policy,
- module_evaluation_tx.clone(),
- );
+ if !install_global_failed {
+ if let Err(e) =
+ install_worker_global_scope(scope, global, state.clone(), worker_templates.as_ref())
+ {
+ tracing::error!(url = %script_url, error = %e, "failed to install worker global scope");
+ bootstrap_completion.mark_install_global_failure(&script_url, e.to_string());
+ install_global_failed = true;
+ } else if script_kind == WorkerScriptKind::Classic {
+ let referrer_policy = { state.borrow().referrer_policy.clone() };
+ install_classic_worker_dynamic_module_runtime(
+ scope,
+ referrer_policy,
+ module_evaluation_tx.clone(),
+ );
+ }
}
}
if install_global_failed {
diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
index 9ef2b49ee..535ca5da4 100644
--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
@@ -238,6 +238,64 @@ async fn service_worker_global_scope_does_not_expose_close() {
handle.terminate_and_join();
}
+#[tokio::test]
+async fn worker_global_prototype_chains_inherit_event_target_and_are_immutable() {
+ ensure_v8();
+ let script_url = url::Url::parse("https://example.test/app/worker-prototypes.js").unwrap();
+ let fixture = include_str!("../../../../tests/fixtures/worker-global-prototypes.js");
+ for (interface, kind) in [
+ (
+ "DedicatedWorkerGlobalScope",
+ WorkerGlobalKind::Dedicated {
+ name: String::new(),
+ },
+ ),
+ (
+ "SharedWorkerGlobalScope",
+ WorkerGlobalKind::Shared {
+ name: String::new(),
+ storage_key: moli_storage_key::MoliStorageKey::first_party_from_url(
+ &script_url,
+ None,
+ ),
+ },
+ ),
+ (
+ "ServiceWorkerGlobalScope",
+ WorkerGlobalKind::Service {
+ registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1),
+ version_id: ServiceWorkerVersionId::from_u64_for_test(1),
+ scope_url: url::Url::parse("https://example.test/app/").unwrap(),
+ },
+ ),
+ ] {
+ let (bootstrap_tx, mut bootstrap_rx) =
+ tokio::sync::mpsc::unbounded_channel::<crate::worker::WorkerBootstrapCompletion>();
+ let handle = spawn_test_worker_with_options(
+ WorkerSpawnOptions::new(
+ format!(
+ r#"
+ const result = ({fixture})({interface:?});
+ if (result.checks !== 46 || result.failures.length) {{
+ throw new Error(JSON.stringify(result));
+ }}
+ "#
+ ),
+ script_url.to_string(),
+ )
+ .with_global_kind(kind)
+ .with_bootstrap_completion_sender(bootstrap_tx),
+ );
+ let bootstrap = timeout(TIMEOUT, bootstrap_rx.recv()).await;
+ handle.terminate_and_join();
+ bootstrap
+ .expect("timed out waiting for worker prototype checks")
+ .expect("worker bootstrap channel closed")
+ .result
+ .unwrap_or_else(|error| panic!("{interface} prototype checks failed: {error:?}"));
+ }
+}
+
#[tokio::test]
async fn worker_pause_evaluation_until_debugger_exposes_context_before_bootstrap() {
ensure_v8();
diff --git a/moli-renderer-v8/tests/fixtures/worker-global-prototypes.js b/moli-renderer-v8/tests/fixtures/worker-global-prototypes.js
new file mode 100644
index 000000000..003b9ce84
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/worker-global-prototypes.js
@@ -0,0 +1,82 @@
+(scopeName => {
+ const failures = [];
+ let checks = 0;
+ const check = (value, label) => {
+ checks++;
+ if (!value) failures.push(label);
+ };
+ const test = (label, callback) => {
+ try { callback(); } catch (error) { check(false, label + ': ' + error); }
+ };
+ const throwsTypeError = callback => {
+ try { callback(); } catch (error) { return error instanceof TypeError; }
+ return false;
+ };
+ const scopeConstructor = self[scopeName];
+ const eventTarget = EventTarget;
+ const chain = [self, scopeConstructor.prototype, WorkerGlobalScope.prototype,
+ eventTarget.prototype, Object.prototype];
+ for (let i = 0; i < chain.length; i++) {
+ const value = chain[i];
+ const parent = chain[i + 1] || null;
+ const original = Object.getPrototypeOf(value);
+ check(original === parent, 'prototype parent ' + i);
+ check(Object.isExtensible(value), 'extensible ' + i);
+ check(!Reflect.setPrototypeOf(value, {}), 'Reflect rejects different prototype ' + i);
+ // Restore the prototype in a broken implementation so other checks remain useful.
+ if (Object.getPrototypeOf(value) !== original) Reflect.setPrototypeOf(value, original);
+ check(throwsTypeError(() => Object.setPrototypeOf(value, {})), 'Object rejects different prototype ' + i);
+ if (Object.getPrototypeOf(value) !== original) Reflect.setPrototypeOf(value, original);
+ check(Reflect.setPrototypeOf(value, original), 'same prototype allowed ' + i);
+ }
+ check(Object.getPrototypeOf(scopeConstructor) === WorkerGlobalScope, 'specific constructor inherits WorkerGlobalScope');
+ check(Object.getPrototypeOf(WorkerGlobalScope) === eventTarget, 'WorkerGlobalScope constructor inherits EventTarget');
+ check(self instanceof scopeConstructor, 'specific instanceof');
+ check(self instanceof WorkerGlobalScope, 'WorkerGlobalScope instanceof');
+ check(self instanceof eventTarget, 'EventTarget instanceof');
+ check(Object.prototype.toString.call(self) === '[object ' + scopeName + ']', 'global tag');
+ check(Object.prototype.toString.call(WorkerGlobalScope.prototype) === '[object WorkerGlobalScope]', 'worker tag');
+ check(throwsTypeError(() => new scopeConstructor()), 'specific illegal constructor');
+ check(throwsTypeError(() => new WorkerGlobalScope()), 'worker illegal constructor');
+ test('prototype extension', () => {
+ const key = Symbol('EventTarget extension');
+ eventTarget.prototype[key] = 17;
+ try { check(self[key] === 17, 'EventTarget extensions reach global'); }
+ finally { delete eventTarget.prototype[key]; }
+ });
+ test('global event delivery', () => {
+ const values = [];
+ const listener = event => values.push(event);
+ self.addEventListener('worker-prototype-probe', listener);
+ const first = new Event('worker-prototype-probe');
+ self.dispatchEvent(first);
+ check(values.length === 1 && values[0] === first, 'global dispatch reaches listener');
+ check(first.target === self, 'dispatched event target is global');
+ self.removeEventListener('worker-prototype-probe', listener);
+ self.dispatchEvent(new Event('worker-prototype-probe'));
+ check(values.length === 1, 'global listener removal still works');
+ });
+ test('receiver branding', () => {
+ let conversions = 0;
+ let traps = 0;
+ const type = {toString() { conversions++; return 'probe'; }};
+ const revoked = Proxy.revocable(self, {});
+ revoked.revoke();
+ for (const receiver of [{}, Object.create(self), new Proxy(self, {
+ get() { traps++; throw new Error('author proxy trap'); },
+ getPrototypeOf() { traps++; throw new Error('author proxy trap'); }
+ }), revoked.proxy]) {
+ check(throwsTypeError(() => eventTarget.prototype.addEventListener.call(receiver, type, () => {})), 'addEventListener rejects forged/proxy receiver');
+ }
+ check(conversions === 0, 'brand checked before conversion');
+ check(traps === 0, 'brand checked without proxy traps');
+ });
+ test('global constructor replacement', () => {
+ self.EventTarget = function ReplacedEventTarget() {};
+ try {
+ check(Object.getPrototypeOf(WorkerGlobalScope.prototype) === eventTarget.prototype, 'prototype keeps intrinsic EventTarget');
+ check(Object.getPrototypeOf(WorkerGlobalScope) === eventTarget, 'constructor keeps intrinsic EventTarget');
+ } finally { self.EventTarget = eventTarget; }
+ });
+ return {checks, failures};
+})