Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.jsnew file mode 100644index 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};+})