Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor(worker): split global scope by responsibility
ldm0e442d0eee2e1
diff --git a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rsindex 86cfa36ca..fe8e9d4da 100644--- a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs+++ b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs@@ -247,7 +247,7 @@ const DIRECT_V8_CALL_ALLOWLIST: &[AllowedDirectCallFile] = &[DirectCallOwner::NativeForwardingOrScript,),allowed(- "worker/global_scope/mod.rs",+ "worker/global_scope/console.rs",1,DirectCallOwner::NativeForwardingOrScript,),diff --git a/moli-renderer-v8/src/worker/global_scope/async_tasks.rs b/moli-renderer-v8/src/worker/global_scope/async_tasks.rsnew file mode 100644index 000000000..ade37d702--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/async_tasks.rs@@ -0,0 +1,326 @@+//! Worker-owned WebCrypto and OPFS tasks and their promise completions.++use super::*;++/// A WebCrypto primitive dispatched off the worker event loop to the blocking+/// pool. The worker owns the resolver and matches the completion back by the+/// task id allocated for this worker lifetime.+pub(in crate::worker) struct PendingWorkerWebCryptoTask {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++/// Completion of a worker WebCrypto blocking task, routed back onto the worker+/// event loop. The worker sink captures these ids at registration just as the+/// page-side typed producer captures its exact Page/Window owner.+pub(crate) struct WorkerWebCryptoCompletion {+ pub(crate) task_id: u64,+ pub(crate) result: Result<WebCryptoTaskResult, WebCryptoRejection>,+}++pub(in crate::worker) struct PendingWorkerOpfsTask {+ pub(in crate::worker) locator: moli_storage_service::StorageBucketLocator,+ pub(in crate::worker) handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,+ pub(in crate::worker) settlement: crate::opfs_owner_tasks::OpfsTaskSettlement,+}++pub(in crate::worker) struct WorkerOpfsOwnerState {+ next_task_id: u64,+ pending_tasks: HashMap<u64, PendingWorkerOpfsTask>,+ handles: crate::opfs_owner_tasks::OpfsHandleRegistry,+ directory_iterators: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry,+}++impl Default for WorkerOpfsOwnerState {+ fn default() -> Self {+ Self {+ next_task_id: 1,+ pending_tasks: HashMap::new(),+ handles: crate::opfs_owner_tasks::OpfsHandleRegistry::default(),+ directory_iterators: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry::default(),+ }+ }+}++impl WorkerOpfsOwnerState {+ pub(in crate::worker) fn has_pending_tasks(&self) -> bool {+ !self.pending_tasks.is_empty()+ }+}++pub(crate) struct WorkerOpfsCompletion {+ pub(crate) task_id: u64,+ pub(crate) result: OpfsTaskResult,+}++impl WorkerGlobalState {+ /// Register a pending worker WebCrypto task and return the routing tuple the+ /// blocking task needs to report completion. Runs synchronously inside the+ /// V8 callback before control returns to the worker event loop.+ pub(in crate::worker) fn register_pending_webcrypto_task(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> (u64, mpsc::UnboundedSender<WorkerWebCryptoCompletion>) {+ let task_id = self.next_webcrypto_task_id;+ self.next_webcrypto_task_id = task_id+ .checked_add(1)+ .expect("worker WebCrypto task id exhausted");+ self.pending_webcrypto+ .insert(task_id, PendingWorkerWebCryptoTask { resolver });+ (task_id, self.webcrypto_completion_tx.clone())+ }++ pub(in crate::worker) fn take_pending_webcrypto_task(+ &mut self,+ task_id: u64,+ ) -> Option<PendingWorkerWebCryptoTask> {+ self.pending_webcrypto.remove(&task_id)+ }++ pub(in crate::worker) fn register_pending_opfs_task(+ &mut self,+ locator: moli_storage_service::StorageBucketLocator,+ handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,+ settlement: crate::opfs_owner_tasks::OpfsTaskSettlement,+ ) -> (u64, mpsc::UnboundedSender<WorkerOpfsCompletion>) {+ let state = self+ .opfs_owner_state+ .get_or_insert_with(WorkerOpfsOwnerState::default);+ let task_id = state.next_task_id;+ state.next_task_id = task_id+ .checked_add(1)+ .expect("worker OPFS task id exhausted");+ state.pending_tasks.insert(+ task_id,+ PendingWorkerOpfsTask {+ locator,+ handle_access,+ settlement,+ },+ );+ (task_id, self.opfs_completion_tx.clone())+ }++ pub(in crate::worker) fn take_pending_opfs_task(+ &mut self,+ task_id: u64,+ ) -> Option<PendingWorkerOpfsTask> {+ self.opfs_owner_state+ .as_mut()?+ .pending_tasks+ .remove(&task_id)+ }+}++/// Register a pending worker WebCrypto task from a callback scope.+///+/// Returns the routing tuple the blocking task needs to report completion, or+/// `None` when the current scope is not a worker global (e.g. the page runtime+/// or a bare unit-test context). This is the worker-lane analog of the page+/// `register_webcrypto_task`.+pub(crate) fn register_worker_webcrypto_task(+ scope: &mut v8::PinScope<'_, '_>,+ resolver: v8::Local<'_, v8::PromiseResolver>,+) -> Option<(u64, mpsc::UnboundedSender<WorkerWebCryptoCompletion>)> {+ let state = get_worker_state(scope)?;+ let resolver = v8::Global::new(scope, resolver);+ let mut state = state.borrow_mut();+ Some(state.register_pending_webcrypto_task(resolver))+}++pub(crate) fn register_worker_opfs_task(+ scope: &mut v8::PinScope<'_, '_>,+ resolver: v8::Local<'_, v8::PromiseResolver>,+ locator: moli_storage_service::StorageBucketLocator,+ handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,+) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {+ let state = get_worker_state(scope)?;+ let resolver = v8::Global::new(scope, resolver);+ let mut state = state.borrow_mut();+ Some(state.register_pending_opfs_task(+ locator,+ handle_access,+ crate::opfs_owner_tasks::OpfsTaskSettlement::Promise(resolver),+ ))+}++pub(crate) fn register_worker_opfs_iterator_task(+ scope: &mut v8::PinScope<'_, '_>,+ locator: moli_storage_service::StorageBucketLocator,+ registry: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry,+ iterator_id: u32,+ keep_alive: v8::Global<v8::Object>,+ handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,+) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {+ let state = get_worker_state(scope)?;+ let mut state = state.borrow_mut();+ Some(state.register_pending_opfs_task(+ locator,+ handle_access,+ crate::opfs_owner_tasks::OpfsTaskSettlement::DirectoryIterator {+ registry,+ iterator_id,+ keep_alive,+ },+ ))+}++pub(crate) fn register_worker_opfs_move_task(+ scope: &mut v8::PinScope<'_, '_>,+ resolver: v8::Local<'_, v8::PromiseResolver>,+ handle: v8::Local<'_, v8::Object>,+ mutation: crate::opfs_owner_tasks::OpfsHandleMutationGuard,+ locator: moli_storage_service::StorageBucketLocator,+ handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,+) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {+ let state = get_worker_state(scope)?;+ let mut state = state.borrow_mut();+ Some(state.register_pending_opfs_task(+ locator,+ handle_access,+ crate::opfs_owner_tasks::OpfsTaskSettlement::Move {+ resolver: v8::Global::new(scope, resolver),+ handle: v8::Global::new(scope, handle),+ mutation,+ },+ ))+}++pub(crate) fn worker_opfs_handle_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::opfs_owner_tasks::OpfsHandleRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .opfs_owner_state+ .as_ref()?+ .handles+ .clone(),+ )+}++pub(crate) fn ensure_worker_opfs_handle_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::opfs_owner_tasks::OpfsHandleRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow_mut()+ .opfs_owner_state+ .get_or_insert_with(WorkerOpfsOwnerState::default)+ .handles+ .clone(),+ )+}++pub(crate) fn worker_opfs_directory_iterator_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .opfs_owner_state+ .as_ref()?+ .directory_iterators+ .clone(),+ )+}++pub(crate) fn ensure_worker_opfs_directory_iterator_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow_mut()+ .opfs_owner_state+ .get_or_insert_with(WorkerOpfsOwnerState::default)+ .directory_iterators+ .clone(),+ )+}++pub(crate) fn cancel_worker_opfs_task(scope: &mut v8::PinScope<'_, '_>, task_id: u64) {+ if let Some(state) = get_worker_state(scope) {+ state.borrow_mut().take_pending_opfs_task(task_id);+ }+}++/// Settle a worker WebCrypto promise once its blocking task reports back on the+/// worker event loop. Terminating a worker drops this state and its completion+/// receiver together, so a separate reset generation is unnecessary.+pub(in crate::worker) fn drain_worker_webcrypto_completion(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ completion: WorkerWebCryptoCompletion,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_webcrypto_task(completion.task_id) else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ crate::script_vm::webcrypto_tasks::settle_webcrypto_task_result(+ scope,+ resolver,+ completion.result,+ );+}++pub(in crate::worker) fn drain_worker_opfs_completion(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ completion: WorkerOpfsCompletion,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_opfs_task(completion.task_id) else {+ return;+ };+ pending+ };+ let handle_access = pending.handle_access;+ match pending.settlement {+ crate::opfs_owner_tasks::OpfsTaskSettlement::Promise(resolver) => {+ let resolver = v8::Local::new(scope, &resolver);+ crate::context_bootstrap::settle_opfs_task_result(+ scope,+ resolver,+ &pending.locator,+ handle_access.as_ref(),+ completion.result,+ );+ }+ crate::opfs_owner_tasks::OpfsTaskSettlement::Move {+ resolver,+ handle,+ mutation,+ } => {+ let resolver = v8::Local::new(scope, &resolver);+ let handle = v8::Local::new(scope, &handle);+ crate::context_bootstrap::settle_opfs_move_task_result(+ scope,+ resolver,+ handle,+ &pending.locator,+ handle_access.as_ref(),+ completion.result,+ );+ drop(mutation);+ }+ crate::opfs_owner_tasks::OpfsTaskSettlement::DirectoryIterator {+ registry,+ iterator_id,+ keep_alive,+ } => {+ crate::context_bootstrap::settle_opfs_directory_iterator_task_result(+ scope,+ ®istry,+ iterator_id,+ &pending.locator,+ handle_access.as_ref(),+ completion.result,+ );+ drop(keep_alive);+ }+ }+}diff --git a/moli-renderer-v8/src/worker/global_scope/bootstrap.rs b/moli-renderer-v8/src/worker/global_scope/bootstrap.rsnew file mode 100644index 000000000..046c5b1c0--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/bootstrap.rs@@ -0,0 +1,522 @@+//! Global initialization and constructors for dedicated, shared and service workers.++use super::*;++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalBootstrapPropertiesDeclaration<'scope> {+ #[webapi(slot = WORKER_STATE_SLOT)]+ worker_state: v8::Local<'scope, v8::External>,+ #[webapi(data_property = "self", readonly)]+ self_value: v8::Local<'scope, v8::Object>,+ #[webapi(data_property = "crossOriginIsolated")]+ cross_origin_isolated: bool,+ #[webapi(data_property = "isSecureContext", readonly)]+ is_secure_context: bool,+ #[webapi(data_property = "globalThis")]+ global_this: v8::Local<'scope, v8::Object>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalNameDeclaration {+ #[webapi(data_property, enumerable)]+ name: String,+}++#[derive(Default, WebApiObject)]+#[webapi(fragment, prototype = "DedicatedWorkerGlobalScope", enumerable)]+struct DedicatedWorkerGlobalMethodsDeclaration {+ #[webapi(method, callback = worker_close_callback, length = 0)]+ close: (),+}++#[derive(Default, WebApiObject)]+#[webapi(fragment, prototype = "SharedWorkerGlobalScope", enumerable)]+struct SharedWorkerGlobalMethodsDeclaration {+ #[webapi(method, callback = worker_close_callback, length = 0)]+ close: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalCommonOperationsDeclaration {+ #[webapi(+ method = "structuredClone",+ callback = worker_structured_clone_callback,+ length = 1+ )]+ structured_clone: (),+ #[webapi(method, callback = worker_fetch_callback, length = 1)]+ fetch: (),+ #[webapi(method = "importScripts", callback = worker_import_scripts_callback, length = 0)]+ import_scripts: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalCreateImageBitmapDeclaration {+ #[webapi(+ method = "createImageBitmap",+ callback = worker_create_image_bitmap_callback,+ length = 1+ )]+ create_image_bitmap: (),+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalScopeConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "WorkerGlobalScope")]+ constructor: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct DedicatedWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "DedicatedWorkerGlobalScope")]+ constructor: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct SharedWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "SharedWorkerGlobalScope")]+ constructor: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct ServiceWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "ServiceWorkerGlobalScope")]+ constructor: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerScopePrototypeConstructorDeclaration<'scope> {+ #[webapi(data_property = "constructor")]+ constructor: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerPrototypeTagDeclaration {+ #[webapi(to_string_tag, readonly)]+ tag: &'static str,+}++/// Install the `DedicatedWorkerGlobalScope` APIs on the given V8 global object.+///+/// The `state_ptr` is stored as an external in V8 so callbacks can access+/// `WorkerGlobalState`. Callers must ensure the `Rc<RefCell<WorkerGlobalState>>`+/// outlives the V8 context.+pub(in crate::worker) 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;+ let external = v8::External::new(scope, state_ptr);+ // Prevent leak: the Rc was consumed by into_raw, but we still hold `state`.+ // We reconstruct it so the ref-count is correct. The raw pointer stored in+ // the external is valid as long as the Rc (held by the caller) is alive.+ unsafe { Rc::from_raw(state_ptr as *const RefCell<WorkerGlobalState>) };+ let global_kind = state.borrow().global_kind.clone();++ let (secure_context, cross_origin_isolated) = {+ let state = state.borrow();+ (+ state.secure_context,+ state.secure_context && state.policy_context.cross_origin_isolated,+ )+ };+ WorkerGlobalBootstrapPropertiesDeclaration::new(+ external,+ global,+ cross_origin_isolated,+ secure_context,+ global,+ )+ .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, worker_templates)?;+ let (_, realm_kind) = worker_global_scope_interface(&global_kind);+ crate::context_bootstrap::install_worker_lazy_exposed_interfaces(+ scope,+ global,+ realm_kind,+ secure_context,+ )?;+ crate::context_bootstrap::install_trusted_types_runtime_state(scope, global)?;+ let require_trusted_types_for_script =+ crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(+ &state.borrow().content_security_policies,+ );+ if require_trusted_types_for_script {+ scope+ .get_current_context()+ .set_allow_generation_from_strings(false);+ crate::context_bootstrap::install_trusted_types_eval_runtime_state(scope, global)?;+ }+ crate::context_bootstrap::install_webassembly_runtime_state(scope, global)?;+ if matches!(+ global_kind,+ crate::worker::thread::WorkerGlobalKind::Service { .. }+ ) {+ install_service_worker_extendable_event_constructors(scope, global)?;+ }+ crate::context_bootstrap::initialize_worker_fetch_realm_state(scope, global)?;+ let subtle_crypto_available = secure_context;+ crate::context_bootstrap::initialize_worker_crypto_realm_state(+ scope,+ global,+ subtle_crypto_available,+ )?;+ crate::context_bootstrap::initialize_worker_file_realm_state(scope, global)?;+ install_worker_create_image_bitmap(scope, global)?;+ let identity = state+ .borrow()+ .loader+ .request_client()+ .browser_identity()+ .clone();+ crate::context_bootstrap::install_worker_navigator_runtime_state(+ scope,+ global,+ secure_context,+ &identity,+ )?;+ crate::context_bootstrap::install_worker_indexed_db_runtime_state(scope, global)?;+ crate::context_bootstrap::install_worker_base64_runtime_state(scope, global)?;+ install_simple_event_target_methods(scope, global, WORKER_GLOBAL_LISTENERS_SLOT, false);+ install_simple_event_target_ordered_handlers(scope, global);+ let script_url = state.borrow().current_script_url.clone();+ let origin = script_url+ .as_ref()+ .map(moli_url::origin_ascii_serialization)+ .unwrap_or_else(|| "null".to_owned());+ WorkerGlobalOriginDeclaration::new(origin)+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker global origin: {error}"))?;+ let worker_prototype = global_constructor_prototype(scope, "WorkerGlobalScope")+ .ok_or_else(|| anyhow!("WorkerGlobalScope prototype missing"))?;+ WorkerGlobalOriginPrototypeDeclaration::default()+ .initialize(scope, worker_prototype)+ .map_err(|error| anyhow!("failed to initialize WorkerGlobalScope origin: {error}"))?;+ if let Some(script_url) = script_url {+ crate::context_bootstrap::install_worker_location_runtime_state(+ scope,+ global,+ &script_url,+ )?;+ crate::context_bootstrap::install_worker_script_url_runtime_state(+ scope,+ global,+ &script_url,+ )?;+ }++ match &global_kind {+ crate::worker::thread::WorkerGlobalKind::Dedicated { name } => {+ set_worker_global_name_prop(scope, global, name)?;+ DedicatedWorkerGlobalPostMessageDeclaration::default()+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker postMessage: {error}"))?;+ }+ crate::worker::thread::WorkerGlobalKind::Shared { name, .. } => {+ set_worker_global_name_prop(scope, global, name)?;+ }+ crate::worker::thread::WorkerGlobalKind::Service {+ registration_id,+ version_id,+ scope_url,+ } => {+ set_worker_global_name_prop(scope, global, "")?;+ install_service_worker_global_runtime(+ scope,+ global,+ *registration_id,+ *version_id,+ scope_url,+ )?;+ }+ }++ WorkerGlobalCommonOperationsDeclaration::default()+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker global operations: {error}"))?;++ install_worker_global_event_handler_accessors(scope, global, &global_kind)?;++ // console+ install_console(scope, global)?;++ WorkerGlobalTimerOperationsDeclaration::default()+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker timers: {error}"))?;++ crate::context_bootstrap::exposed_interfaces::capture_eager_intrinsic_interfaces(+ scope, global, realm_kind,+ )?;+ Ok(())+}++fn set_worker_global_name_prop<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+ name: &str,+) -> Result<()> {+ // WorkerGlobalScope.name is [Replaceable] readonly in IDL. Browsers expose+ // an own global property whose assignment becomes a normal enumerable data+ // property, which WPT observes through Object.getOwnPropertyDescriptor.+ WorkerGlobalNameDeclaration::new(name.to_owned())+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker global `name`: {error}"))+}++fn install_worker_create_image_bitmap<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+) -> Result<()> {+ WorkerGlobalCreateImageBitmapDeclaration::default()+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize createImageBitmap: {error}"))+}++fn worker_create_image_bitmap_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ _args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(resolver) = v8::PromiseResolver::new(scope) else {+ rv.set_undefined();+ return;+ };+ let promise = resolver.get_promise(scope);+ let reason = worker_dom_exception_value(+ scope,+ "The source image could not be decoded.",+ "InvalidStateError",+ );+ let _ = resolver.reject(scope, reason);+ rv.set(promise.into());+}++pub(in crate::worker) struct PreparedWorkerGlobalScopeTemplates {+ event_target: v8::Global<v8::FunctionTemplate>,+ worker: v8::Global<v8::FunctionTemplate>,+ specific_worker: v8::Global<v8::FunctionTemplate>,+}++impl PreparedWorkerGlobalScopeTemplates {+ pub(in crate::worker) 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: &crate::worker::thread::WorkerGlobalKind,+) -> (+ &'static str,+ crate::context_bootstrap::exposed_interfaces::RealmKind,+) {+ use crate::context_bootstrap::exposed_interfaces::RealmKind;+ match global_kind {+ crate::worker::thread::WorkerGlobalKind::Dedicated { .. } => {+ ("DedicatedWorkerGlobalScope", RealmKind::DedicatedWorker)+ }+ crate::worker::thread::WorkerGlobalKind::Shared { .. } => {+ ("SharedWorkerGlobalScope", RealmKind::SharedWorker)+ }+ crate::worker::thread::WorkerGlobalKind::Service { .. } => {+ ("ServiceWorkerGlobalScope", RealmKind::ServiceWorker)+ }+ }+}++pub(in crate::worker) fn prepare_worker_global_scope_templates<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ global_kind: &crate::worker::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 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_worker_global_scope_constructors<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+ global_kind: &crate::worker::thread::WorkerGlobalKind,+ worker_templates: Option<&PreparedWorkerGlobalScopeTemplates>,+) -> Result<()> {+ 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 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 {+ crate::worker::thread::WorkerGlobalKind::Dedicated { .. } => {+ DedicatedWorkerGlobalMethodsDeclaration::default().initialize(scope, specific_proto)?;+ DedicatedWorkerGlobalScopeConstructorGlobalDeclaration::new(specific_ctor)+ .initialize(scope, global)?;+ }+ crate::worker::thread::WorkerGlobalKind::Shared { .. } => {+ SharedWorkerGlobalMethodsDeclaration::default().initialize(scope, specific_proto)?;+ SharedWorkerGlobalScopeConstructorGlobalDeclaration::new(specific_ctor)+ .initialize(scope, global)?;+ }+ crate::worker::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(())+}++pub(super) fn ensure_worker_interface_constructor<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ name: &'static str,+) -> Result<()> {+ let global = scope.get_current_context().global(scope);+ if global+ .get(scope, v8str(scope, name).into())+ .is_some_and(|value| !value.is_undefined())+ {+ return Ok(());+ }+ let constructor = worker_scope_constructor(scope, name)?;+ let prototype = constructor_prototype(scope, constructor, name)?;+ set_worker_to_string_tag(scope, prototype, name);+ set_prop(scope, global, name, constructor.into())+}++fn worker_scope_constructor<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ name: &'static str,+) -> Result<v8::Local<'s, v8::Function>> {+ let constructor = v8::Function::builder(worker_global_scope_constructor_callback)+ .build(scope)+ .ok_or_else(|| anyhow!("failed to build {name} constructor"))?;+ constructor.set_name(v8str(scope, name));+ Ok(constructor)+}++pub(super) fn constructor_prototype<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ constructor: v8::Local<'s, v8::Function>,+ name: &'static str,+) -> Result<v8::Local<'s, v8::Object>> {+ let prototype_key = v8str(scope, "prototype");+ let prototype = constructor+ .get(scope, prototype_key.into())+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ .ok_or_else(|| anyhow!("{name} constructor prototype missing"))?;+ WorkerScopePrototypeConstructorDeclaration::new(constructor)+ .initialize(scope, prototype)+ .map_err(|error| anyhow!("failed to initialize {name}.prototype.constructor: {error}"))?;+ Ok(prototype)+}++pub(super) fn set_worker_to_string_tag<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ prototype: v8::Local<'s, v8::Object>,+ tag: &'static str,+) {+ let _ = WorkerPrototypeTagDeclaration::new(tag).initialize(scope, prototype);+}++fn worker_global_scope_constructor_callback(+ scope: &mut v8::PinScope<'_, '_>,+ _args: v8::FunctionCallbackArguments<'_>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ throw_type_error(scope, "Illegal constructor.");+}++fn set_prop(+ scope: &mut v8::PinScope<'_, '_>,+ obj: v8::Local<'_, v8::Object>,+ name: &str,+ value: v8::Local<'_, v8::Value>,+) -> Result<()> {+ let key =+ v8_string(scope, name).ok_or_else(|| anyhow!("failed to allocate worker key `{name}`"))?;+ obj.define_own_property(scope, key.into(), value, v8::PropertyAttribute::DONT_ENUM)+ .unwrap_or(false)+ .then_some(())+ .ok_or_else(|| anyhow!("failed to set worker global `{name}`"))+}diff --git a/moli-renderer-v8/src/worker/global_scope/console.rs b/moli-renderer-v8/src/worker/global_scope/console.rsnew file mode 100644index 000000000..ab6121fcf--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/console.rs@@ -0,0 +1,186 @@+//! Worker console bindings and forwarding to captured native console methods.++use super::*;++const WORKER_ORIGINAL_CONSOLE_SLOT: &str = "__moliWorkerOriginalConsole";++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalConsoleDeclaration<'scope> {+ #[webapi(data_property)]+ console: v8::Local<'scope, v8::Object>,+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct WorkerConsoleObjectDeclaration {+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "log"))]+ log: (),+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "info"))]+ info: (),+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "warn"))]+ warn: (),+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "error"))]+ error: (),+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "debug"))]+ debug: (),+ #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "trace"))]+ trace: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ time: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ time_log: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ time_end: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ count: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ count_reset: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ dir: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ dirxml: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ table: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ group: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ group_end: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ group_collapsed: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ clear: (),+ #[webapi(method, enumerable, callback = console_noop_callback)]+ assert: (),+ #[webapi(method, enumerable, callback = console_profile_callback)]+ profile: (),+ #[webapi(method, enumerable, callback = console_profile_end_callback)]+ profile_end: (),+}++pub(super) fn install_console<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+) -> Result<()> {+ let console_key = v8str(scope, "console");+ if let Some(original_console) = global.get(scope, console_key.into()) {+ set_private_value(+ scope,+ global,+ WORKER_ORIGINAL_CONSOLE_SLOT,+ original_console,+ );+ }+ let _ = global.delete(scope, console_key.into());++ let console = WorkerConsoleObjectDeclaration::default()+ .bind(scope)+ .map_err(|error| anyhow!("failed to create worker console: {error}"))?;++ WorkerGlobalConsoleDeclaration::new(console)+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker console: {error}"))+}++fn format_console_args(+ scope: &mut v8::PinScope<'_, '_>,+ args: &v8::FunctionCallbackArguments<'_>,+) -> String {+ let mut parts = Vec::new();+ for i in 0..args.length() {+ let val = args.get(i);+ if let Some(s) = val.to_detail_string(scope) {+ parts.push(s.to_rust_string_lossy(scope));+ }+ }+ parts.join(" ")+}++fn console_arg_snapshots_json(+ scope: &mut v8::PinScope<'_, '_>,+ args: &v8::FunctionCallbackArguments<'_>,+) -> Vec<serde_json::Value> {+ let mut snapshots = Vec::with_capacity(args.length().max(0) as usize);+ for index in 0..args.length() {+ snapshots.push(crate::context_bootstrap::console_arg_remote_object_json(+ scope,+ args.get(index),+ ));+ }+ snapshots+}++fn console_log_callback(+ scope: &mut v8::PinScope<'_, '_>,+ args: v8::FunctionCallbackArguments<'_>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let level = args+ .data()+ .to_string(scope)+ .map(|value| value.to_rust_string_lossy(scope))+ .unwrap_or_else(|| "log".to_owned());+ let text = format_console_args(scope, &args);+ let message = format!("{level}: {text}");+ let arg_snapshots = console_arg_snapshots_json(scope, &args);+ let stack = crate::context_bootstrap::current_console_stack(scope);+ tracing::trace!("{}", message);+ if let Some(state) = get_worker_state(scope) {+ let parent_tx = state.borrow().parent_tx.clone();+ let _ = parent_tx.send(WorkerToParentMessage::Console(WorkerConsoleMessage {+ message,+ args: arg_snapshots,+ stack,+ }));+ }+}++fn console_noop_callback(+ _scope: &mut v8::PinScope<'_, '_>,+ _args: v8::FunctionCallbackArguments<'_>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+}++fn console_profile_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ call_original_worker_console_method(scope, &args, "profile");+ rv.set_undefined();+}++fn console_profile_end_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ call_original_worker_console_method(scope, &args, "profileEnd");+ rv.set_undefined();+}++fn call_original_worker_console_method<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ method_name: &'static str,+) {+ let global = scope.get_current_context().global(scope);+ let Some(original_console) = get_private_value(scope, global, WORKER_ORIGINAL_CONSOLE_SLOT)+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ else {+ return;+ };+ let Some(method) = original_console+ .get(scope, v8str(scope, method_name).into())+ .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())+ else {+ return;+ };++ let mut forwarded_args = Vec::with_capacity(args.length().max(0) as usize);+ for index in 0..args.length() {+ forwarded_args.push(args.get(index));+ }+ let _ = method.call(scope, original_console.into(), &forwarded_args);+}diff --git a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rsindex 8efcc0508..7d7b32218 100644--- a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs+++ b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs@@ -32,8 +32,8 @@ use moli_fetch::{};use super::{- PendingWorkerCspReport, WORKER_GLOBAL_LISTENERS_SLOT, WorkerGlobalState, next_fetch_id,- record_worker_subresource_failure_with_handle, request_body_text,+ PendingWorkerCspReport, WORKER_GLOBAL_LISTENERS_SLOT, WorkerGlobalState, get_worker_state,+ next_fetch_id, record_worker_subresource_failure_with_handle, request_body_text,};pub(super) fn dispatch_worker_content_security_policy_violation_event<'s>(@@ -961,6 +961,55 @@ pub(super) fn worker_content_security_policy_error_message()}+pub(in crate::worker) fn dispatch_worker_csp_violation_event<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ loader: &crate::network::context::WorkerResourceLoader,+ violation: &crate::content_security_policy::ContentSecurityPolicyUrlViolation,+) {+ self::dispatch_worker_content_security_policy_violation_event(scope, loader, violation);+}++pub(crate) fn worker_allows_trusted_type_policy_name(+ scope: &mut v8::PinScope<'_, '_>,+ name: &str,+) -> Option<bool> {+ Some(+ crate::content_security_policy::content_security_policy_allows_trusted_type_policy_name(+ &get_worker_state(scope)?.borrow().content_security_policies,+ name,+ ),+ )+}++pub(crate) fn worker_requires_trusted_types_for_script(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<bool> {+ Some(+ crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(+ &get_worker_state(scope)?.borrow().content_security_policies,+ ),+ )+}++pub(crate) fn worker_allows_trusted_types_eval(scope: &mut v8::PinScope<'_, '_>) -> Option<bool> {+ Some(+ crate::content_security_policy::content_security_policy_allows_trusted_types_eval(+ &get_worker_state(scope)?.borrow().content_security_policies,+ ),+ )+}++pub(crate) fn dispatch_worker_trusted_types_sink_violation_event(+ scope: &mut v8::PinScope<'_, '_>,+ sink: &str,+ sample: &str,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ self::dispatch_worker_trusted_types_sink_violation_event_for_state(scope, &state, sink, sample);+}+pub(super) fn worker_compilation_content_security_policy_violations(state: &WorkerGlobalState,protected_url: &Url,@@ -986,3 +1035,81 @@ pub(super) fn worker_compilation_content_security_policy_violations(}).collect()}++pub(crate) fn worker_allows_eval_code_generation_by_csp(+ scope: &mut v8::PinScope<'_, '_>,+ allow_trusted_types_eval: bool,+ source: Option<&str>,+) -> Option<bool> {+ use crate::content_security_policy::ContentSecurityPolicyNonUrlKind;+ let kind = if allow_trusted_types_eval {+ ContentSecurityPolicyNonUrlKind::TrustedTypesEval+ } else {+ ContentSecurityPolicyNonUrlKind::Eval+ };+ worker_allows_compilation_by_csp(scope, kind, source)+}++fn worker_allows_compilation_by_csp(+ scope: &mut v8::PinScope<'_, '_>,+ kind: crate::content_security_policy::ContentSecurityPolicyNonUrlKind,+ source: Option<&str>,+) -> Option<bool> {+ let state = get_worker_state(scope)?;+ let (wake_tx, mut report_only_violations, mut enforce_violations) = {+ let state = state.borrow();+ let Some(protected_url) = state.current_script_url.as_ref() else {+ return Some(true);+ };+ (+ state.worker_wake_tx.clone(),+ worker_compilation_content_security_policy_violations(+ &state,+ protected_url,+ kind,+ source,+ crate::content_security_policy::ContentSecurityPolicyDisposition::Report,+ ),+ worker_compilation_content_security_policy_violations(+ &state,+ protected_url,+ kind,+ source,+ crate::content_security_policy::ContentSecurityPolicyDisposition::Enforce,+ ),+ )+ };+ if kind != crate::content_security_policy::ContentSecurityPolicyNonUrlKind::WasmEval+ && (!report_only_violations.is_empty() || !enforce_violations.is_empty())+ && let Some((source_file, line_number, column_number)) =+ crate::content_security_policy::current_script_violation_location(scope)+ {+ for violation in [&mut report_only_violations, &mut enforce_violations]+ .into_iter()+ .flatten()+ {+ violation.source_file.clone_from(&source_file);+ violation.line_number = line_number;+ violation.column_number = column_number;+ }+ }+ let allowed = enforce_violations.is_empty();+ for violation in report_only_violations.into_iter().chain(enforce_violations) {+ let _ = wake_tx.send(+ crate::worker::handle::WorkerMessage::DispatchContentSecurityPolicyViolation(Box::new(+ violation,+ )),+ );+ }+ Some(allowed)+}++pub(in crate::worker) fn dispatch_worker_csp_violation_event_for_state<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ violation: &crate::content_security_policy::ContentSecurityPolicyUrlViolation,+) {+ self::dispatch_worker_content_security_policy_violation_event_for_state(+ scope, state, violation,+ );+}diff --git a/moli-renderer-v8/src/worker/global_scope/event_handlers.rs b/moli-renderer-v8/src/worker/global_scope/event_handlers.rsnew file mode 100644index 000000000..c73da2ab5--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/event_handlers.rs@@ -0,0 +1,747 @@+//! Worker event-handler properties, private slots and fetch-handler classification.++use super::*;++pub(in crate::worker) const WORKER_GLOBAL_LISTENERS_SLOT: &str = "__moliWorkerGlobalListeners";++const WORKER_GLOBAL_ONMESSAGE_SLOT: &str = "__moliWorkerGlobalOnMessage";++const WORKER_GLOBAL_ONMESSAGEERROR_SLOT: &str = "__moliWorkerGlobalOnMessageError";++const WORKER_GLOBAL_ONERROR_SLOT: &str = "__moliWorkerGlobalOnError";++const WORKER_GLOBAL_ONCONNECT_SLOT: &str = "__moliWorkerGlobalOnConnect";++const WORKER_GLOBAL_ONINSTALL_SLOT: &str = "__moliWorkerGlobalOnInstall";++const WORKER_GLOBAL_ONACTIVATE_SLOT: &str = "__moliWorkerGlobalOnActivate";++const WORKER_GLOBAL_ONFETCH_SLOT: &str = "__moliWorkerGlobalOnFetch";++const WORKER_GLOBAL_ONPUSH_SLOT: &str = "__moliWorkerGlobalOnPush";++const WORKER_GLOBAL_ONSYNC_SLOT: &str = "__moliWorkerGlobalOnSync";++const WORKER_GLOBAL_ONPERIODICSYNC_SLOT: &str = "__moliWorkerGlobalOnPeriodicSync";++const WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT: &str = "__moliWorkerGlobalOnNotificationClick";++const WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT: &str = "__moliWorkerGlobalOnNotificationClose";++const WORKER_GLOBAL_ONOFFLINE_SLOT: &str = "__moliWorkerGlobalOnOffline";++const WORKER_GLOBAL_ONONLINE_SLOT: &str = "__moliWorkerGlobalOnOnline";++const WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT: &str = "__moliWorkerGlobalOnUnhandledRejection";++const WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT: &str = "__moliWorkerGlobalOnRejectionHandled";++#[derive(Default, WebApiObject)]+#[webapi(plain, enumerable)]+struct WorkerGlobalCommonEventHandlersDeclaration {+ #[webapi(+ accessor_property = "onerror",+ getter = worker_global_onerror_getter,+ setter = worker_global_onerror_setter+ )]+ onerror: (),+ #[webapi(+ accessor_property = "onoffline",+ getter = worker_global_onoffline_getter,+ setter = worker_global_onoffline_setter+ )]+ onoffline: (),+ #[webapi(+ accessor_property = "ononline",+ getter = worker_global_ononline_getter,+ setter = worker_global_ononline_setter+ )]+ ononline: (),+ #[webapi(+ accessor_property = "onunhandledrejection",+ getter = worker_global_onunhandledrejection_getter,+ setter = worker_global_onunhandledrejection_setter+ )]+ onunhandledrejection: (),+ #[webapi(+ accessor_property = "onrejectionhandled",+ getter = worker_global_onrejectionhandled_getter,+ setter = worker_global_onrejectionhandled_setter+ )]+ onrejectionhandled: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain, enumerable)]+struct DedicatedWorkerGlobalEventHandlersDeclaration {+ #[webapi(+ accessor_property = "onmessage",+ getter = worker_global_onmessage_getter,+ setter = worker_global_onmessage_setter+ )]+ onmessage: (),+ #[webapi(+ accessor_property = "onmessageerror",+ getter = worker_global_onmessageerror_getter,+ setter = worker_global_onmessageerror_setter+ )]+ onmessageerror: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain, enumerable)]+struct SharedWorkerGlobalEventHandlersDeclaration {+ #[webapi(+ accessor_property = "onconnect",+ getter = worker_global_onconnect_getter,+ setter = worker_global_onconnect_setter+ )]+ onconnect: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalCommonEventHandlerStateDeclaration {+ #[webapi(slot = WORKER_GLOBAL_ONERROR_SLOT, init = "null")]+ onerror: (),+ #[webapi(slot = WORKER_GLOBAL_ONOFFLINE_SLOT, init = "null")]+ onoffline: (),+ #[webapi(slot = WORKER_GLOBAL_ONONLINE_SLOT, init = "null")]+ ononline: (),+ #[webapi(slot = WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT, init = "null")]+ onunhandledrejection: (),+ #[webapi(slot = WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT, init = "null")]+ onrejectionhandled: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct DedicatedWorkerGlobalEventHandlerStateDeclaration {+ #[webapi(slot = WORKER_GLOBAL_ONMESSAGE_SLOT, init = "null")]+ onmessage: (),+ #[webapi(slot = WORKER_GLOBAL_ONMESSAGEERROR_SLOT, init = "null")]+ onmessageerror: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct SharedWorkerGlobalEventHandlerStateDeclaration {+ #[webapi(slot = WORKER_GLOBAL_ONCONNECT_SLOT, init = "null")]+ onconnect: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain, enumerable)]+struct ServiceWorkerGlobalEventHandlersDeclaration {+ #[webapi(+ accessor_property = "oninstall",+ getter = worker_global_oninstall_getter,+ setter = worker_global_oninstall_setter+ )]+ oninstall: (),+ #[webapi(+ accessor_property = "onactivate",+ getter = worker_global_onactivate_getter,+ setter = worker_global_onactivate_setter+ )]+ onactivate: (),+ #[webapi(+ accessor_property = "onfetch",+ getter = worker_global_onfetch_getter,+ setter = worker_global_onfetch_setter+ )]+ onfetch: (),+ #[webapi(+ accessor_property = "onpush",+ getter = worker_global_onpush_getter,+ setter = worker_global_onpush_setter+ )]+ onpush: (),+ #[webapi(+ accessor_property = "onsync",+ getter = worker_global_onsync_getter,+ setter = worker_global_onsync_setter+ )]+ onsync: (),+ #[webapi(+ accessor_property = "onperiodicsync",+ getter = worker_global_onperiodicsync_getter,+ setter = worker_global_onperiodicsync_setter+ )]+ onperiodicsync: (),+ #[webapi(+ accessor_property = "onmessage",+ getter = worker_global_onmessage_getter,+ setter = worker_global_onmessage_setter+ )]+ onmessage: (),+ #[webapi(+ accessor_property = "onmessageerror",+ getter = worker_global_onmessageerror_getter,+ setter = worker_global_onmessageerror_setter+ )]+ onmessageerror: (),+ #[webapi(+ accessor_property = "onnotificationclick",+ getter = worker_global_onnotificationclick_getter,+ setter = worker_global_onnotificationclick_setter+ )]+ onnotificationclick: (),+ #[webapi(+ accessor_property = "onnotificationclose",+ getter = worker_global_onnotificationclose_getter,+ setter = worker_global_onnotificationclose_setter+ )]+ onnotificationclose: (),+}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+struct ServiceWorkerGlobalEventHandlerStateDeclaration {+ #[webapi(slot = WORKER_GLOBAL_ONINSTALL_SLOT, init = "null")]+ oninstall: (),+ #[webapi(slot = WORKER_GLOBAL_ONACTIVATE_SLOT, init = "null")]+ onactivate: (),+ #[webapi(slot = WORKER_GLOBAL_ONFETCH_SLOT, init = "null")]+ onfetch: (),+ #[webapi(slot = WORKER_GLOBAL_ONPUSH_SLOT, init = "null")]+ onpush: (),+ #[webapi(slot = WORKER_GLOBAL_ONSYNC_SLOT, init = "null")]+ onsync: (),+ #[webapi(slot = WORKER_GLOBAL_ONPERIODICSYNC_SLOT, init = "null")]+ onperiodicsync: (),+ #[webapi(slot = WORKER_GLOBAL_ONMESSAGE_SLOT, init = "null")]+ onmessage: (),+ #[webapi(slot = WORKER_GLOBAL_ONMESSAGEERROR_SLOT, init = "null")]+ onmessageerror: (),+ #[webapi(slot = WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT, init = "null")]+ onnotificationclick: (),+ #[webapi(slot = WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT, init = "null")]+ onnotificationclose: (),+}++pub(super) fn install_worker_global_event_handler_accessors<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+ global_kind: &crate::worker::thread::WorkerGlobalKind,+) -> Result<()> {+ if matches!(+ global_kind,+ crate::worker::thread::WorkerGlobalKind::Dedicated { .. }+ ) {+ DedicatedWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;+ DedicatedWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;+ }+ if matches!(+ global_kind,+ crate::worker::thread::WorkerGlobalKind::Shared { .. }+ ) {+ SharedWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;+ SharedWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;+ }+ if matches!(+ global_kind,+ crate::worker::thread::WorkerGlobalKind::Service { .. }+ ) {+ ServiceWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;+ ServiceWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;+ }+ WorkerGlobalCommonEventHandlersDeclaration::default().initialize(scope, global)?;+ WorkerGlobalCommonEventHandlerStateDeclaration::default().initialize(scope, global)?;+ Ok(())+}++fn worker_global_event_handler_value<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+ slot_name: &str,+) -> v8::Local<'s, v8::Value> {+ get_private_value(scope, global, slot_name).unwrap_or_else(|| v8::null(scope).into())+}++fn set_worker_global_event_handler<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+ value: v8::Local<'s, v8::Value>,+ slot_name: &'static str,+ event_type: Option<&str>,+) {+ let stored = if value.is_object() {+ value+ } else {+ v8::null(scope).into()+ };+ let active = stored.is_object();+ set_private_value(scope, global, slot_name, stored);+ if let Some(event_type) = event_type {+ simple_object_event_set_ordered_handler(+ scope,+ global,+ WORKER_GLOBAL_LISTENERS_SLOT,+ event_type,+ slot_name,+ active,+ );+ }+}++fn worker_global_onmessage_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONMESSAGE_SLOT,+ ));+}++fn worker_global_onmessage_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONMESSAGE_SLOT,+ Some("message"),+ );+}++fn worker_global_onmessageerror_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONMESSAGEERROR_SLOT,+ ));+}++fn worker_global_onmessageerror_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONMESSAGEERROR_SLOT,+ Some("messageerror"),+ );+}++fn worker_global_oninstall_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONINSTALL_SLOT,+ ));+}++fn worker_global_oninstall_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONINSTALL_SLOT,+ Some("install"),+ );+}++fn worker_global_onactivate_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONACTIVATE_SLOT,+ ));+}++fn worker_global_onactivate_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONACTIVATE_SLOT,+ Some("activate"),+ );+}++fn worker_global_onfetch_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONFETCH_SLOT,+ ));+}++fn worker_global_onfetch_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONFETCH_SLOT,+ Some("fetch"),+ );+}++fn worker_global_onpush_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONPUSH_SLOT,+ ));+}++fn worker_global_onpush_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONPUSH_SLOT,+ Some("push"),+ );+}++fn worker_global_onsync_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONSYNC_SLOT,+ ));+}++fn worker_global_onsync_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONSYNC_SLOT,+ Some("sync"),+ );+}++fn worker_global_onperiodicsync_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONPERIODICSYNC_SLOT,+ ));+}++fn worker_global_onperiodicsync_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONPERIODICSYNC_SLOT,+ Some("periodicsync"),+ );+}++fn worker_global_onnotificationclick_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT,+ ));+}++fn worker_global_onnotificationclick_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT,+ Some("notificationclick"),+ );+}++fn worker_global_onnotificationclose_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT,+ ));+}++fn worker_global_onnotificationclose_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT,+ Some("notificationclose"),+ );+}++fn worker_global_onerror_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONERROR_SLOT,+ ));+}++fn worker_global_onerror_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONERROR_SLOT,+ None,+ );+}++fn worker_global_onconnect_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONCONNECT_SLOT,+ ));+}++fn worker_global_onconnect_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONCONNECT_SLOT,+ Some("connect"),+ );+}++fn worker_global_onoffline_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONOFFLINE_SLOT,+ ));+}++fn worker_global_onoffline_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONOFFLINE_SLOT,+ Some("offline"),+ );+}++fn worker_global_ononline_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONONLINE_SLOT,+ ));+}++fn worker_global_ononline_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONONLINE_SLOT,+ Some("online"),+ );+}++fn worker_global_onunhandledrejection_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT,+ ));+}++fn worker_global_onunhandledrejection_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT,+ Some("unhandledrejection"),+ );+}++fn worker_global_onrejectionhandled_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set(worker_global_event_handler_value(+ scope,+ args.this(),+ WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT,+ ));+}++fn worker_global_onrejectionhandled_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ set_worker_global_event_handler(+ scope,+ args.this(),+ args.get(0),+ WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT,+ Some("rejectionhandled"),+ );+}++pub(in crate::worker) fn service_worker_fetch_handler_type<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+) -> WorkerFetchHandlerType {+ let listeners = simple_object_event_listeners_snapshot(+ scope,+ global,+ WORKER_GLOBAL_LISTENERS_SLOT,+ "fetch",+ );+ if listeners.is_empty() {+ return WorkerFetchHandlerType::NoHandler;+ }+ if listeners.iter().all(|listener| {+ listener+ .callable_function()+ .is_some_and(|callback| function_source_has_empty_body(scope, callback))+ }) {+ WorkerFetchHandlerType::EmptyFetchHandler+ } else {+ WorkerFetchHandlerType::NotSkippable+ }+}++fn function_source_has_empty_body<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ function: v8::Local<'s, v8::Function>,+) -> bool {+ let Some(source) = function.to_string(scope) else {+ return false;+ };+ let normalized = source+ .to_rust_string_lossy(scope)+ .chars()+ .filter(|ch| !ch.is_whitespace())+ .collect::<String>();+ let Some(open_brace) = normalized.find('{') else {+ return false;+ };+ let Some(close_brace) = normalized.rfind('}') else {+ return false;+ };+ open_brace < close_brace && normalized[open_brace + 1..close_brace].is_empty()+}diff --git a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs b/moli-renderer-v8/src/worker/global_scope/extendable_events.rsnew file mode 100644index 000000000..0a63e56bd--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs@@ -0,0 +1,560 @@+//! Service Worker extendable events and their pending dispatch state.++use super::*;++#[derive(WebApiFunctionTemplate)]+#[webapi(+ interface = web_api_interfaces::ExtendableEvent,+ constructor_callback = extendable_event_constructor_callback,+ constructor_length = 1+)]+struct ExtendableEventTemplateDeclaration {+ #[webapi(method = "waitUntil", callback = extendable_event_wait_until_callback, length = 1)]+ wait_until: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(+ interface = web_api_interfaces::ExtendableMessageEvent,+ constructor_callback = extendable_message_event_constructor_callback,+ constructor_length = 1+)]+struct ExtendableMessageEventTemplateDeclaration {}++#[derive(WebApiObject)]+#[webapi(plain)]+struct ExtendableEventConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "ExtendableEvent")]+ extendable_event: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct ExtendableMessageEventConstructorGlobalDeclaration<'scope> {+ #[webapi(data_property = "ExtendableMessageEvent")]+ extendable_message_event: v8::Local<'scope, v8::Function>,+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::ExtendableEvent, prototype = "Object")]+struct ExtendableEventStateDeclaration {+ #[webapi(data_property, enumerable)]+ composed: bool,+}++#[derive(WebApiObject)]+#[webapi(+ interface = web_api_interfaces::ExtendableMessageEvent,+ prototype = "Object"+)]+struct ExtendableMessageEventStateDeclaration<'scope> {+ #[webapi(data_property, enumerable)]+ data: v8::Local<'scope, v8::Value>,++ #[webapi(data_property, enumerable)]+ origin: String,++ #[webapi(data_property = "lastEventId", enumerable)]+ last_event_id: String,++ #[webapi(data_property, enumerable)]+ source: v8::Local<'scope, v8::Value>,++ #[webapi(data_property, enumerable)]+ ports: v8::Local<'scope, v8::Array>,+}++pub(in crate::worker) struct PendingServiceWorkerLifecycleEvent {+ pub(in crate::worker) completion: ServiceWorkerLifecycleCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+}++pub(in crate::worker) struct PendingServiceWorkerMessageEvent {+ pub(in crate::worker) completion: ServiceWorkerMessageCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+ pub(in crate::worker) window_interaction_allowed: bool,+}++pub(in crate::worker) struct PendingServiceWorkerNotificationEvent {+ pub(in crate::worker) completion: crate::runtime::ServiceWorkerNotificationCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+ pub(in crate::worker) window_interaction_allowed: bool,+}++pub(in crate::worker) struct PendingServiceWorkerPushEvent {+ pub(in crate::worker) completion: crate::runtime::ServiceWorkerPushCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+}++pub(in crate::worker) struct PendingServiceWorkerSyncEvent {+ pub(in crate::worker) completion: crate::runtime::ServiceWorkerSyncCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+}++pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncEvent {+ pub(in crate::worker) completion: crate::runtime::ServiceWorkerPeriodicSyncCompletion,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+}++pub(in crate::worker) struct PendingServiceWorkerFetchEvent {+ pub(in crate::worker) completion: ServiceWorkerFetchCompletion,+ pub(in crate::worker) handled_resolver: Option<v8::Global<v8::PromiseResolver>>,+ pub(in crate::worker) request_signal_id: Option<u32>,+ pub(in crate::worker) request_mode: RequestMode,+ pub(in crate::worker) request_destination: ServiceWorkerRequestDestination,+ pub(in crate::worker) pending_respond_with_response:+ Option<crate::network_host::MaterializedResponseHead>,+ pub(in crate::worker) pending_respond_with_stream_body_source_id: Option<NetworkBodySourceId>,+ pub(in crate::worker) pending_respond_with_stream_cancel_handle: Option<v8::Global<v8::Object>>,+ pub(in crate::worker) respond_with_called: bool,+ pub(in crate::worker) pending_respond_with: bool,+ pub(in crate::worker) pending_wait_until_count: usize,+ pub(in crate::worker) dispatch_finished: bool,+}++impl PendingServiceWorkerFetchEvent {+ pub(in crate::worker) fn fallback(+ completion: ServiceWorkerFetchCompletion,+ request_mode: RequestMode,+ request_destination: ServiceWorkerRequestDestination,+ ) -> Self {+ Self {+ completion: ServiceWorkerFetchCompletion {+ result: ServiceWorkerFetchResult::Fallback,+ ..completion+ },+ handled_resolver: None,+ request_signal_id: None,+ request_mode,+ request_destination,+ pending_respond_with_response: None,+ pending_respond_with_stream_body_source_id: None,+ pending_respond_with_stream_cancel_handle: None,+ respond_with_called: false,+ pending_respond_with: false,+ pending_wait_until_count: 0,+ dispatch_finished: false,+ }+ }+}++pub(in crate::worker) struct PendingServiceWorkerNavigationPreload {+ pub(in crate::worker) owner: crate::service_worker_runtime::ServiceWorkerRunOwner,+ pub(in crate::worker) _promise: v8::Global<v8::Promise>,+ pub(in crate::worker) resolver: Option<v8::Global<v8::PromiseResolver>>,+ pub(in crate::worker) body_source_id: Option<NetworkBodySourceId>,+}++pub(super) fn install_service_worker_extendable_event_constructors<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+) -> Result<()> {+ let extendable_template = ExtendableEventTemplateDeclaration::build(scope);+ let extendable_ctor = extendable_template+ .get_function(scope)+ .ok_or_else(|| anyhow!("failed to build ExtendableEvent constructor"))?;+ let extendable_proto = constructor_prototype(scope, extendable_ctor, "ExtendableEvent")?;+ set_worker_to_string_tag(scope, extendable_proto, "ExtendableEvent");+ if let Some(event_ctor) = global_constructor_object(scope, "Event") {+ let _ = extendable_ctor.set_prototype(scope, event_ctor.into());+ }+ if let Some(event_proto) = global_constructor_prototype(scope, "Event") {+ let _ = extendable_proto.set_prototype(scope, event_proto.into());+ }+ ExtendableEventConstructorGlobalDeclaration::new(extendable_ctor)+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize ExtendableEvent global: {error}"))?;++ let message_template = ExtendableMessageEventTemplateDeclaration::build(scope);+ let message_ctor = message_template+ .get_function(scope)+ .ok_or_else(|| anyhow!("failed to build ExtendableMessageEvent constructor"))?;+ let message_proto = constructor_prototype(scope, message_ctor, "ExtendableMessageEvent")?;+ set_worker_to_string_tag(scope, message_proto, "ExtendableMessageEvent");+ let _ = message_ctor.set_prototype(scope, extendable_ctor.into());+ let _ = message_proto.set_prototype(scope, extendable_proto.into());+ ExtendableMessageEventConstructorGlobalDeclaration::new(message_ctor)+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize ExtendableMessageEvent global: {error}"))?;++ ensure_worker_interface_constructor(scope, "ServiceWorker")?;+ web_api_interfaces::WindowClient::DESCRIPTOR.register(scope)?;+ ensure_worker_interface_constructor(scope, "Client")?;+ ensure_worker_interface_constructor(scope, "WindowClient")?;+ if let Some(client_ctor) = global_constructor_object(scope, "Client")+ && let Some(window_ctor) = global_constructor_object(scope, "WindowClient")+ {+ let _ = window_ctor.set_prototype(scope, client_ctor.into());+ }+ if let Some(client_proto) = global_constructor_prototype(scope, "Client")+ && let Some(window_proto) = global_constructor_prototype(scope, "WindowClient")+ {+ let _ = window_proto.set_prototype(scope, client_proto.into());+ }++ Ok(())+}++fn extendable_event_constructor_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ if !args.is_construct_call() {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableEvent': Please use the 'new' operator.",+ );+ return;+ }+ let Some(event_type) = extendable_event_type_argument(scope, &args, "ExtendableEvent") else {+ return;+ };+ let Some((bubbles, cancelable, composed)) =+ extendable_event_init_flags(scope, &args, "ExtendableEvent")+ else {+ return;+ };+ initialize_extendable_event_object(+ scope,+ args.this(),+ &event_type,+ bubbles,+ cancelable,+ composed,+ );+ rv.set(args.this().into());+}++fn extendable_message_event_constructor_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ if !args.is_construct_call() {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': Please use the 'new' operator.",+ );+ return;+ }+ let Some(event_type) = extendable_event_type_argument(scope, &args, "ExtendableMessageEvent")+ else {+ return;+ };+ let init = extendable_event_init_object(&args);+ let Some((bubbles, cancelable, composed)) =+ extendable_event_init_flags(scope, &args, "ExtendableMessageEvent")+ else {+ return;+ };+ let Some(data) = extendable_message_event_data(scope, init) else {+ return;+ };+ let Some(origin) = extendable_message_event_string_member(scope, init, "origin", "") else {+ return;+ };+ let Some(last_event_id) =+ extendable_message_event_string_member(scope, init, "lastEventId", "")+ else {+ return;+ };+ let Some(source) = extendable_message_event_source(scope, init) else {+ return;+ };+ let Some(ports) = extendable_message_event_ports(scope, init) else {+ return;+ };++ let event = args.this();+ initialize_extendable_event_object(scope, event, &event_type, bubbles, cancelable, composed);+ let _ = ExtendableMessageEventStateDeclaration::new(data, origin, last_event_id, source, ports)+ .initialize(scope, event);+ rv.set(event.into());+}++fn extendable_event_type_argument<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ constructor_name: &'static str,+) -> Option<String> {+ if args.length() == 0 {+ throw_type_error(+ scope,+ &format!("Failed to construct '{constructor_name}': 1 argument required."),+ );+ return None;+ }+ webidl::argument::<webidl::DomString>(+ scope,+ args,+ 0,+ webidl::Context::argument(constructor_name, 1),+ )+ .map(Into::into)+ .map_or_else(+ |error| {+ webidl::throw_error(scope, &error);+ None+ },+ Some,+ )+}++fn extendable_event_init_object<'s>(+ args: &v8::FunctionCallbackArguments<'s>,+) -> Option<v8::Local<'s, v8::Object>> {+ if args.length() <= 1 {+ return None;+ }+ let value = args.get(1);+ if value.is_null_or_undefined() || !value.is_object() {+ None+ } else {+ v8::Local::<v8::Object>::try_from(value).ok()+ }+}++fn extendable_event_init_flags<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ constructor_name: &'static str,+) -> Option<(bool, bool, bool)> {+ let init = extendable_event_init_object(args);+ Some((+ extendable_event_bool_member(scope, init, constructor_name, "bubbles")?,+ extendable_event_bool_member(scope, init, constructor_name, "cancelable")?,+ extendable_event_bool_member(scope, init, constructor_name, "composed")?,+ ))+}++fn extendable_event_bool_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+ prefix: &'static str,+ key: &'static str,+) -> Option<bool> {+ let Some(init) = init else {+ return Some(false);+ };+ let value =+ match webidl::property_result(scope, init, key, webidl::Context::member(prefix, key)) {+ Ok(Some(value)) if !value.is_undefined() => value,+ Ok(_) => return Some(false),+ Err(error) => {+ webidl::throw_error(scope, &error);+ return None;+ }+ };+ webidl::convert::<webidl::Boolean>(scope, value, webidl::Context::member(prefix, key))+ .map(Into::into)+ .map_or_else(+ |error| {+ webidl::throw_error(scope, &error);+ None+ },+ Some,+ )+}++fn initialize_extendable_event_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ event_type: &str,+ bubbles: bool,+ cancelable: bool,+ composed: bool,+) {+ // EventTarget dispatch and inherited Event methods require the base+ // event's internal state, in addition to its visible properties.+ crate::context_bootstrap::initialize_event_object(+ scope, event, event_type, bubbles, cancelable,+ );+ ExtendableEventStateDeclaration::new(composed)+ .initialize(scope, event)+ .expect("extendable event state should initialize");+}++fn extendable_message_event_data<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+) -> Option<v8::Local<'s, v8::Value>> {+ let Some(init) = init else {+ return Some(v8::null(scope).into());+ };+ match webidl::property_result(+ scope,+ init,+ "data",+ webidl::Context::member("ExtendableMessageEvent", "data"),+ ) {+ Ok(Some(value)) if !value.is_undefined() => Some(value),+ Ok(_) => Some(v8::null(scope).into()),+ Err(error) => {+ webidl::throw_error(scope, &error);+ None+ }+ }+}++fn extendable_message_event_string_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+ key: &'static str,+ default: &'static str,+) -> Option<String> {+ let Some(init) = init else {+ return Some(default.to_owned());+ };+ let value = match webidl::property_result(+ scope,+ init,+ key,+ webidl::Context::member("ExtendableMessageEvent", key),+ ) {+ Ok(Some(value)) if !value.is_undefined() => value,+ Ok(_) => return Some(default.to_owned()),+ Err(error) => {+ webidl::throw_error(scope, &error);+ return None;+ }+ };+ webidl::convert::<webidl::DomString>(+ scope,+ value,+ webidl::Context::member("ExtendableMessageEvent", key),+ )+ .map(Into::into)+ .map_or_else(+ |error| {+ webidl::throw_error(scope, &error);+ None+ },+ Some,+ )+}++fn extendable_message_event_source<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+) -> Option<v8::Local<'s, v8::Value>> {+ let Some(init) = init else {+ return Some(v8::null(scope).into());+ };+ let value = match webidl::property_result(+ scope,+ init,+ "source",+ webidl::Context::member("ExtendableMessageEvent", "source"),+ ) {+ Ok(Some(value)) if !value.is_null_or_undefined() => value,+ Ok(_) => return Some(v8::null(scope).into()),+ Err(error) => {+ webidl::throw_error(scope, &error);+ return None;+ }+ };+ let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': member source is not of type Client, ServiceWorker, or MessagePort.",+ );+ return None;+ };+ if extendable_message_event_source_object_is_valid(scope, object) {+ Some(value)+ } else {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': member source is not of type Client, ServiceWorker, or MessagePort.",+ );+ None+ }+}++fn extendable_message_event_source_object_is_valid<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+) -> bool {+ crate::context_bootstrap::message_port_id_from_object(scope, object).is_some()+ || get_private_value(scope, object, SERVICE_WORKER_CLIENT_ID_SLOT).is_some()+ || (get_private_value(scope, object, SERVICE_WORKER_VERSION_ID_SLOT).is_some()+ && object+ .get(scope, v8str(scope, "scriptURL").into())+ .is_some_and(|value| value.is_string()))+}++fn extendable_message_event_ports<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ init: Option<v8::Local<'s, v8::Object>>,+) -> Option<v8::Local<'s, v8::Array>> {+ let Some(init) = init else {+ return Some(frozen_empty_worker_array(scope));+ };+ let value = match webidl::property_result(+ scope,+ init,+ "ports",+ webidl::Context::member("ExtendableMessageEvent", "ports"),+ ) {+ Ok(Some(value)) if !value.is_undefined() => value,+ Ok(_) => return Some(frozen_empty_worker_array(scope)),+ Err(error) => {+ webidl::throw_error(scope, &error);+ return None;+ }+ };+ let Ok(source) = v8::Local::<v8::Array>::try_from(value) else {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': member ports is not a sequence<MessagePort>.",+ );+ return None;+ };+ let ports = v8::Array::new(scope, source.length() as i32);+ for index in 0..source.length() {+ let port = source.get_index(scope, index)?;+ let Ok(port_object) = v8::Local::<v8::Object>::try_from(port) else {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': member ports contains a non-MessagePort value.",+ );+ return None;+ };+ if crate::context_bootstrap::message_port_id_from_object(scope, port_object).is_none() {+ throw_type_error(+ scope,+ "Failed to construct 'ExtendableMessageEvent': member ports contains a non-MessagePort value.",+ );+ return None;+ }+ let _ = ports.set_index(scope, index, port);+ }+ let _ = ports.set_integrity_level(scope, v8::IntegrityLevel::Frozen);+ Some(ports)+}++fn frozen_empty_worker_array<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Array> {+ let array = v8::Array::new(scope, 0);+ let _ = array.set_integrity_level(scope, v8::IntegrityLevel::Frozen);+ array+}++fn extendable_event_wait_until_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ _args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let exception = worker_dom_exception_value(+ scope,+ "ExtendableEvent.waitUntil() was called outside an active event dispatch.",+ "InvalidStateError",+ );+ scope.throw_exception(exception);+}diff --git a/moli-renderer-v8/src/worker/global_scope/import_scripts.rs b/moli-renderer-v8/src/worker/global_scope/import_scripts.rsindex a8cf664f6..fe14d3a74 100644--- a/moli-renderer-v8/src/worker/global_scope/import_scripts.rs+++ b/moli-renderer-v8/src/worker/global_scope/import_scripts.rs@@ -7,7 +7,7 @@ pub(super) struct WorkerImportScriptSource {resource: Option<crate::worker::WorkerScriptResource>,}-pub(super) fn resolve_import_script_url(+fn resolve_import_script_url(state: Rc<RefCell<WorkerGlobalState>>,input: &str,) -> Result<Url, WorkerImportScriptError> {@@ -36,7 +36,7 @@ pub(super) fn resolve_import_script_url(Ok(url)}-pub(super) fn materialize_worker_import_source(+fn materialize_worker_import_source(scope: &mut v8::PinScope<'_, '_>,state: &Rc<RefCell<WorkerGlobalState>>,script_url: &Url,@@ -244,7 +244,7 @@ fn report_service_worker_imported_script_loaded(});}-pub(super) fn evaluate_worker_script(+fn evaluate_worker_script(scope: &mut v8::PinScope<'_, '_>,state: Rc<RefCell<WorkerGlobalState>>,script_url: &Url,@@ -317,3 +317,209 @@ pub(super) fn evaluate_worker_script(}// ─── console ────────────────────────────────────────────────────────────────++pub(in crate::worker) const WORKER_EXCEPTION_SOURCE_SLOT: &str = "__moliWorkerExceptionSource";++pub(in crate::worker) const WORKER_EXCEPTION_LINE_SLOT: &str = "__moliWorkerExceptionLine";++pub(in crate::worker) const WORKER_EXCEPTION_COLUMN_SLOT: &str = "__moliWorkerExceptionColumn";++enum WorkerImportScriptError {+ DomException { name: &'static str, message: String },+ Exception(v8::Global<v8::Value>),+}++impl WorkerImportScriptError {+ fn syntax(message: impl Into<String>) -> Self {+ Self::DomException {+ name: "SyntaxError",+ message: message.into(),+ }+ }++ fn network(message: impl Into<String>) -> Self {+ Self::DomException {+ name: "NetworkError",+ message: message.into(),+ }+ }++ fn error<'s>(scope: &mut v8::PinScope<'s, '_>, message: impl Into<String>) -> Self {+ let message = message.into();+ let value = v8_string(scope, &message)+ .map(|value| v8::Exception::error(scope, value))+ .unwrap_or_else(|| v8::Exception::error(scope, v8::String::empty(scope)));+ Self::Exception(v8::Global::new(scope, value))+ }++ fn throw(self, scope: &mut v8::PinScope<'_, '_>) {+ match self {+ Self::DomException { name, message } => {+ let exception = worker_dom_exception_value(scope, &message, name);+ scope.throw_exception(exception);+ }+ Self::Exception(value) => {+ let value = v8::Local::new(scope, value);+ scope.throw_exception(value);+ }+ }+ }+}++struct PreparedWorkerImportScript {+ final_url: Url,+ source: Option<String>,+ muted_errors: bool,+}++fn annotate_worker_exception_location<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ exception: v8::Local<'s, v8::Value>,+ message: Option<v8::Local<'s, v8::Message>>,+) {+ let Ok(object) = v8::Local::<v8::Object>::try_from(exception) else {+ return;+ };+ let source = message+ .and_then(|message| message.get_script_resource_name(scope))+ .and_then(|value| value.to_string(scope))+ .map(|value| value.to_rust_string_lossy(scope))+ .filter(|value| !value.is_empty());+ if let Some(source) = source+ && let Some(value) = v8_string(scope, &source)+ {+ set_worker_exception_location_if_missing(+ scope,+ object,+ WORKER_EXCEPTION_SOURCE_SLOT,+ value.into(),+ );+ }+ if let Some(line) = message.and_then(|message| message.get_line_number(scope)) {+ let value = v8::Number::new(scope, line as f64);+ set_worker_exception_location_if_missing(+ scope,+ object,+ WORKER_EXCEPTION_LINE_SLOT,+ value.into(),+ );+ }+ if let Some(column) = message.and_then(|message| message.get_start_column().checked_add(1)) {+ let value = v8::Number::new(scope, column as f64);+ set_worker_exception_location_if_missing(+ scope,+ object,+ WORKER_EXCEPTION_COLUMN_SLOT,+ value.into(),+ );+ }+}++fn set_worker_exception_location_if_missing<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ slot: &str,+ value: v8::Local<'s, v8::Value>,+) {+ if get_private_value(scope, object, slot).is_none() {+ set_private_value(scope, object, slot, value);+ }+}++pub(super) fn worker_import_scripts_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ if state.borrow().script_kind == crate::worker::thread::WorkerScriptKind::Module {+ throw_type_error(scope, "Module scripts don't support importScripts().");+ return;+ }+ let require_trusted_types_for_script =+ crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(+ &state.borrow().content_security_policies,+ );+ let mut prepared = Vec::with_capacity(args.length() as usize);+ for i in 0..args.length() {+ let Some(specifier) = crate::context_bootstrap::trusted_script_url_string_or_throw(+ scope,+ args.get(i),+ crate::content_security_policy::TrustedTypesForScriptRequirements::enforced_only(+ require_trusted_types_for_script,+ ),+ "WorkerGlobalScope importScripts",+ "importScripts",+ ) else {+ return;+ };+ let resolved_url = match resolve_import_script_url(state.clone(), &specifier) {+ Ok(url) => url,+ Err(error) => {+ error.throw(scope);+ return;+ }+ };+ let source = if matches!(resolved_url.scheme(), "data" | "blob") {+ match materialize_worker_import_source(scope, &state, &resolved_url) {+ Ok(import_source) => Some(import_source.source),+ Err(error) => {+ error.throw(scope);+ return;+ }+ }+ } else {+ None+ };+ prepared.push(PreparedWorkerImportScript {+ final_url: resolved_url,+ source,+ muted_errors: false,+ });+ }+ for mut script in prepared {+ if script.source.is_none() {+ let import_source =+ match materialize_worker_import_source(scope, &state, &script.final_url) {+ Ok(result) => result,+ Err(error) => {+ error.throw(scope);+ return;+ }+ };+ script.final_url = import_source.final_url;+ script.source = Some(import_source.source);+ script.muted_errors = import_source.muted_errors;+ }+ let source = script.source.as_deref().unwrap_or_default();+ if let Err(error) = evaluate_worker_script(+ scope,+ state.clone(),+ &script.final_url,+ source,+ script.muted_errors,+ ) {+ error.throw(scope);+ return;+ }+ }+}++fn create_script_origin<'s>(scope: &mut v8::PinScope<'s, '_>, url: &str) -> v8::ScriptOrigin<'s> {+ let name = v8::String::new(scope, url).expect("worker script origin");+ v8::ScriptOrigin::new(+ scope,+ name.into(),+ 0,+ 0,+ false,+ -1,+ None,+ false,+ false,+ false,+ None,+ )+}diff --git a/moli-renderer-v8/src/worker/global_scope/messaging.rs b/moli-renderer-v8/src/worker/global_scope/messaging.rsnew file mode 100644index 000000000..bed0c49d4--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/messaging.rs@@ -0,0 +1,236 @@+//! Worker postMessage, structured cloning, MessagePorts and BroadcastChannels.++use super::*;++#[derive(Default, WebApiObject)]+#[webapi(plain)]+pub(super) struct DedicatedWorkerGlobalPostMessageDeclaration {+ #[webapi(method = "postMessage", callback = worker_post_message_callback, length = 1)]+ post_message: (),+}++/// Mutable state accessible from V8 callbacks inside the worker isolate.+pub(in crate::worker) struct WorkerMessagePortWrapperEntry {+ wrapper: v8::Global<v8::Object>,+}++pub(crate) fn worker_message_port_wake_sender(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<mpsc::UnboundedSender<crate::worker::handle::WorkerMessage>> {+ Some(get_worker_state(scope)?.borrow().worker_wake_tx.clone())+}++pub(crate) fn worker_message_port_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<SharedMessagePortRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .message_port_registry+ .clone(),+ )+}++pub(crate) fn worker_broadcast_channel_wake_sender(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<mpsc::UnboundedSender<crate::worker::handle::WorkerMessage>> {+ Some(get_worker_state(scope)?.borrow().worker_wake_tx.clone())+}++pub(crate) fn worker_broadcast_channel_registry(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<SharedBroadcastChannelRegistry> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .broadcast_channel_registry+ .clone(),+ )+}++pub(crate) fn worker_broadcast_channel_storage_key(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<MoliStorageKey> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .broadcast_channel_storage_key+ .clone(),+ )+}++pub(crate) fn register_worker_message_port_wrapper(+ scope: &mut v8::PinScope<'_, '_>,+ port_id: MessagePortId,+ port: v8::Local<'_, v8::Object>,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ state.borrow_mut().message_port_wrappers.insert(+ port_id,+ WorkerMessagePortWrapperEntry {+ wrapper: v8::Global::new(scope, port),+ },+ );+}++pub(crate) fn register_shared_worker_connection_port(+ scope: &mut v8::PinScope<'_, '_>,+ port_id: MessagePortId,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ state+ .borrow_mut()+ .shared_worker_connection_ports+ .insert(port_id);+}++pub(crate) fn forget_worker_message_port_wrapper(+ scope: &mut v8::PinScope<'_, '_>,+ port_id: MessagePortId,+) {+ if let Some(state) = get_worker_state(scope) {+ state.borrow_mut().message_port_wrappers.remove(&port_id);+ }+}++pub(crate) fn worker_message_port_wrapper<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ port_id: MessagePortId,+) -> Option<v8::Local<'s, v8::Object>> {+ let state = get_worker_state(scope)?;+ let state = state.borrow();+ state+ .message_port_wrappers+ .get(&port_id)+ .map(|entry| v8::Local::new(scope, &entry.wrapper))+}++pub(crate) fn register_worker_broadcast_channel_wrapper(+ scope: &mut v8::PinScope<'_, '_>,+ channel_id: BroadcastChannelId,+ channel: v8::Local<'_, v8::Object>,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ state+ .borrow_mut()+ .broadcast_channel_wrappers+ .insert(channel_id, v8::Global::new(scope, channel));+}++pub(crate) fn forget_worker_broadcast_channel_wrapper(+ scope: &mut v8::PinScope<'_, '_>,+ channel_id: BroadcastChannelId,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ state+ .borrow_mut()+ .broadcast_channel_wrappers+ .remove(&channel_id);+}++pub(crate) fn worker_broadcast_channel_wrapper<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ channel_id: BroadcastChannelId,+) -> Option<v8::Local<'s, v8::Object>> {+ let state = get_worker_state(scope)?;+ let state = state.borrow();+ state+ .broadcast_channel_wrappers+ .get(&channel_id)+ .map(|handle| v8::Local::new(scope, handle))+}++pub(in crate::worker) fn close_worker_owned_message_ports(state: &Rc<RefCell<WorkerGlobalState>>) {+ let (registry, port_ids): (SharedMessagePortRegistry, Vec<MessagePortId>) = {+ let mut state = state.borrow_mut();+ let shared_worker_connection_ports =+ std::mem::take(&mut state.shared_worker_connection_ports);+ (+ state.message_port_registry.clone(),+ state+ .message_port_wrappers+ .drain()+ .filter_map(|(port_id, _)| {+ (!shared_worker_connection_ports.contains(&port_id)).then_some(port_id)+ })+ .collect(),+ )+ };+ for port_id in port_ids {+ registry.close_message_port(port_id);+ }+}++pub(in crate::worker) fn close_worker_owned_broadcast_channels(+ state: &Rc<RefCell<WorkerGlobalState>>,+) {+ let (registry, channel_ids): (SharedBroadcastChannelRegistry, Vec<BroadcastChannelId>) = {+ let mut state = state.borrow_mut();+ (+ state.broadcast_channel_registry.clone(),+ state+ .broadcast_channel_wrappers+ .drain()+ .map(|(channel_id, _)| channel_id)+ .collect(),+ )+ };+ for channel_id in channel_ids {+ registry.close_broadcast_channel(channel_id);+ }+}++fn worker_post_message_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(state) = get_worker_state(scope) else {+ return;+ };+ if args.length() == 0 {+ throw_type_error(+ scope,+ "Failed to execute 'postMessage' on 'DedicatedWorkerGlobalScope': 1 argument required, but only 0 present.",+ );+ return;+ }+ let val = args.get(0);+ let transfer_arg = (args.length() > 1).then(|| args.get(1));+ let Some(data) = crate::context_bootstrap::structured_serialize_value_for_post_message(+ scope,+ val,+ transfer_arg,+ "DedicatedWorkerGlobalScope",+ ) else {+ return;+ };+ let _ = state+ .borrow()+ .parent_tx+ .send(WorkerToParentMessage::Post(data));+}++pub(super) fn worker_structured_clone_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ if let Some(value) = crate::context_bootstrap::structured_clone_value_with_options(+ scope,+ args.get(0),+ args.get(1),+ ) {+ rv.set(value);+ } else {+ rv.set_undefined();+ }+}diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rsindex e82c45afc..2050ece39 100644--- a/moli-renderer-v8/src/worker/global_scope/mod.rs+++ b/moli-renderer-v8/src/worker/global_scope/mod.rs@@ -1,15 +1,7 @@-//! Bootstrap the `DedicatedWorkerGlobalScope` — the JS global environment-//! visible inside a Web Worker.+//! WorkerGlobalScope bindings for dedicated, shared and service workers.//!-//! Workers have no DOM access. The global exposes:-//! - `self` (the global itself)-//! - `postMessage(data)` — send to parent-//! - `onmessage` / `onmessageerror` and functional service worker handlers-//! - `close()` — request worker shutdown-//! - `console` (log/warn/error/info/profile/profileEnd)-//! - `setTimeout` / `clearTimeout` / `setInterval` / `clearInterval`-//! - `requestAnimationFrame` / `cancelAnimationFrame`-//! - `globalThis`+//! Initialization, runtime state and API implementations live in the child modules.+//! This module retains the existing worker-facing exports and shared imports.use crate::web_api_interfaces;use std::cell::RefCell;@@ -124,12 +116,25 @@ use crate::worker::abort::{worker_abort_signal_id, worker_abort_signal_reason, worker_dom_exception_value,};+mod async_tasks;+mod bootstrap;+mod console;mod content_security_policy;+mod event_handlers;+mod extendable_events;mod fetch;mod import_scripts;+mod messaging;+mod nested_workers;+mod network_state;+mod origin;+mod performance;mod service_worker_api;+mod service_worker_results;+mod state;mod timers;mod xhr;+use self::service_worker_api::*;pub(super) use self::service_worker_api::{build_service_worker_client_object, build_service_worker_client_object_from_snapshot,@@ -149,4997 +154,96 @@ use import_scripts::*;use timers::*;pub(crate) use xhr::*;-pub(super) fn dispatch_worker_csp_violation_event<'s>(- scope: &mut v8::PinScope<'s, '_>,- loader: &crate::network::context::WorkerResourceLoader,- violation: &crate::content_security_policy::ContentSecurityPolicyUrlViolation,-) {- content_security_policy::dispatch_worker_content_security_policy_violation_event(- scope, loader, violation,- );-}--pub(super) const WORKER_GLOBAL_LISTENERS_SLOT: &str = "__moliWorkerGlobalListeners";-pub(crate) const WORKER_STATE_SLOT: &str = "__workerState";-const WORKER_GLOBAL_ONMESSAGE_SLOT: &str = "__moliWorkerGlobalOnMessage";-const WORKER_GLOBAL_ONMESSAGEERROR_SLOT: &str = "__moliWorkerGlobalOnMessageError";-const WORKER_GLOBAL_ONERROR_SLOT: &str = "__moliWorkerGlobalOnError";-const WORKER_GLOBAL_ONCONNECT_SLOT: &str = "__moliWorkerGlobalOnConnect";-const WORKER_GLOBAL_ONINSTALL_SLOT: &str = "__moliWorkerGlobalOnInstall";-const WORKER_GLOBAL_ONACTIVATE_SLOT: &str = "__moliWorkerGlobalOnActivate";-const WORKER_GLOBAL_ONFETCH_SLOT: &str = "__moliWorkerGlobalOnFetch";-const WORKER_GLOBAL_ONPUSH_SLOT: &str = "__moliWorkerGlobalOnPush";-const WORKER_GLOBAL_ONSYNC_SLOT: &str = "__moliWorkerGlobalOnSync";-const WORKER_GLOBAL_ONPERIODICSYNC_SLOT: &str = "__moliWorkerGlobalOnPeriodicSync";-const WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT: &str = "__moliWorkerGlobalOnNotificationClick";-const WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT: &str = "__moliWorkerGlobalOnNotificationClose";-const WORKER_GLOBAL_ONOFFLINE_SLOT: &str = "__moliWorkerGlobalOnOffline";-const WORKER_GLOBAL_ONONLINE_SLOT: &str = "__moliWorkerGlobalOnOnline";-const WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT: &str = "__moliWorkerGlobalOnUnhandledRejection";-const WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT: &str = "__moliWorkerGlobalOnRejectionHandled";-pub(super) const WORKER_EXCEPTION_SOURCE_SLOT: &str = "__moliWorkerExceptionSource";-pub(super) const WORKER_EXCEPTION_LINE_SLOT: &str = "__moliWorkerExceptionLine";-pub(super) const WORKER_EXCEPTION_COLUMN_SLOT: &str = "__moliWorkerExceptionColumn";-const SERVICE_WORKER_REGISTRATION_SCOPE_SLOT: &str = "__moliServiceWorkerRegistrationScope";-const SERVICE_WORKER_REGISTRATION_ID_SLOT: &str = "__moliServiceWorkerRegistrationId";-const SERVICE_WORKER_VERSION_ID_SLOT: &str = "__moliServiceWorkerVersionId";-const SERVICE_WORKER_WORKER_EVENTS_SLOT: &str = "__moliServiceWorkerWorkerEvents";-const SERVICE_WORKER_NAVIGATION_PRELOAD_MANAGER_SCOPE_SLOT: &str =- "__moliServiceWorkerNavigationPreloadManagerScope";-const SERVICE_WORKER_CLIENT_ID_SLOT: &str = "__lmServiceWorkerClientId";-const WORKER_ORIGINAL_CONSOLE_SLOT: &str = "__moliWorkerOriginalConsole";-const WORKER_GLOBAL_ORIGIN_SLOT: &str = "__moliWorkerGlobalOrigin";--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalBootstrapPropertiesDeclaration<'scope> {- #[webapi(slot = WORKER_STATE_SLOT)]- worker_state: v8::Local<'scope, v8::External>,- #[webapi(data_property = "self", readonly)]- self_value: v8::Local<'scope, v8::Object>,- #[webapi(data_property = "crossOriginIsolated")]- cross_origin_isolated: bool,- #[webapi(data_property = "isSecureContext", readonly)]- is_secure_context: bool,- #[webapi(data_property = "globalThis")]- global_this: v8::Local<'scope, v8::Object>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalNameDeclaration {- #[webapi(data_property, enumerable)]- name: String,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalOriginDeclaration {- #[webapi(slot = WORKER_GLOBAL_ORIGIN_SLOT)]- origin: String,-}--#[derive(Default, WebApiObject)]-#[webapi(fragment, prototype = "WorkerGlobalScope", enumerable)]-struct WorkerGlobalOriginPrototypeDeclaration {- #[webapi(- accessor_property,- getter = worker_global_origin_getter,- setter = worker_global_origin_setter- )]- origin: (),-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalConsoleDeclaration<'scope> {- #[webapi(data_property)]- console: v8::Local<'scope, v8::Object>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalPerformanceDeclaration<'scope> {- #[webapi(data_property)]- performance: v8::Local<'scope, v8::Object>,-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct WorkerConsoleObjectDeclaration {- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "log"))]- log: (),- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "info"))]- info: (),- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "warn"))]- warn: (),- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "error"))]- error: (),- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "debug"))]- debug: (),- #[webapi(method, enumerable, callback = console_log_callback, data = v8str(scope, "trace"))]- trace: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- time: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- time_log: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- time_end: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- count: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- count_reset: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- dir: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- dirxml: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- table: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- group: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- group_end: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- group_collapsed: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- clear: (),- #[webapi(method, enumerable, callback = console_noop_callback)]- assert: (),- #[webapi(method, enumerable, callback = console_profile_callback)]- profile: (),- #[webapi(method, enumerable, callback = console_profile_end_callback)]- profile_end: (),-}--#[derive(WebApiObject)]-#[webapi(prototype = "Object", interface = web_api_interfaces::Performance)]-struct WorkerPerformanceObjectDeclaration {- #[webapi(data_property, readonly)]- time_origin: f64,- #[webapi(method, callback = worker_performance_now_callback, data = self.time_origin)]- now: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain, enumerable)]-struct WorkerGlobalCommonEventHandlersDeclaration {- #[webapi(- accessor_property = "onerror",- getter = worker_global_onerror_getter,- setter = worker_global_onerror_setter- )]- onerror: (),- #[webapi(- accessor_property = "onoffline",- getter = worker_global_onoffline_getter,- setter = worker_global_onoffline_setter- )]- onoffline: (),- #[webapi(- accessor_property = "ononline",- getter = worker_global_ononline_getter,- setter = worker_global_ononline_setter- )]- ononline: (),- #[webapi(- accessor_property = "onunhandledrejection",- getter = worker_global_onunhandledrejection_getter,- setter = worker_global_onunhandledrejection_setter- )]- onunhandledrejection: (),- #[webapi(- accessor_property = "onrejectionhandled",- getter = worker_global_onrejectionhandled_getter,- setter = worker_global_onrejectionhandled_setter- )]- onrejectionhandled: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain, enumerable)]-struct DedicatedWorkerGlobalEventHandlersDeclaration {- #[webapi(- accessor_property = "onmessage",- getter = worker_global_onmessage_getter,- setter = worker_global_onmessage_setter- )]- onmessage: (),- #[webapi(- accessor_property = "onmessageerror",- getter = worker_global_onmessageerror_getter,- setter = worker_global_onmessageerror_setter- )]- onmessageerror: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain, enumerable)]-struct SharedWorkerGlobalEventHandlersDeclaration {- #[webapi(- accessor_property = "onconnect",- getter = worker_global_onconnect_getter,- setter = worker_global_onconnect_setter- )]- onconnect: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalCommonEventHandlerStateDeclaration {- #[webapi(slot = WORKER_GLOBAL_ONERROR_SLOT, init = "null")]- onerror: (),- #[webapi(slot = WORKER_GLOBAL_ONOFFLINE_SLOT, init = "null")]- onoffline: (),- #[webapi(slot = WORKER_GLOBAL_ONONLINE_SLOT, init = "null")]- ononline: (),- #[webapi(slot = WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT, init = "null")]- onunhandledrejection: (),- #[webapi(slot = WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT, init = "null")]- onrejectionhandled: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct DedicatedWorkerGlobalEventHandlerStateDeclaration {- #[webapi(slot = WORKER_GLOBAL_ONMESSAGE_SLOT, init = "null")]- onmessage: (),- #[webapi(slot = WORKER_GLOBAL_ONMESSAGEERROR_SLOT, init = "null")]- onmessageerror: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct SharedWorkerGlobalEventHandlerStateDeclaration {- #[webapi(slot = WORKER_GLOBAL_ONCONNECT_SLOT, init = "null")]- onconnect: (),-}--#[derive(Default, WebApiObject)]-#[webapi(fragment, prototype = "DedicatedWorkerGlobalScope", enumerable)]-struct DedicatedWorkerGlobalMethodsDeclaration {- #[webapi(method, callback = worker_close_callback, length = 0)]- close: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct DedicatedWorkerGlobalPostMessageDeclaration {- #[webapi(method = "postMessage", callback = worker_post_message_callback, length = 1)]- post_message: (),-}--#[derive(Default, WebApiObject)]-#[webapi(fragment, prototype = "SharedWorkerGlobalScope", enumerable)]-struct SharedWorkerGlobalMethodsDeclaration {- #[webapi(method, callback = worker_close_callback, length = 0)]- close: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalCommonOperationsDeclaration {- #[webapi(- method = "structuredClone",- callback = worker_structured_clone_callback,- length = 1- )]- structured_clone: (),- #[webapi(method, callback = worker_fetch_callback, length = 1)]- fetch: (),- #[webapi(method = "importScripts", callback = worker_import_scripts_callback, length = 0)]- import_scripts: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalTimerOperationsDeclaration {- #[webapi(method = "setTimeout", callback = worker_set_timeout_callback, length = 1)]- set_timeout: (),- #[webapi(method = "clearTimeout", callback = worker_clear_timeout_callback, length = 1)]- clear_timeout: (),- #[webapi(method = "setInterval", callback = worker_set_interval_callback, length = 1)]- set_interval: (),- #[webapi(method = "clearInterval", callback = worker_clear_interval_callback, length = 1)]- clear_interval: (),- #[webapi(- method = "requestAnimationFrame",- callback = worker_request_animation_frame_callback,- length = 1- )]- request_animation_frame: (),- #[webapi(- method = "cancelAnimationFrame",- callback = worker_clear_timeout_callback,- length = 1- )]- cancel_animation_frame: (),- #[webapi(- method = "queueMicrotask",- callback = worker_queue_microtask_callback,- length = 1- )]- queue_microtask: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalCreateImageBitmapDeclaration {- #[webapi(- method = "createImageBitmap",- callback = worker_create_image_bitmap_callback,- length = 1- )]- create_image_bitmap: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain, enumerable)]-struct ServiceWorkerGlobalEventHandlersDeclaration {- #[webapi(- accessor_property = "oninstall",- getter = worker_global_oninstall_getter,- setter = worker_global_oninstall_setter- )]- oninstall: (),- #[webapi(- accessor_property = "onactivate",- getter = worker_global_onactivate_getter,- setter = worker_global_onactivate_setter- )]- onactivate: (),- #[webapi(- accessor_property = "onfetch",- getter = worker_global_onfetch_getter,- setter = worker_global_onfetch_setter- )]- onfetch: (),- #[webapi(- accessor_property = "onpush",- getter = worker_global_onpush_getter,- setter = worker_global_onpush_setter- )]- onpush: (),- #[webapi(- accessor_property = "onsync",- getter = worker_global_onsync_getter,- setter = worker_global_onsync_setter- )]- onsync: (),- #[webapi(- accessor_property = "onperiodicsync",- getter = worker_global_onperiodicsync_getter,- setter = worker_global_onperiodicsync_setter- )]- onperiodicsync: (),- #[webapi(- accessor_property = "onmessage",- getter = worker_global_onmessage_getter,- setter = worker_global_onmessage_setter- )]- onmessage: (),- #[webapi(- accessor_property = "onmessageerror",- getter = worker_global_onmessageerror_getter,- setter = worker_global_onmessageerror_setter- )]- onmessageerror: (),- #[webapi(- accessor_property = "onnotificationclick",- getter = worker_global_onnotificationclick_getter,- setter = worker_global_onnotificationclick_setter- )]- onnotificationclick: (),- #[webapi(- accessor_property = "onnotificationclose",- getter = worker_global_onnotificationclose_getter,- setter = worker_global_onnotificationclose_setter- )]- onnotificationclose: (),-}--#[derive(Default, WebApiObject)]-#[webapi(plain)]-struct ServiceWorkerGlobalEventHandlerStateDeclaration {- #[webapi(slot = WORKER_GLOBAL_ONINSTALL_SLOT, init = "null")]- oninstall: (),- #[webapi(slot = WORKER_GLOBAL_ONACTIVATE_SLOT, init = "null")]- onactivate: (),- #[webapi(slot = WORKER_GLOBAL_ONFETCH_SLOT, init = "null")]- onfetch: (),- #[webapi(slot = WORKER_GLOBAL_ONPUSH_SLOT, init = "null")]- onpush: (),- #[webapi(slot = WORKER_GLOBAL_ONSYNC_SLOT, init = "null")]- onsync: (),- #[webapi(slot = WORKER_GLOBAL_ONPERIODICSYNC_SLOT, init = "null")]- onperiodicsync: (),- #[webapi(slot = WORKER_GLOBAL_ONMESSAGE_SLOT, init = "null")]- onmessage: (),- #[webapi(slot = WORKER_GLOBAL_ONMESSAGEERROR_SLOT, init = "null")]- onmessageerror: (),- #[webapi(slot = WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT, init = "null")]- onnotificationclick: (),- #[webapi(slot = WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT, init = "null")]- onnotificationclose: (),-}--#[derive(Default, WebApiObject)]-#[webapi(interface = web_api_interfaces::Clients, prototype = "Object")]-struct ServiceWorkerClientsDeclaration {- #[webapi(method, callback = service_worker_clients_claim_callback, length = 0)]- claim: (),- #[webapi(method, callback = service_worker_clients_get_callback, length = 1)]- get: (),- #[webapi(- method = "matchAll",- callback = service_worker_clients_match_all_callback,- length = 0- )]- match_all: (),- #[webapi(- method = "openWindow",- callback = service_worker_clients_open_window_callback,- length = 1- )]- open_window: (),-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct ServiceWorkerGlobalRuntimeDeclaration<'scope> {- #[webapi(data_property, readonly)]- registration: v8::Local<'scope, v8::Object>,- #[webapi(data_property, readonly)]- clients: v8::Local<'scope, v8::Object>,- #[webapi(method = "skipWaiting", callback = service_worker_skip_waiting_callback, length = 0)]- skip_waiting: (),-}--#[derive(WebApiFunctionTemplate)]-#[webapi(- interface = web_api_interfaces::ExtendableEvent,- constructor_callback = extendable_event_constructor_callback,- constructor_length = 1-)]-struct ExtendableEventTemplateDeclaration {- #[webapi(method = "waitUntil", callback = extendable_event_wait_until_callback, length = 1)]- wait_until: (),-}--#[derive(WebApiFunctionTemplate)]-#[webapi(- interface = web_api_interfaces::ExtendableMessageEvent,- constructor_callback = extendable_message_event_constructor_callback,- constructor_length = 1-)]-struct ExtendableMessageEventTemplateDeclaration {}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerGlobalScopeConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "WorkerGlobalScope")]- constructor: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct DedicatedWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "DedicatedWorkerGlobalScope")]- constructor: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct SharedWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "SharedWorkerGlobalScope")]- constructor: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct ServiceWorkerGlobalScopeConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "ServiceWorkerGlobalScope")]- constructor: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct ExtendableEventConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "ExtendableEvent")]- extendable_event: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct ExtendableMessageEventConstructorGlobalDeclaration<'scope> {- #[webapi(data_property = "ExtendableMessageEvent")]- extendable_message_event: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerScopePrototypeConstructorDeclaration<'scope> {- #[webapi(data_property = "constructor")]- constructor: v8::Local<'scope, v8::Function>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerPrototypeTagDeclaration {- #[webapi(to_string_tag, readonly)]- tag: &'static str,-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::ServiceWorkerRegistration,)]-struct ServiceWorkerGlobalRegistrationDeclaration<'scope> {- #[webapi(data_property, readonly)]- scope: String,-- #[webapi(- accessor_property = "installing",- getter = service_worker_registration_installing_getter- )]- installing: (),-- #[webapi(- accessor_property = "waiting",- getter = service_worker_registration_waiting_getter- )]- waiting: (),-- #[webapi(- accessor_property = "active",- getter = service_worker_registration_active_getter- )]- active: (),-- #[webapi(method, callback = service_worker_registration_unregister_callback, length = 0)]- unregister: (),-- #[webapi(- method = "showNotification",- callback = service_worker_registration_show_notification_callback,- length = 1- )]- show_notification: (),-- #[webapi(- method = "getNotifications",- callback = service_worker_registration_get_notifications_callback,- length = 0- )]- get_notifications: (),-- #[webapi(data_property, readonly)]- sync: v8::Local<'scope, v8::Object>,-- #[webapi(data_property = "periodicSync", readonly)]- periodic_sync: v8::Local<'scope, v8::Object>,-- #[webapi(data_property = "pushManager", readonly)]- push_manager: v8::Local<'scope, v8::Object>,-- #[webapi(data_property = "navigationPreload", readonly)]- navigation_preload: v8::Local<'scope, v8::Object>,-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::ServiceWorker,)]-struct ServiceWorkerGlobalServiceWorkerDeclaration {- #[webapi(data_property = "scriptURL", readonly)]- script_url: String,-- #[webapi(data_property, readonly)]- state: String,-- #[webapi(method = "postMessage", callback = service_worker_worker_post_message_callback, length = 1)]- post_message: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::SyncManager)]-struct ServiceWorkerGlobalSyncManagerDeclaration {- #[webapi(- method = "register",- callback = service_worker_sync_manager_register_callback,- length = 1- )]- register: (),-- #[webapi(- method = "getTags",- callback = service_worker_sync_manager_get_tags_callback,- length = 0- )]- get_tags: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::PeriodicSyncManager)]-struct ServiceWorkerGlobalPeriodicSyncManagerDeclaration {- #[webapi(- method = "register",- callback = service_worker_periodic_sync_manager_register_callback,- length = 1- )]- register: (),-- #[webapi(- method = "getTags",- callback = service_worker_periodic_sync_manager_get_tags_callback,- length = 0- )]- get_tags: (),-- #[webapi(- method = "unregister",- callback = service_worker_periodic_sync_manager_unregister_callback,- length = 1- )]- unregister: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::PushManager)]-struct ServiceWorkerGlobalPushManagerDeclaration {- #[webapi(- method = "subscribe",- callback = service_worker_push_manager_subscribe_callback,- length = 0- )]- subscribe: (),-- #[webapi(- method = "getSubscription",- callback = service_worker_push_manager_get_subscription_callback,- length = 0- )]- get_subscription: (),-- #[webapi(- method = "permissionState",- callback = service_worker_push_manager_permission_state_callback,- length = 0- )]- permission_state: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::NavigationPreloadManager)]-struct ServiceWorkerGlobalNavigationPreloadManagerDeclaration {- #[webapi(- method,- callback = service_worker_navigation_preload_manager_enable_callback,- length = 0- )]- enable: (),-- #[webapi(- method,- callback = service_worker_navigation_preload_manager_disable_callback,- length = 0- )]- disable: (),-- #[webapi(- method = "setHeaderValue",- callback = service_worker_navigation_preload_manager_set_header_value_callback,- length = 1- )]- set_header_value: (),-- #[webapi(- method = "getState",- callback = service_worker_navigation_preload_manager_get_state_callback,- length = 0- )]- get_state: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::PushSubscription)]-struct ServiceWorkerPushSubscriptionDeclaration<'scope> {- #[webapi(data_property, readonly)]- endpoint: String,-- #[webapi(data_property = "expirationTime", readonly)]- expiration_time: v8::Local<'scope, v8::Value>,-- #[webapi(data_property, readonly)]- options: v8::Local<'scope, v8::Object>,-- #[webapi(method, callback = service_worker_push_subscription_unsubscribe_callback, length = 0)]- unsubscribe: (),-- #[webapi(- method = "toJSON",- callback = service_worker_push_subscription_to_json_callback,- length = 0- )]- to_json: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::PushSubscriptionOptions, prototype = "Object")]-struct ServiceWorkerPushSubscriptionOptionsDeclaration<'scope> {- #[webapi(data_property = "userVisibleOnly", readonly)]- user_visible_only: bool,-- #[webapi(data_property = "applicationServerKey", readonly)]- application_server_key: v8::Local<'scope, v8::Value>,-}--#[derive(WebApiObject)]-#[webapi(plain)]-struct WorkerNavigationPreloadStateDeclaration {- #[webapi(data_property, enumerable)]- enabled: bool,-- #[webapi(data_property = "headerValue", enumerable)]- header_value: String,-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::ExtendableEvent, prototype = "Object")]-struct ExtendableEventStateDeclaration {- #[webapi(data_property, enumerable)]- composed: bool,-}--#[derive(WebApiObject)]-#[webapi(- interface = web_api_interfaces::ExtendableMessageEvent,- prototype = "Object"-)]-struct ExtendableMessageEventStateDeclaration<'scope> {- #[webapi(data_property, enumerable)]- data: v8::Local<'scope, v8::Value>,-- #[webapi(data_property, enumerable)]- origin: String,-- #[webapi(data_property = "lastEventId", enumerable)]- last_event_id: String,-- #[webapi(data_property, enumerable)]- source: v8::Local<'scope, v8::Value>,-- #[webapi(data_property, enumerable)]- ports: v8::Local<'scope, v8::Array>,-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::Client)]-pub(super) struct ServiceWorkerBaseClientDeclaration<'scope> {- #[webapi(data_property, readonly)]- id: String,-- #[webapi(data_property, readonly)]- url: v8::Local<'scope, v8::String>,-- #[webapi(data_property = "type", readonly)]- client_type: &'static str,-- #[webapi(method = "postMessage", callback = service_worker_client_post_message_callback, length = 1)]- post_message: (),-}--#[derive(WebApiObject)]-#[webapi(interface = web_api_interfaces::WindowClient)]-pub(super) struct ServiceWorkerWindowClientDeclaration<'scope> {- #[webapi(data_property, readonly)]- id: String,-- #[webapi(data_property, readonly)]- url: v8::Local<'scope, v8::String>,-- #[webapi(data_property = "type", readonly)]- client_type: &'static str,-- #[webapi(data_property = "frameType", readonly)]- frame_type: &'static str,-- #[webapi(data_property = "lifecycleState", readonly)]- lifecycle_state: &'static str,-- #[webapi(data_property = "visibilityState", readonly)]- visibility_state: &'static str,-- #[webapi(data_property, readonly)]- focused: bool,-- #[webapi(method = "postMessage", callback = service_worker_client_post_message_callback, length = 1)]- post_message: (),-- #[webapi(method, callback = service_worker_window_client_focus_callback, length = 0)]- focus: (),-- #[webapi(method, callback = service_worker_window_client_navigate_callback, length = 1)]- navigate: (),-}--pub(super) struct PendingServiceWorkerClientQuery {- pub(super) resolver: v8::Global<v8::PromiseResolver>,- pub(super) query_type: PendingServiceWorkerClientQueryType,-}--pub(super) struct PendingServiceWorkerClientNavigate {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerClientFocus {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerClientsOpenWindow {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerShowNotification {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerGetNotifications {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerSyncRegistration {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerSyncGetTags {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerPeriodicSyncRegistration {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerPeriodicSyncGetTags {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerPeriodicSyncUnregistration {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerPushSubscribe {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--#[derive(Default, webidl::WebIdlDictionary)]-#[webidl(prefix = "BackgroundSyncOptions")]-struct BackgroundSyncOptions {- #[webidl(- name = "minInterval",- converter = "enforce_range_unsigned_long_long",- default = 0- )]- min_interval: u64,-}--pub(super) struct PendingServiceWorkerPushGetSubscription {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--pub(super) struct PendingServiceWorkerPushUnsubscribe {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--#[derive(Clone, Copy, Debug, Eq, PartialEq)]-pub(super) enum PendingServiceWorkerClientQueryType {- Get,- MatchAll,-}--/// A WebCrypto primitive dispatched off the worker event loop to the blocking-/// pool. The worker owns the resolver and matches the completion back by the-/// task id allocated for this worker lifetime.-pub(super) struct PendingWorkerWebCryptoTask {- pub(super) resolver: v8::Global<v8::PromiseResolver>,-}--/// Completion of a worker WebCrypto blocking task, routed back onto the worker-/// event loop. The worker sink captures these ids at registration just as the-/// page-side typed producer captures its exact Page/Window owner.-pub(crate) struct WorkerWebCryptoCompletion {- pub(crate) task_id: u64,- pub(crate) result: Result<WebCryptoTaskResult, WebCryptoRejection>,-}--pub(super) struct PendingWorkerOpfsTask {- pub(super) locator: moli_storage_service::StorageBucketLocator,- pub(super) handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,- pub(super) settlement: crate::opfs_owner_tasks::OpfsTaskSettlement,-}--pub(super) struct WorkerOpfsOwnerState {- next_task_id: u64,- pending_tasks: HashMap<u64, PendingWorkerOpfsTask>,- handles: crate::opfs_owner_tasks::OpfsHandleRegistry,- directory_iterators: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry,-}--impl Default for WorkerOpfsOwnerState {- fn default() -> Self {- Self {- next_task_id: 1,- pending_tasks: HashMap::new(),- handles: crate::opfs_owner_tasks::OpfsHandleRegistry::default(),- directory_iterators: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry::default(),- }- }-}--impl WorkerOpfsOwnerState {- pub(super) fn has_pending_tasks(&self) -> bool {- !self.pending_tasks.is_empty()- }-}--pub(crate) struct WorkerOpfsCompletion {- pub(crate) task_id: u64,- pub(crate) result: OpfsTaskResult,-}--pub(super) struct PendingWorkerFetch {- pub(super) resolver: v8::Global<v8::PromiseResolver>,- pub(super) document_url: Url,- pub(super) credentials_mode: RequestCredentialsMode,- pub(super) request_mode: moli_fetch::RequestMode,- pub(super) redirect_mode: RequestRedirectMode,- pub(super) request_priority: Option<moli_fetch::FetchPriorityHint>,- pub(super) request_metadata: crate::service_worker_runtime::ServiceWorkerFetchRequestMetadata,- pub(super) policy_context: crate::types::SubresourcePolicyContext,- pub(super) signal_id: Option<u32>,- pub(super) load: ResourceLoadLease,- pub(super) request_url: Url,- pub(super) request_method: String,- pub(super) request_headers: moli_fetch::RequestHeaders,- pub(super) request_body: Option<String>,- pub(super) network_request_handle: Option<SubresourceNetworkRequestHandle>,- pub(super) network_record: Option<PendingWorkerFetchNetworkRecord>,- pub(super) paused_response: Option<PausedWorkerSubresourceResponse>,- pub(super) streaming_body_source_id: Option<NetworkBodySourceId>,-}--pub(super) enum WorkerFetchEvent {- Completion(Box<WorkerFetchCompletion>),- StreamingStarted(WorkerFetchStreamingStarted),- StreamingChunk(WorkerFetchStreamingChunk),- StreamingFinished(WorkerFetchStreamingFinished),-}--pub(super) struct WorkerFetchCompletion {- fetch_id: u32,- network_request_headers: Option<Vec<(String, String)>>,- result: Result<WorkerFetchResponse, String>,-}--pub(super) struct WorkerFetchStreamingStarted {- fetch_id: u32,- body_source_id: NetworkBodySourceId,- head: ResponseHead,- network_request_headers: Option<Vec<(String, String)>>,-}--pub(super) struct WorkerFetchStreamingChunk {- body_source_id: NetworkBodySourceId,- bytes: Vec<u8>,-}--pub(super) struct WorkerFetchStreamingFinished {- fetch_id: u32,- body_source_id: NetworkBodySourceId,- head: ResponseHead,- result: Result<SubresourceResponseBody, String>,-}--pub(super) enum WorkerFetchResponse {- Materialized(Box<Response>),- Streamed {- head: Box<ResponseHead>,- body: SubresourceResponseBody,- },-}--impl WorkerFetchResponse {- fn head(&self) -> ResponseHead {- match self {- Self::Materialized(response) => response.head(),- Self::Streamed { head, .. } => head.as_ref().clone(),- }- }-- fn subresource_response_body(&self) -> SubresourceResponseBody {- match self {- Self::Materialized(response) => SubresourceResponseBody::from_fetch_response(response),- Self::Streamed { body, .. } => body.clone(),- }- }-- fn into_fetch_parts(self) -> WorkerFetchResponseParts {- match self {- Self::Materialized(response) => {- let (head, body) = response.into_body();- WorkerFetchResponseParts::Materialized {- head,- body: Box::new(body),- }- }- Self::Streamed { head, body } => {- WorkerFetchResponseParts::Subresource { head: *head, body }- }- }- }-}--enum WorkerFetchResponseParts {- Materialized {- head: ResponseHead,- body: Box<ResponseBody>,- },- Subresource {- head: ResponseHead,- body: SubresourceResponseBody,- },-}--#[derive(Clone)]-pub(super) struct PendingWorkerFetchNetworkRecord {- pub(crate) redirect_headers: Option<moli_fetch::RequestHeaders>,- pub(super) internal_id: u64,- pub(super) url: Url,- pub(super) method: String,- pub(super) request_headers: moli_fetch::RequestHeaders,- pub(super) request_body: Option<String>,- pub(super) initial_network_request_headers: Option<Vec<(String, String)>>,- pub(super) intercept_response: bool,- pub(super) handle_auth_requests: bool,-}--impl PendingWorkerFetchNetworkRecord {- fn follow_redirects(&mut self, head: &ResponseHead) {- if head.redirect_chain.is_empty() {- return;- }- let mut request = Request::get_with_url(self.url.clone())- .with_redirect_headers(self.redirect_headers.take());- request.method = std::mem::take(&mut self.method);- request.body = self.request_body.clone().map(String::into_bytes);- request.request_headers = std::mem::take(&mut self.request_headers);- for redirect in &head.redirect_chain {- request.apply_redirect_status(redirect.status);- }- self.url = head.final_url.clone();- self.method = request.method;- self.request_headers = request.request_headers;- if request.body.is_none() {- self.request_body = None;- }- }-}--pub(super) struct PendingWorkerXhr {- pub(super) xhr: v8::Global<v8::Object>,- pub(super) document_url: Url,- pub(super) credentials_mode: RequestCredentialsMode,- pub(super) load: ResourceLoadLease,- pub(super) request_paused: bool,- pub(super) request_url: Url,- pub(super) request_method: String,- pub(super) request_headers: moli_fetch::RequestHeaders,- pub(super) request_body: Option<String>,- pub(super) network_request_handle: Option<SubresourceNetworkRequestHandle>,- pub(super) network_record: Option<PendingWorkerFetchNetworkRecord>,- pub(super) paused_response: Option<PausedWorkerSubresourceResponse>,-}--pub(super) struct PendingWorkerCspReport {- pub(super) load: ResourceLoadLease,- pub(super) document_url: Url,- pub(super) request: Request,- pub(super) request_body: Option<String>,- pub(super) policy_context: crate::types::SubresourcePolicyContext,- pub(super) service_worker_runtime:- Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,- pub(super) service_worker_client_id:- Option<crate::service_worker_runtime::ServiceWorkerClientId>,-}--pub(super) struct PausedWorkerSubresourceResponse {- pub(super) head: ResponseHead,- pub(super) body: SubresourceResponseBody,-}--pub(super) struct WorkerXhrCompletion {- pub(super) xhr_id: u32,- pub(super) network_request_headers: Option<Vec<(String, String)>>,- pub(super) result: Result<WorkerXhrResponse, String>,-}--pub(super) enum WorkerXhrResponse {- Materialized(Box<Response>),- Streamed {- head: Box<ResponseHead>,- body: SubresourceResponseBody,- },-}--impl WorkerXhrResponse {- fn head(&self) -> ResponseHead {- match self {- Self::Materialized(response) => response.head(),- Self::Streamed { head, .. } => head.as_ref().clone(),- }- }-- fn subresource_response_body(&self) -> SubresourceResponseBody {- match self {- Self::Materialized(response) => SubresourceResponseBody::from_fetch_response(response),- Self::Streamed { body, .. } => body.clone(),- }- }-- fn into_body_source(self) -> Result<(ResponseHead, ResponseBody), String> {- match self {- Self::Materialized(response) => Ok(response.into_body()),- Self::Streamed { head, body } => body- .materialize_bytes()- .map(|bytes| (*head, ResponseBody::materialized_bytes(bytes)))- .map_err(|error| format!("failed to materialize worker XHR body: {error}")),- }- }-}--pub(super) struct WorkerWebSocketState {- pub(super) wrapper: v8::Global<v8::Object>,- pub(super) connection: WebSocketConnectionHandle,- pub(super) document_url: Url,- pub(super) url: Url,- pub(super) loader: crate::network::context::WorkerResourceLoader,- pub(super) load: Option<ResourceLoadLease>,- pub(super) opened: bool,- pub(super) network_recorded: bool,-}--pub(super) struct PendingServiceWorkerLifecycleEvent {- pub(super) completion: ServiceWorkerLifecycleCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,-}--pub(super) struct PendingServiceWorkerMessageEvent {- pub(super) completion: ServiceWorkerMessageCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,- pub(super) window_interaction_allowed: bool,-}--pub(super) struct PendingServiceWorkerNotificationEvent {- pub(super) completion: crate::runtime::ServiceWorkerNotificationCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,- pub(super) window_interaction_allowed: bool,-}--pub(super) struct PendingServiceWorkerPushEvent {- pub(super) completion: crate::runtime::ServiceWorkerPushCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,-}--pub(super) struct PendingServiceWorkerSyncEvent {- pub(super) completion: crate::runtime::ServiceWorkerSyncCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,-}--pub(super) struct PendingServiceWorkerPeriodicSyncEvent {- pub(super) completion: crate::runtime::ServiceWorkerPeriodicSyncCompletion,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,-}--pub(super) struct PendingServiceWorkerFetchEvent {- pub(super) completion: ServiceWorkerFetchCompletion,- pub(super) handled_resolver: Option<v8::Global<v8::PromiseResolver>>,- pub(super) request_signal_id: Option<u32>,- pub(super) request_mode: RequestMode,- pub(super) request_destination: ServiceWorkerRequestDestination,- pub(super) pending_respond_with_response: Option<crate::network_host::MaterializedResponseHead>,- pub(super) pending_respond_with_stream_body_source_id: Option<NetworkBodySourceId>,- pub(super) pending_respond_with_stream_cancel_handle: Option<v8::Global<v8::Object>>,- pub(super) respond_with_called: bool,- pub(super) pending_respond_with: bool,- pub(super) pending_wait_until_count: usize,- pub(super) dispatch_finished: bool,-}--impl PendingServiceWorkerFetchEvent {- pub(super) fn fallback(- completion: ServiceWorkerFetchCompletion,- request_mode: RequestMode,- request_destination: ServiceWorkerRequestDestination,- ) -> Self {- Self {- completion: ServiceWorkerFetchCompletion {- result: ServiceWorkerFetchResult::Fallback,- ..completion- },- handled_resolver: None,- request_signal_id: None,- request_mode,- request_destination,- pending_respond_with_response: None,- pending_respond_with_stream_body_source_id: None,- pending_respond_with_stream_cancel_handle: None,- respond_with_called: false,- pending_respond_with: false,- pending_wait_until_count: 0,- dispatch_finished: false,- }- }-}--pub(super) struct PendingServiceWorkerNavigationPreload {- pub(super) owner: crate::service_worker_runtime::ServiceWorkerRunOwner,- pub(super) _promise: v8::Global<v8::Promise>,- pub(super) resolver: Option<v8::Global<v8::PromiseResolver>>,- pub(super) body_source_id: Option<NetworkBodySourceId>,-}--enum WorkerImportScriptError {- DomException { name: &'static str, message: String },- Exception(v8::Global<v8::Value>),-}--impl WorkerImportScriptError {- fn syntax(message: impl Into<String>) -> Self {- Self::DomException {- name: "SyntaxError",- message: message.into(),- }- }-- fn network(message: impl Into<String>) -> Self {- Self::DomException {- name: "NetworkError",- message: message.into(),- }- }-- fn error<'s>(scope: &mut v8::PinScope<'s, '_>, message: impl Into<String>) -> Self {- let message = message.into();- let value = v8_string(scope, &message)- .map(|value| v8::Exception::error(scope, value))- .unwrap_or_else(|| v8::Exception::error(scope, v8::String::empty(scope)));- Self::Exception(v8::Global::new(scope, value))- }-- fn throw(self, scope: &mut v8::PinScope<'_, '_>) {- match self {- Self::DomException { name, message } => {- let exception = worker_dom_exception_value(scope, &message, name);- scope.throw_exception(exception);- }- Self::Exception(value) => {- let value = v8::Local::new(scope, value);- scope.throw_exception(value);- }- }- }-}--struct PreparedWorkerImportScript {- final_url: Url,- source: Option<String>,- muted_errors: bool,-}--fn annotate_worker_exception_location<'s>(- scope: &mut v8::PinScope<'s, '_>,- exception: v8::Local<'s, v8::Value>,- message: Option<v8::Local<'s, v8::Message>>,-) {- let Ok(object) = v8::Local::<v8::Object>::try_from(exception) else {- return;- };- let source = message- .and_then(|message| message.get_script_resource_name(scope))- .and_then(|value| value.to_string(scope))- .map(|value| value.to_rust_string_lossy(scope))- .filter(|value| !value.is_empty());- if let Some(source) = source- && let Some(value) = v8_string(scope, &source)- {- set_worker_exception_location_if_missing(- scope,- object,- WORKER_EXCEPTION_SOURCE_SLOT,- value.into(),- );- }- if let Some(line) = message.and_then(|message| message.get_line_number(scope)) {- let value = v8::Number::new(scope, line as f64);- set_worker_exception_location_if_missing(- scope,- object,- WORKER_EXCEPTION_LINE_SLOT,- value.into(),- );- }- if let Some(column) = message.and_then(|message| message.get_start_column().checked_add(1)) {- let value = v8::Number::new(scope, column as f64);- set_worker_exception_location_if_missing(- scope,- object,- WORKER_EXCEPTION_COLUMN_SLOT,- value.into(),- );- }-}--fn set_worker_exception_location_if_missing<'s>(- scope: &mut v8::PinScope<'s, '_>,- object: v8::Local<'s, v8::Object>,- slot: &str,- value: v8::Local<'s, v8::Value>,-) {- if get_private_value(scope, object, slot).is_none() {- set_private_value(scope, object, slot, value);- }-}--/// Mutable state accessible from V8 callbacks inside the worker isolate.-pub(super) struct WorkerMessagePortWrapperEntry {- wrapper: v8::Global<v8::Object>,-}--pub(crate) struct WorkerGlobalState {- /// Weak handles and native cleanups owned by this worker isolate. Worker- /// teardown clears this registry before `OwnedIsolate` is destroyed.- pub(crate) v8_finalizers: crate::v8_finalizer::V8FinalizerRegistry,- /// Channel to send messages back to the parent.- pub(super) parent_tx: mpsc::UnboundedSender<WorkerToParentMessage>,- /// Internal wake channel used by worker-owned async runtime surfaces.- pub(crate) worker_wake_tx: mpsc::UnboundedSender<super::handle::WorkerMessage>,- /// Shared lifecycle bit published by `Worker.terminate()` before V8 is- /// interrupted. Worker-side task delivery must not rely on cross-thread- /// timing between that interrupt and already-selected work.- pub(crate) termination_requested: Arc<AtomicBool>,- /// Whether `close()` has been called.- pub(super) closed: bool,- /// HTML's per-global guard against recursively reporting an error event.- pub(super) in_error_reporting_mode: bool,- /// Timer id counter.- pub(super) next_timer_id: u32,- /// Inside-settings resource authority for every request owned by this- /// WorkerGlobalScope. Even data/blob workers retain the creator's browser- /// backend so later fetch/XHR/module/WebSocket work has an exact owner.- pub(super) loader: crate::network::context::WorkerResourceLoader,- /// Whether this runtime is a dedicated or shared worker global.- pub(super) global_kind: super::thread::WorkerGlobalKind,- /// Whether this worker was constructed as a classic or module worker.- pub(super) script_kind: super::thread::WorkerScriptKind,- /// Base URL used to resolve relative worker script fetches.- pub(super) current_script_url: Option<Url>,- /// Referrer policy parsed from the top-level worker script response.- pub(super) referrer_policy: Option<String>,- /// CSP policies from outside settings used for module static imports.- pub(super) module_static_import_content_security_policies: Vec<String>,- /// Enforce CSP policies parsed from the top-level worker script response.- pub(super) content_security_policies: Vec<String>,- /// Report-only CSP policies parsed from the top-level worker script response.- pub(super) content_security_report_only_policies: Vec<String>,- /// Reporting API endpoints parsed from the top-level worker script response.- pub(super) content_security_reporting_endpoints: ContentSecurityPolicyReportingEndpoints,- /// Whether this worker global is a secure context for `[SecureContext]` APIs.- pub(super) secure_context: bool,- /// Network.setExtraHTTPHeaders headers inherited from the owning page/CDP session.- pub(super) extra_http_headers: moli_fetch::RequestHeaders,- /// Permission overrides inherited from the owning page/CDP session.- pub(super) permission_overrides: Vec<crate::protocol_types::PermissionOverrideRegistration>,- /// Network.emulateNetworkConditions offline state inherited from the owning page/CDP session.- pub(super) network_offline: bool,- /// Network.setBlockedURLs patterns inherited from the owning page/CDP session.- pub(super) blocked_url_patterns: Vec<String>,- /// Current document network/cache partition key inherited by worker-owned requests.- pub(super) network_partition_key: Option<String>,- /// COEP/DIP policy container state inherited by worker-owned subresource requests.- pub(super) policy_context: crate::types::SubresourcePolicyContext,- /// Fetch domain subresource interception inherited from the owning page/CDP session.- pub(super) fetch_subresource_interception_enabled: bool,- pub(super) fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,- /// Async fetch completions routed back onto the worker event loop.- pub(super) fetch_completion_tx: mpsc::UnboundedSender<WorkerFetchEvent>,- /// Promise resolvers pending async fetch completion.- pub(super) pending_fetches: HashMap<u32, PendingWorkerFetch>,- /// Worker-local pending body sources for headers-first worker fetch.- pub(crate) pending_network_body_sources:- HashMap<NetworkBodySourceId, crate::network_host::PendingNetworkBodySourceState>,- pub(crate) pending_network_body_clones: HashMap<NetworkBodySourceId, Vec<NetworkBodySourceId>>,- /// Fetch id counter.- pub(super) next_fetch_id: u32,- /// Async XHR completions routed back onto the worker event loop.- pub(super) xhr_completion_tx: mpsc::UnboundedSender<WorkerXhrCompletion>,- /// In-flight worker XHR requests keyed by internal id.- pub(super) pending_xhrs: HashMap<u32, PendingWorkerXhr>,- /// Worker XHR id counter.- pub(super) next_xhr_id: u32,- /// Worker-owned CSP report requests paused for Fetch domain request-stage interception.- pub(super) pending_csp_reports: HashMap<u32, PendingWorkerCspReport>,- /// Worker-local TextDecoder state. TextEncoder is stateless, but TextDecoder- /// can stream and needs decoder state tied to this worker's isolate.- pub(crate) text_codecs: TextCodecStore,- /// Worker-local AbortController/AbortSignal runtime state.- pub(super) abort: Rc<RefCell<WorkerAbortStore>>,- /// Worker-thread view of the creator's browser-context/partition runtime.- pub(super) worker_context_runtime: crate::runtime::RendererWorkerContextRuntime,- /// Browser-context Service Worker owner inherited by real worker clients.- pub(super) service_worker_runtime:- Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,- /// Live Service Worker client id for DedicatedWorker/SharedWorker globals.- pub(super) service_worker_client_id:- Option<crate::service_worker_runtime::ServiceWorkerClientId>,- /// Owner-scoped MessagePort state shared with page and nested worker contexts.- pub(super) message_port_registry: SharedMessagePortRegistry,- /// Worker-owned MessagePort wrappers keyed by runtime port id.- pub(super) message_port_wrappers: HashMap<MessagePortId, WorkerMessagePortWrapperEntry>,- /// SharedWorker connect-event ports whose lifetime is owned by the shared worker runtime.- pub(super) shared_worker_connection_ports: HashSet<MessagePortId>,- /// Worker-owned BroadcastChannel wrappers keyed by runtime channel id.- pub(super) broadcast_channel_registry: SharedBroadcastChannelRegistry,- pub(super) broadcast_channel_storage_key: MoliStorageKey,- pub(super) storage_key: MoliStorageKey,- pub(super) broadcast_channel_wrappers: HashMap<BroadcastChannelId, v8::Global<v8::Object>>,- /// IndexedDB storage manager inherited from the owning browser context.- pub(super) indexed_db_manager: Option<crate::context_bootstrap::WeakIndexedDbManager>,- /// Storage Buckets registry inherited from the owning browser context.- pub(super) storage_bucket_store: Option<crate::context_bootstrap::SharedStorageBucketStore>,- /// Async WebSocket transport events routed back onto this worker loop.- pub(super) websocket_event_tx: tokio::sync::mpsc::Sender<WebSocketEvent>,- /// Worker-owned classic WebSocket connections keyed by socket id.- pub(super) websockets: HashMap<u64, WorkerWebSocketState>,- /// Worker-local WebSocket id counter.- pub(super) next_websocket_id: u64,- /// Worker-local dedicated workers created through `new Worker(...)`.- pub(super) next_nested_worker_id: u64,- pub(super) nested_worker_wrappers: HashMap<DedicatedWorkerId, v8::Global<v8::Object>>,- /// Heavyweight WebCrypto completions routed back onto the worker event loop.- pub(super) webcrypto_completion_tx: mpsc::UnboundedSender<WorkerWebCryptoCompletion>,- /// In-flight worker WebCrypto blocking tasks keyed by task id.- pub(super) pending_webcrypto: HashMap<u64, PendingWorkerWebCryptoTask>,- /// Worker WebCrypto task id counter (never zero so 0 can mean "unset").- pub(super) next_webcrypto_task_id: u64,- /// OPFS completions routed from the partition-owned storage IO sequence.- pub(super) opfs_completion_tx: mpsc::UnboundedSender<WorkerOpfsCompletion>,- pub(super) opfs_owner_state: Option<WorkerOpfsOwnerState>,- /// In-flight Service Worker `periodicsync` events keyed by runtime event id.- pub(super) pending_service_worker_periodic_sync_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerPeriodicSyncEvent>,- /// In-flight Service Worker `clients.get()` / `clients.matchAll()` queries keyed by request id.- pub(super) pending_service_worker_client_queries: HashMap<u64, PendingServiceWorkerClientQuery>,- /// In-flight Service Worker `WindowClient.navigate()` requests keyed by request id.- pub(super) pending_service_worker_client_navigates:- HashMap<u64, PendingServiceWorkerClientNavigate>,- /// In-flight Service Worker `WindowClient.focus()` requests keyed by request id.- pub(super) pending_service_worker_client_focuses: HashMap<u64, PendingServiceWorkerClientFocus>,- /// In-flight Service Worker `clients.openWindow()` requests keyed by request id.- pub(super) pending_service_worker_clients_open_windows:- HashMap<u64, PendingServiceWorkerClientsOpenWindow>,- /// In-flight Service Worker `registration.showNotification()` requests keyed by request id.- pub(super) pending_service_worker_show_notifications:- HashMap<u64, PendingServiceWorkerShowNotification>,- /// In-flight Service Worker `registration.getNotifications()` requests keyed by request id.- pub(super) pending_service_worker_get_notifications:- HashMap<u64, PendingServiceWorkerGetNotifications>,- /// In-flight Service Worker `registration.sync.register()` requests keyed by request id.- pub(super) pending_service_worker_sync_registrations:- HashMap<u64, PendingServiceWorkerSyncRegistration>,- /// In-flight Service Worker `registration.sync.getTags()` requests keyed by request id.- pub(super) pending_service_worker_sync_get_tags: HashMap<u64, PendingServiceWorkerSyncGetTags>,- /// In-flight Service Worker `registration.periodicSync.register()` requests keyed by request id.- pub(super) pending_service_worker_periodic_sync_registrations:- HashMap<u64, PendingServiceWorkerPeriodicSyncRegistration>,- /// In-flight Service Worker `registration.periodicSync.getTags()` requests keyed by request id.- pub(super) pending_service_worker_periodic_sync_get_tags:- HashMap<u64, PendingServiceWorkerPeriodicSyncGetTags>,- /// In-flight Service Worker `registration.periodicSync.unregister()` requests keyed by request id.- pub(super) pending_service_worker_periodic_sync_unregistrations:- HashMap<u64, PendingServiceWorkerPeriodicSyncUnregistration>,- /// In-flight Service Worker `registration.pushManager.subscribe()` requests keyed by request id.- pub(super) pending_service_worker_push_subscriptions:- HashMap<u64, PendingServiceWorkerPushSubscribe>,- /// In-flight Service Worker `registration.pushManager.getSubscription()` requests keyed by request id.- pub(super) pending_service_worker_push_get_subscriptions:- HashMap<u64, PendingServiceWorkerPushGetSubscription>,- /// In-flight Service Worker `PushSubscription.unsubscribe()` requests keyed by request id.- pub(super) pending_service_worker_push_unsubscriptions:- HashMap<u64, PendingServiceWorkerPushUnsubscribe>,- pub(super) service_worker_client_query_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_client_navigate_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_client_focus_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_clients_open_window_request_ids:- WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_show_notification_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_get_notifications_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_sync_registration_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_sync_get_tags_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_periodic_sync_registration_request_ids:- WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_periodic_sync_get_tags_request_ids:- WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_periodic_sync_unregistration_request_ids:- WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_push_subscription_request_ids: WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_push_get_subscription_request_ids:- WorkerServiceWorkerRequestIdAllocator,- pub(super) service_worker_push_unsubscription_request_ids:- WorkerServiceWorkerRequestIdAllocator,- /// Count of active Service Worker events that allow window interaction.- pub(super) service_worker_window_interaction_allowed_count: usize,- /// Service Worker lifecycle events currently waiting for dispatch and- /// `ExtendableEvent.waitUntil()` promises to finish.- pub(super) pending_service_worker_lifecycle_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerLifecycleEvent>,- /// Service Worker fetch events currently waiting for dispatch, `respondWith()`,- /// and minimal `waitUntil()` promises to finish.- pub(super) pending_service_worker_fetch_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerFetchEvent>,- /// Navigation preload promises and response bodies stay alive until preload complete/error.- pub(super) pending_service_worker_navigation_preloads:- HashMap<ServiceWorkerEventId, PendingServiceWorkerNavigationPreload>,- /// Service Worker message events currently waiting for dispatch and- /// `ExtendableEvent.waitUntil()` promises to finish.- pub(super) pending_service_worker_message_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerMessageEvent>,- /// Service Worker notification events currently waiting for dispatch and- /// `ExtendableEvent.waitUntil()` promises to finish.- pub(super) pending_service_worker_notification_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerNotificationEvent>,- /// Service Worker push events currently waiting for dispatch and- /// `ExtendableEvent.waitUntil()` promises to finish.- pub(super) pending_service_worker_push_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerPushEvent>,- /// Service Worker sync events currently waiting for dispatch and- /// `ExtendableEvent.waitUntil()` promises to finish.- pub(super) pending_service_worker_sync_events:- HashMap<ServiceWorkerEventId, PendingServiceWorkerSyncEvent>,-}--/// Checked allocator for one operation-local Service Worker request namespace.-///-/// The parent/worker protocol intentionally gives each operation its own-/// namespace. Keeping that shape avoids coupling unrelated APIs while making-/// exhaustion fail instead of overwriting a live pending resolver.-#[derive(Debug)]-pub(super) struct WorkerServiceWorkerRequestIdAllocator {- next: u64,-}--impl Default for WorkerServiceWorkerRequestIdAllocator {- fn default() -> Self {- Self { next: 1 }- }-}--impl WorkerServiceWorkerRequestIdAllocator {- fn allocate(&mut self) -> u64 {- let request_id = self.next;- self.next = request_id- .checked_add(1)- .expect("worker Service Worker request id space exhausted");- request_id- }-}--#[cfg(test)]-mod service_worker_request_id_allocator_tests {- use super::WorkerServiceWorkerRequestIdAllocator;-- #[test]- #[should_panic(expected = "worker Service Worker request id space exhausted")]- fn operation_local_request_ids_never_wrap() {- let mut ids = WorkerServiceWorkerRequestIdAllocator { next: u64::MAX };- let _ = ids.allocate();- }-}--impl WorkerGlobalState {- /// Register a pending worker WebCrypto task and return the routing tuple the- /// blocking task needs to report completion. Runs synchronously inside the- /// V8 callback before control returns to the worker event loop.- pub(super) fn register_pending_webcrypto_task(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> (u64, mpsc::UnboundedSender<WorkerWebCryptoCompletion>) {- let task_id = self.next_webcrypto_task_id;- self.next_webcrypto_task_id = task_id- .checked_add(1)- .expect("worker WebCrypto task id exhausted");- self.pending_webcrypto- .insert(task_id, PendingWorkerWebCryptoTask { resolver });- (task_id, self.webcrypto_completion_tx.clone())- }-- pub(super) fn take_pending_webcrypto_task(- &mut self,- task_id: u64,- ) -> Option<PendingWorkerWebCryptoTask> {- self.pending_webcrypto.remove(&task_id)- }-- pub(super) fn register_pending_opfs_task(- &mut self,- locator: moli_storage_service::StorageBucketLocator,- handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,- settlement: crate::opfs_owner_tasks::OpfsTaskSettlement,- ) -> (u64, mpsc::UnboundedSender<WorkerOpfsCompletion>) {- let state = self- .opfs_owner_state- .get_or_insert_with(WorkerOpfsOwnerState::default);- let task_id = state.next_task_id;- state.next_task_id = task_id- .checked_add(1)- .expect("worker OPFS task id exhausted");- state.pending_tasks.insert(- task_id,- PendingWorkerOpfsTask {- locator,- handle_access,- settlement,- },- );- (task_id, self.opfs_completion_tx.clone())- }-- pub(super) fn take_pending_opfs_task(&mut self, task_id: u64) -> Option<PendingWorkerOpfsTask> {- self.opfs_owner_state- .as_mut()?- .pending_tasks- .remove(&task_id)- }-- pub(super) fn register_pending_service_worker_client_query(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- query_type: PendingServiceWorkerClientQueryType,- ) -> u64 {- let request_id = self.service_worker_client_query_request_ids.allocate();- self.pending_service_worker_client_queries.insert(- request_id,- PendingServiceWorkerClientQuery {- resolver,- query_type,- },- );- request_id- }-- pub(super) fn take_pending_service_worker_client_query(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerClientQuery> {- self.pending_service_worker_client_queries- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_client_navigate(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_client_navigate_request_ids.allocate();- self.pending_service_worker_client_navigates- .insert(request_id, PendingServiceWorkerClientNavigate { resolver });- request_id- }-- pub(super) fn take_pending_service_worker_client_navigate(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerClientNavigate> {- self.pending_service_worker_client_navigates- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_client_focus(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_client_focus_request_ids.allocate();- self.pending_service_worker_client_focuses- .insert(request_id, PendingServiceWorkerClientFocus { resolver });- request_id- }-- pub(super) fn take_pending_service_worker_client_focus(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerClientFocus> {- self.pending_service_worker_client_focuses- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_clients_open_window(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_clients_open_window_request_ids- .allocate();- self.pending_service_worker_clients_open_windows.insert(- request_id,- PendingServiceWorkerClientsOpenWindow { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_clients_open_window(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerClientsOpenWindow> {- self.pending_service_worker_clients_open_windows- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_show_notification(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_show_notification_request_ids.allocate();- self.pending_service_worker_show_notifications.insert(- request_id,- PendingServiceWorkerShowNotification { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_show_notification(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerShowNotification> {- self.pending_service_worker_show_notifications- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_get_notifications(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_get_notifications_request_ids.allocate();- self.pending_service_worker_get_notifications.insert(- request_id,- PendingServiceWorkerGetNotifications { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_get_notifications(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerGetNotifications> {- self.pending_service_worker_get_notifications- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_sync_registration(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_sync_registration_request_ids.allocate();- self.pending_service_worker_sync_registrations.insert(- request_id,- PendingServiceWorkerSyncRegistration { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_sync_registration(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerSyncRegistration> {- self.pending_service_worker_sync_registrations- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_sync_get_tags(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_sync_get_tags_request_ids.allocate();- self.pending_service_worker_sync_get_tags- .insert(request_id, PendingServiceWorkerSyncGetTags { resolver });- request_id- }-- pub(super) fn take_pending_service_worker_sync_get_tags(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerSyncGetTags> {- self.pending_service_worker_sync_get_tags- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_periodic_sync_registration(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_periodic_sync_registration_request_ids- .allocate();- self.pending_service_worker_periodic_sync_registrations- .insert(- request_id,- PendingServiceWorkerPeriodicSyncRegistration { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_periodic_sync_registration(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPeriodicSyncRegistration> {- self.pending_service_worker_periodic_sync_registrations- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_periodic_sync_get_tags(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_periodic_sync_get_tags_request_ids- .allocate();- self.pending_service_worker_periodic_sync_get_tags.insert(- request_id,- PendingServiceWorkerPeriodicSyncGetTags { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_periodic_sync_get_tags(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPeriodicSyncGetTags> {- self.pending_service_worker_periodic_sync_get_tags- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_periodic_sync_unregistration(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_periodic_sync_unregistration_request_ids- .allocate();- self.pending_service_worker_periodic_sync_unregistrations- .insert(- request_id,- PendingServiceWorkerPeriodicSyncUnregistration { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_periodic_sync_unregistration(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPeriodicSyncUnregistration> {- self.pending_service_worker_periodic_sync_unregistrations- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_push_subscribe(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self.service_worker_push_subscription_request_ids.allocate();- self.pending_service_worker_push_subscriptions- .insert(request_id, PendingServiceWorkerPushSubscribe { resolver });- request_id- }-- pub(super) fn take_pending_service_worker_push_subscribe(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPushSubscribe> {- self.pending_service_worker_push_subscriptions- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_push_get_subscription(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_push_get_subscription_request_ids- .allocate();- self.pending_service_worker_push_get_subscriptions.insert(- request_id,- PendingServiceWorkerPushGetSubscription { resolver },- );- request_id- }-- pub(super) fn take_pending_service_worker_push_get_subscription(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPushGetSubscription> {- self.pending_service_worker_push_get_subscriptions- .remove(&request_id)- }-- pub(super) fn register_pending_service_worker_push_unsubscribe(- &mut self,- resolver: v8::Global<v8::PromiseResolver>,- ) -> u64 {- let request_id = self- .service_worker_push_unsubscription_request_ids- .allocate();- self.pending_service_worker_push_unsubscriptions- .insert(request_id, PendingServiceWorkerPushUnsubscribe { resolver });- request_id- }-- pub(super) fn take_pending_service_worker_push_unsubscribe(- &mut self,- request_id: u64,- ) -> Option<PendingServiceWorkerPushUnsubscribe> {- self.pending_service_worker_push_unsubscriptions- .remove(&request_id)- }-- pub(super) fn consume_service_worker_window_interaction(&mut self) -> bool {- if self.service_worker_window_interaction_allowed_count == 0 {- return false;- }-- self.service_worker_window_interaction_allowed_count = self- .service_worker_window_interaction_allowed_count- .saturating_sub(1);-- if let Some((_, pending)) = self- .pending_service_worker_message_events- .iter_mut()- .find(|(_, pending)| pending.window_interaction_allowed)- {- pending.window_interaction_allowed = false;- return true;- }-- if let Some((_, pending)) = self- .pending_service_worker_notification_events- .iter_mut()- .find(|(_, pending)| pending.window_interaction_allowed)- {- pending.window_interaction_allowed = false;- }-- true- }-}--/// Register a pending worker WebCrypto task from a callback scope.-///-/// Returns the routing tuple the blocking task needs to report completion, or-/// `None` when the current scope is not a worker global (e.g. the page runtime-/// or a bare unit-test context). This is the worker-lane analog of the page-/// `register_webcrypto_task`.-pub(crate) fn register_worker_webcrypto_task(- scope: &mut v8::PinScope<'_, '_>,- resolver: v8::Local<'_, v8::PromiseResolver>,-) -> Option<(u64, mpsc::UnboundedSender<WorkerWebCryptoCompletion>)> {- let state = get_worker_state(scope)?;- let resolver = v8::Global::new(scope, resolver);- let mut state = state.borrow_mut();- Some(state.register_pending_webcrypto_task(resolver))-}--pub(crate) fn register_worker_opfs_task(- scope: &mut v8::PinScope<'_, '_>,- resolver: v8::Local<'_, v8::PromiseResolver>,- locator: moli_storage_service::StorageBucketLocator,- handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,-) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {- let state = get_worker_state(scope)?;- let resolver = v8::Global::new(scope, resolver);- let mut state = state.borrow_mut();- Some(state.register_pending_opfs_task(- locator,- handle_access,- crate::opfs_owner_tasks::OpfsTaskSettlement::Promise(resolver),- ))-}--pub(crate) fn register_worker_opfs_iterator_task(- scope: &mut v8::PinScope<'_, '_>,- locator: moli_storage_service::StorageBucketLocator,- registry: crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry,- iterator_id: u32,- keep_alive: v8::Global<v8::Object>,- handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,-) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {- let state = get_worker_state(scope)?;- let mut state = state.borrow_mut();- Some(state.register_pending_opfs_task(- locator,- handle_access,- crate::opfs_owner_tasks::OpfsTaskSettlement::DirectoryIterator {- registry,- iterator_id,- keep_alive,- },- ))-}--pub(crate) fn register_worker_opfs_move_task(- scope: &mut v8::PinScope<'_, '_>,- resolver: v8::Local<'_, v8::PromiseResolver>,- handle: v8::Local<'_, v8::Object>,- mutation: crate::opfs_owner_tasks::OpfsHandleMutationGuard,- locator: moli_storage_service::StorageBucketLocator,- handle_access: Option<crate::opfs_owner_tasks::OpfsHandleAccessContext>,-) -> Option<(u64, mpsc::UnboundedSender<WorkerOpfsCompletion>)> {- let state = get_worker_state(scope)?;- let mut state = state.borrow_mut();- Some(state.register_pending_opfs_task(- locator,- handle_access,- crate::opfs_owner_tasks::OpfsTaskSettlement::Move {- resolver: v8::Global::new(scope, resolver),- handle: v8::Global::new(scope, handle),- mutation,- },- ))-}--pub(crate) fn worker_opfs_handle_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::opfs_owner_tasks::OpfsHandleRegistry> {- Some(- get_worker_state(scope)?- .borrow()- .opfs_owner_state- .as_ref()?- .handles- .clone(),- )-}--pub(crate) fn ensure_worker_opfs_handle_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::opfs_owner_tasks::OpfsHandleRegistry> {- Some(- get_worker_state(scope)?- .borrow_mut()- .opfs_owner_state- .get_or_insert_with(WorkerOpfsOwnerState::default)- .handles- .clone(),- )-}--pub(crate) fn worker_opfs_directory_iterator_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry> {- Some(- get_worker_state(scope)?- .borrow()- .opfs_owner_state- .as_ref()?- .directory_iterators- .clone(),- )-}--pub(crate) fn ensure_worker_opfs_directory_iterator_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::opfs_owner_tasks::OpfsDirectoryIteratorRegistry> {- Some(- get_worker_state(scope)?- .borrow_mut()- .opfs_owner_state- .get_or_insert_with(WorkerOpfsOwnerState::default)- .directory_iterators- .clone(),- )-}--pub(crate) fn cancel_worker_opfs_task(scope: &mut v8::PinScope<'_, '_>, task_id: u64) {- if let Some(state) = get_worker_state(scope) {- state.borrow_mut().take_pending_opfs_task(task_id);- }-}--/// Settle a worker WebCrypto promise once its blocking task reports back on the-/// worker event loop. Terminating a worker drops this state and its completion-/// receiver together, so a separate reset generation is unnecessary.-pub(super) fn drain_worker_webcrypto_completion(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- completion: WorkerWebCryptoCompletion,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_webcrypto_task(completion.task_id) else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- crate::script_vm::webcrypto_tasks::settle_webcrypto_task_result(- scope,- resolver,- completion.result,- );-}--pub(super) fn drain_worker_opfs_completion(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- completion: WorkerOpfsCompletion,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_opfs_task(completion.task_id) else {- return;- };- pending- };- let handle_access = pending.handle_access;- match pending.settlement {- crate::opfs_owner_tasks::OpfsTaskSettlement::Promise(resolver) => {- let resolver = v8::Local::new(scope, &resolver);- crate::context_bootstrap::settle_opfs_task_result(- scope,- resolver,- &pending.locator,- handle_access.as_ref(),- completion.result,- );- }- crate::opfs_owner_tasks::OpfsTaskSettlement::Move {- resolver,- handle,- mutation,- } => {- let resolver = v8::Local::new(scope, &resolver);- let handle = v8::Local::new(scope, &handle);- crate::context_bootstrap::settle_opfs_move_task_result(- scope,- resolver,- handle,- &pending.locator,- handle_access.as_ref(),- completion.result,- );- drop(mutation);- }- crate::opfs_owner_tasks::OpfsTaskSettlement::DirectoryIterator {- registry,- iterator_id,- keep_alive,- } => {- crate::context_bootstrap::settle_opfs_directory_iterator_task_result(- scope,- ®istry,- iterator_id,- &pending.locator,- handle_access.as_ref(),- completion.result,- );- drop(keep_alive);- }- }-}--pub(super) fn drain_service_worker_client_query_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerClientQueryResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_client_query(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match pending.query_type {- PendingServiceWorkerClientQueryType::Get => {- let value = result- .clients- .into_iter()- .next()- .and_then(|client| build_service_worker_client_object_from_snapshot(scope, &client))- .map(v8::Local::into)- .unwrap_or_else(|| v8::undefined(scope).into());- let _ = resolver.resolve(scope, value);- }- PendingServiceWorkerClientQueryType::MatchAll => {- let array = v8::Array::new(scope, result.clients.len() as i32);- for (index, client) in result.clients.iter().enumerate() {- if let Some(object) =- build_service_worker_client_object_from_snapshot(scope, client)- {- let _ = array.set_index(scope, index as u32, object.into());- }- }- let _ = resolver.resolve(scope, array.into());- }- }-}--pub(super) fn drain_service_worker_client_navigate_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerClientNavigateResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_client_navigate(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(Some(client)) => {- let value = build_service_worker_client_object_from_snapshot(scope, &client)- .map(v8::Local::into)- .unwrap_or_else(|| v8::null(scope).into());- let _ = resolver.resolve(scope, value);- }- Ok(None) => {- let _ = resolver.resolve(scope, v8::null(scope).into());- }- Err(error) => match error {- ServiceWorkerClientNavigateError::TypeError(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- },- }-}--pub(super) fn drain_service_worker_client_focus_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: crate::runtime::ServiceWorkerClientFocusResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_client_focus(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(client) => {- let value = build_service_worker_client_object_from_snapshot(scope, &client)- .map(v8::Local::into)- .unwrap_or_else(|| v8::null(scope).into());- let _ = resolver.resolve(scope, value);- }- Err(error) => {- reject_service_worker_client_focus_error(scope, resolver, error);- }- }-}--fn reject_service_worker_client_focus_error<'s>(- scope: &mut v8::PinScope<'s, '_>,- resolver: v8::Local<'s, v8::PromiseResolver>,- error: ServiceWorkerClientFocusError,-) {- match error {- ServiceWorkerClientFocusError::DomException { name, message } => {- let reason = worker_dom_exception_value(scope, &message, name);- let _ = resolver.reject(scope, reason);- }- ServiceWorkerClientFocusError::TypeError(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let reason = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, reason);- }- }-}--pub(super) fn drain_service_worker_clients_open_window_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerClientsOpenWindowResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) =- state.take_pending_service_worker_clients_open_window(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(Some(client)) => {- let value = build_service_worker_client_object_from_snapshot(scope, &client)- .map(v8::Local::into)- .unwrap_or_else(|| v8::null(scope).into());- let _ = resolver.resolve(scope, value);- }- Ok(None) => {- let _ = resolver.resolve(scope, v8::null(scope).into());- }- Err(error) => match error {- ServiceWorkerClientsOpenWindowError::TypeError(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- },- }-}--pub(super) fn drain_service_worker_show_notification_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerShowNotificationResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_show_notification(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(()) => {- let _ = resolver.resolve(scope, v8::undefined(scope).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_get_notifications_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerGetNotificationsResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_get_notifications(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- let notifications = match result.result {- Ok(notifications) => notifications,- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- return;- }- };- let array = v8::Array::new(scope, notifications.len() as i32);- for (index, notification) in notifications.iter().enumerate() {- if let Some(object) =- crate::context_bootstrap::build_notification_object_from_snapshot(scope, notification)- {- let _ = array.set_index(scope, index as u32, object.into());- }- }- let _ = resolver.resolve(scope, array.into());-}--pub(super) fn drain_service_worker_sync_registration_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerSyncRegistrationResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_sync_registration(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(()) => {- let _ = resolver.resolve(scope, v8::undefined(scope).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_sync_get_tags_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerSyncGetTagsResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_sync_get_tags(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(tags) => {- let array = v8::Array::new(scope, tags.len() as i32);- for (index, tag) in tags.iter().enumerate() {- if let Some(value) = v8_string(scope, tag) {- let _ = array.set_index(scope, index as u32, value.into());- }- }- let _ = resolver.resolve(scope, array.into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_periodic_sync_registration_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: crate::runtime::ServiceWorkerPeriodicSyncRegistrationResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) =- state.take_pending_service_worker_periodic_sync_registration(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(()) => {- let _ = resolver.resolve(scope, v8::undefined(scope).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_periodic_sync_get_tags_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: crate::runtime::ServiceWorkerPeriodicSyncGetTagsResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) =- state.take_pending_service_worker_periodic_sync_get_tags(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(tags) => {- let array = v8::Array::new(scope, tags.len() as i32);- for (index, tag) in tags.iter().enumerate() {- if let Some(value) = v8_string(scope, tag) {- let _ = array.set_index(scope, index as u32, value.into());- }- }- let _ = resolver.resolve(scope, array.into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_periodic_sync_unregistration_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: crate::runtime::ServiceWorkerPeriodicSyncUnregistrationResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) =- state.take_pending_service_worker_periodic_sync_unregistration(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(()) => {- let _ = resolver.resolve(scope, v8::undefined(scope).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_push_subscribe_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerPushSubscribeResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_push_subscribe(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(subscription) => {- let value = build_service_worker_push_subscription_object(scope, &subscription)- .map(v8::Local::into)- .unwrap_or_else(|| v8::null(scope).into());- let _ = resolver.resolve(scope, value);- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_push_get_subscription_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerPushGetSubscriptionResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) =- state.take_pending_service_worker_push_get_subscription(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(Some(subscription)) => {- let value = build_service_worker_push_subscription_object(scope, &subscription)- .map(v8::Local::into)- .unwrap_or_else(|| v8::null(scope).into());- let _ = resolver.resolve(scope, value);- }- Ok(None) => {- let _ = resolver.resolve(scope, v8::null(scope).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(super) fn drain_service_worker_push_unsubscribe_result(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- result: ServiceWorkerPushUnsubscribeResult,-) {- let pending = {- let mut state = state.borrow_mut();- let Some(pending) = state.take_pending_service_worker_push_unsubscribe(result.request_id)- else {- return;- };- pending- };- let resolver = v8::Local::new(scope, &pending.resolver);- match result.result {- Ok(unsubscribed) => {- let _ = resolver.resolve(scope, v8::Boolean::new(scope, unsubscribed).into());- }- Err(message) => {- let Some(message) = v8_string(scope, &message) else {- let _ = resolver.reject(scope, v8::undefined(scope).into());- return;- };- let error = v8::Exception::type_error(scope, message);- let _ = resolver.reject(scope, error);- }- }-}--pub(crate) struct NestedWorkerContext {- pub(crate) worker_id: DedicatedWorkerId,- pub(crate) base_url: Url,- pub(crate) loader: crate::network::context::WorkerResourceLoader,- pub(crate) worker_context_runtime: crate::runtime::RendererWorkerContextRuntime,- pub(crate) service_worker_runtime:- Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,- pub(crate) service_worker_client_id:- Option<crate::service_worker_runtime::ServiceWorkerClientId>,- pub(crate) storage_key_top_level_site: String,- pub(crate) creator_storage_key: MoliStorageKey,- pub(crate) indexed_db_manager: Option<crate::context_bootstrap::WeakIndexedDbManager>,- pub(crate) storage_bucket_store: Option<crate::context_bootstrap::SharedStorageBucketStore>,- pub(crate) module_static_import_content_security_policies: Vec<String>,- pub(crate) require_trusted_types_for_script: bool,- pub(crate) network_policy: super::handle::WorkerNetworkPolicy,- pub(crate) policy_context: crate::types::SubresourcePolicyContext,- pub(crate) wake_tx: mpsc::UnboundedSender<super::handle::WorkerMessage>,-}--pub(crate) fn reserve_nested_worker_context(- scope: &mut v8::PinScope<'_, '_>,- worker: v8::Local<'_, v8::Object>,-) -> Option<NestedWorkerContext> {- let state = get_worker_state(scope)?;- let mut state = state.borrow_mut();- let base_url = state.current_script_url.clone()?;- let worker_id = DedicatedWorkerId::new(state.next_nested_worker_id);- state.next_nested_worker_id = state- .next_nested_worker_id- .checked_add(1)- .expect("nested worker id space exhausted");- state- .nested_worker_wrappers- .insert(worker_id, v8::Global::new(scope, worker));- Some(NestedWorkerContext {- worker_id,- base_url,- loader: state.loader.clone(),- worker_context_runtime: state.worker_context_runtime.clone(),- service_worker_runtime: state.service_worker_runtime.clone(),- service_worker_client_id: state.service_worker_client_id,- storage_key_top_level_site: state.storage_key.top_level_site().to_owned(),- creator_storage_key: state.storage_key.clone(),- indexed_db_manager: state.indexed_db_manager.clone(),- storage_bucket_store: state.storage_bucket_store.clone(),- module_static_import_content_security_policies: state.content_security_policies.clone(),- require_trusted_types_for_script:- crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(- &state.content_security_policies,- ),- network_policy: super::handle::WorkerNetworkPolicy {- secure_context: state.secure_context,- permission_overrides: state.permission_overrides.clone(),- extra_http_headers: state.extra_http_headers.clone(),- network_offline: state.network_offline,- blocked_url_patterns: state.blocked_url_patterns.clone(),- network_partition_key: state.network_partition_key.clone(),- fetch_subresource_interception_enabled: state.fetch_subresource_interception_enabled,- fetch_subresource_interception_resource_type: state- .fetch_subresource_interception_resource_type,- },- policy_context: state.policy_context,- wake_tx: state.worker_wake_tx.clone(),- })-}--pub(crate) fn worker_service_worker_control_state(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::runtime::ServiceWorkerControlState> {- let state = get_worker_state(scope)?;- let state = state.borrow();- let runtime = state.service_worker_runtime.as_ref()?;- let client_id = state.service_worker_client_id?;- runtime.matching_controller_for_client(client_id)-}--pub(super) struct NestedWorkerUnhandledError {- pub(super) message: String,- pub(super) filename: String,- pub(super) lineno: u32,- pub(super) colno: u32,- pub(super) event_kind: super::handle::WorkerParentErrorEventKind,-}--pub(super) struct NestedWorkerDispatchResult {- pub(super) dispatched: bool,- pub(super) unhandled_error: Option<NestedWorkerUnhandledError>,-}--pub(crate) fn forget_nested_worker_context(- scope: &mut v8::PinScope<'_, '_>,- worker_id: DedicatedWorkerId,-) -> bool {- let Some(state) = get_worker_state(scope) else {- return false;- };- let mut state = state.borrow_mut();- state.nested_worker_wrappers.remove(&worker_id).is_some()-}--pub(super) fn dispatch_nested_worker_event(- scope: &mut v8::PinScope<'_, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- worker_id: DedicatedWorkerId,- message: &super::handle::WorkerToParentMessage,-) -> NestedWorkerDispatchResult {- let Some(worker) = state- .borrow()- .nested_worker_wrappers- .get(&worker_id)- .map(|worker| v8::Local::new(scope, worker))- else {- return NestedWorkerDispatchResult {- dispatched: false,- unhandled_error: None,- };- };-- match message {- super::handle::WorkerToParentMessage::Post(_) => {- let has_message_delivery_listener =- crate::context_bootstrap::worker_has_message_delivery_listener(scope, worker);- let _ = crate::context_bootstrap::dispatch_worker_event(scope, worker, message);- NestedWorkerDispatchResult {- dispatched: has_message_delivery_listener,- unhandled_error: None,- }- }- super::handle::WorkerToParentMessage::Error {- message: error_message,- filename,- lineno,- colno,- event_kind,- phase,- ..- } => {- let unhandled = crate::context_bootstrap::dispatch_worker_event(scope, worker, message);- // Bootstrap failures only fire an Event at the child Worker. Only- // uncanceled runtime errors propagate to its owner's global scope.- let propagate = unhandled && *phase == super::handle::WorkerErrorPhase::Runtime;- NestedWorkerDispatchResult {- dispatched: true,- unhandled_error: propagate.then(|| NestedWorkerUnhandledError {- message: error_message.clone(),- filename: filename.clone(),- lineno: *lineno,- colno: *colno,- event_kind: *event_kind,- }),- }- }- _ => NestedWorkerDispatchResult {- dispatched: crate::context_bootstrap::dispatch_worker_event(scope, worker, message),- unhandled_error: None,- },- }-}--/// Install the `DedicatedWorkerGlobalScope` APIs on the given V8 global object.-///-/// The `state_ptr` is stored as an external in V8 so callbacks can access-/// `WorkerGlobalState`. Callers must ensure the `Rc<RefCell<WorkerGlobalState>>`-/// outlives the V8 context.-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;- let external = v8::External::new(scope, state_ptr);- // Prevent leak: the Rc was consumed by into_raw, but we still hold `state`.- // We reconstruct it so the ref-count is correct. The raw pointer stored in- // the external is valid as long as the Rc (held by the caller) is alive.- unsafe { Rc::from_raw(state_ptr as *const RefCell<WorkerGlobalState>) };- let global_kind = state.borrow().global_kind.clone();-- let (secure_context, cross_origin_isolated) = {- let state = state.borrow();- (- state.secure_context,- state.secure_context && state.policy_context.cross_origin_isolated,- )- };- WorkerGlobalBootstrapPropertiesDeclaration::new(- external,- global,- cross_origin_isolated,- secure_context,- global,- )- .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, worker_templates)?;- let (_, realm_kind) = worker_global_scope_interface(&global_kind);- crate::context_bootstrap::install_worker_lazy_exposed_interfaces(- scope,- global,- realm_kind,- secure_context,- )?;- crate::context_bootstrap::install_trusted_types_runtime_state(scope, global)?;- let require_trusted_types_for_script =- crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(- &state.borrow().content_security_policies,- );- if require_trusted_types_for_script {- scope- .get_current_context()- .set_allow_generation_from_strings(false);- crate::context_bootstrap::install_trusted_types_eval_runtime_state(scope, global)?;- }- crate::context_bootstrap::install_webassembly_runtime_state(scope, global)?;- if matches!(global_kind, super::thread::WorkerGlobalKind::Service { .. }) {- install_service_worker_extendable_event_constructors(scope, global)?;- }- crate::context_bootstrap::initialize_worker_fetch_realm_state(scope, global)?;- let subtle_crypto_available = secure_context;- crate::context_bootstrap::initialize_worker_crypto_realm_state(- scope,- global,- subtle_crypto_available,- )?;- crate::context_bootstrap::initialize_worker_file_realm_state(scope, global)?;- install_worker_create_image_bitmap(scope, global)?;- let identity = state- .borrow()- .loader- .request_client()- .browser_identity()- .clone();- crate::context_bootstrap::install_worker_navigator_runtime_state(- scope,- global,- secure_context,- &identity,- )?;- crate::context_bootstrap::install_worker_indexed_db_runtime_state(scope, global)?;- crate::context_bootstrap::install_worker_base64_runtime_state(scope, global)?;- install_simple_event_target_methods(scope, global, WORKER_GLOBAL_LISTENERS_SLOT, false);- install_simple_event_target_ordered_handlers(scope, global);- let script_url = state.borrow().current_script_url.clone();- let origin = script_url- .as_ref()- .map(moli_url::origin_ascii_serialization)- .unwrap_or_else(|| "null".to_owned());- WorkerGlobalOriginDeclaration::new(origin)- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker global origin: {error}"))?;- let worker_prototype = global_constructor_prototype(scope, "WorkerGlobalScope")- .ok_or_else(|| anyhow!("WorkerGlobalScope prototype missing"))?;- WorkerGlobalOriginPrototypeDeclaration::default()- .initialize(scope, worker_prototype)- .map_err(|error| anyhow!("failed to initialize WorkerGlobalScope origin: {error}"))?;- if let Some(script_url) = script_url {- crate::context_bootstrap::install_worker_location_runtime_state(- scope,- global,- &script_url,- )?;- crate::context_bootstrap::install_worker_script_url_runtime_state(- scope,- global,- &script_url,- )?;- }-- match &global_kind {- super::thread::WorkerGlobalKind::Dedicated { name } => {- set_worker_global_name_prop(scope, global, name)?;- DedicatedWorkerGlobalPostMessageDeclaration::default()- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker postMessage: {error}"))?;- }- super::thread::WorkerGlobalKind::Shared { name, .. } => {- set_worker_global_name_prop(scope, global, name)?;- }- super::thread::WorkerGlobalKind::Service {- registration_id,- version_id,- scope_url,- } => {- set_worker_global_name_prop(scope, global, "")?;- install_service_worker_global_runtime(- scope,- global,- *registration_id,- *version_id,- scope_url,- )?;- }- }-- WorkerGlobalCommonOperationsDeclaration::default()- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker global operations: {error}"))?;-- install_worker_global_event_handler_accessors(scope, global, &global_kind)?;-- // console- install_console(scope, global)?;-- WorkerGlobalTimerOperationsDeclaration::default()- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker timers: {error}"))?;-- crate::context_bootstrap::exposed_interfaces::capture_eager_intrinsic_interfaces(- scope, global, realm_kind,- )?;- Ok(())-}--fn worker_global_origin_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'s, v8::Value>,-) {- let global = scope.get_current_context().global(scope);- if !args.this().strict_equals(global.into()) {- throw_type_error(scope, "Illegal invocation");- return;- }- let origin = get_private_value(scope, global, WORKER_GLOBAL_ORIGIN_SLOT)- .unwrap_or_else(|| v8str(scope, "null").into());- rv.set(origin);-}--fn worker_global_origin_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'s, v8::Value>,-) {- let global = scope.get_current_context().global(scope);- if !args.this().strict_equals(global.into()) {- throw_type_error(scope, "Illegal invocation");- return;- }- // [Replaceable] creates an own data property without converting the value- // or changing the origin returned by the original getter.- match global.define_own_property(- scope,- v8str(scope, "origin").into(),- args.get(0),- v8::PropertyAttribute::NONE,- ) {- Some(true) => {}- Some(false) => throw_type_error(scope, "Cannot redefine WorkerGlobalScope.origin"),- None => {}- }-}--fn set_worker_global_name_prop<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,- name: &str,-) -> Result<()> {- // WorkerGlobalScope.name is [Replaceable] readonly in IDL. Browsers expose- // an own global property whose assignment becomes a normal enumerable data- // property, which WPT observes through Object.getOwnPropertyDescriptor.- WorkerGlobalNameDeclaration::new(name.to_owned())- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker global `name`: {error}"))-}--fn install_worker_global_event_handler_accessors<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,- global_kind: &super::thread::WorkerGlobalKind,-) -> Result<()> {- if matches!(- global_kind,- super::thread::WorkerGlobalKind::Dedicated { .. }- ) {- DedicatedWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;- DedicatedWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;- }- if matches!(global_kind, super::thread::WorkerGlobalKind::Shared { .. }) {- SharedWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;- SharedWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;- }- if matches!(global_kind, super::thread::WorkerGlobalKind::Service { .. }) {- ServiceWorkerGlobalEventHandlersDeclaration::default().initialize(scope, global)?;- ServiceWorkerGlobalEventHandlerStateDeclaration::default().initialize(scope, global)?;- }- WorkerGlobalCommonEventHandlersDeclaration::default().initialize(scope, global)?;- WorkerGlobalCommonEventHandlerStateDeclaration::default().initialize(scope, global)?;- Ok(())-}--fn worker_global_event_handler_value<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,- slot_name: &str,-) -> v8::Local<'s, v8::Value> {- get_private_value(scope, global, slot_name).unwrap_or_else(|| v8::null(scope).into())-}--fn set_worker_global_event_handler<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,- value: v8::Local<'s, v8::Value>,- slot_name: &'static str,- event_type: Option<&str>,-) {- let stored = if value.is_object() {- value- } else {- v8::null(scope).into()- };- let active = stored.is_object();- set_private_value(scope, global, slot_name, stored);- if let Some(event_type) = event_type {- simple_object_event_set_ordered_handler(- scope,- global,- WORKER_GLOBAL_LISTENERS_SLOT,- event_type,- slot_name,- active,- );- }-}--fn worker_global_onmessage_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONMESSAGE_SLOT,- ));-}--fn worker_global_onmessage_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONMESSAGE_SLOT,- Some("message"),- );-}--fn worker_global_onmessageerror_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONMESSAGEERROR_SLOT,- ));-}--fn worker_global_onmessageerror_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONMESSAGEERROR_SLOT,- Some("messageerror"),- );-}--fn worker_global_oninstall_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONINSTALL_SLOT,- ));-}--fn worker_global_oninstall_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONINSTALL_SLOT,- Some("install"),- );-}--fn worker_global_onactivate_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONACTIVATE_SLOT,- ));-}--fn worker_global_onactivate_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONACTIVATE_SLOT,- Some("activate"),- );-}--fn worker_global_onfetch_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONFETCH_SLOT,- ));-}--fn worker_global_onfetch_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONFETCH_SLOT,- Some("fetch"),- );-}--fn worker_global_onpush_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONPUSH_SLOT,- ));-}--fn worker_global_onpush_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONPUSH_SLOT,- Some("push"),- );-}--fn worker_global_onsync_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONSYNC_SLOT,- ));-}--fn worker_global_onsync_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONSYNC_SLOT,- Some("sync"),- );-}--fn worker_global_onperiodicsync_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONPERIODICSYNC_SLOT,- ));-}--fn worker_global_onperiodicsync_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONPERIODICSYNC_SLOT,- Some("periodicsync"),- );-}--fn worker_global_onnotificationclick_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT,- ));-}--fn worker_global_onnotificationclick_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONNOTIFICATIONCLICK_SLOT,- Some("notificationclick"),- );-}--fn worker_global_onnotificationclose_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT,- ));-}--fn worker_global_onnotificationclose_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONNOTIFICATIONCLOSE_SLOT,- Some("notificationclose"),- );-}--fn worker_global_onerror_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONERROR_SLOT,- ));-}--fn worker_global_onerror_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONERROR_SLOT,- None,- );-}--fn worker_global_onconnect_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONCONNECT_SLOT,- ));-}--fn worker_global_onconnect_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONCONNECT_SLOT,- Some("connect"),- );-}--fn worker_global_onoffline_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONOFFLINE_SLOT,- ));-}--fn worker_global_onoffline_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONOFFLINE_SLOT,- Some("offline"),- );-}--fn worker_global_ononline_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONONLINE_SLOT,- ));-}--fn worker_global_ononline_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONONLINE_SLOT,- Some("online"),- );-}--fn worker_global_onunhandledrejection_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT,- ));-}--fn worker_global_onunhandledrejection_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONUNHANDLEDREJECTION_SLOT,- Some("unhandledrejection"),- );-}--fn worker_global_onrejectionhandled_getter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- rv.set(worker_global_event_handler_value(- scope,- args.this(),- WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT,- ));-}--fn worker_global_onrejectionhandled_setter<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- set_worker_global_event_handler(- scope,- args.this(),- args.get(0),- WORKER_GLOBAL_ONREJECTIONHANDLED_SLOT,- Some("rejectionhandled"),- );-}--fn install_worker_create_image_bitmap<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,-) -> Result<()> {- WorkerGlobalCreateImageBitmapDeclaration::default()- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize createImageBitmap: {error}"))-}--fn worker_create_image_bitmap_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- _args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- let Some(resolver) = v8::PromiseResolver::new(scope) else {- rv.set_undefined();- return;- };- let promise = resolver.get_promise(scope);- let reason = worker_dom_exception_value(- scope,- "The source image could not be decoded.",- "InvalidStateError",- );- let _ = resolver.reject(scope, reason);- rv.set(promise.into());-}--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,-) -> (- &'static str,- crate::context_bootstrap::exposed_interfaces::RealmKind,-) {- use crate::context_bootstrap::exposed_interfaces::RealmKind;- match global_kind {- super::thread::WorkerGlobalKind::Dedicated { .. } => {- ("DedicatedWorkerGlobalScope", RealmKind::DedicatedWorker)- }- super::thread::WorkerGlobalKind::Shared { .. } => {- ("SharedWorkerGlobalScope", RealmKind::SharedWorker)- }- super::thread::WorkerGlobalKind::Service { .. } => {- ("ServiceWorkerGlobalScope", RealmKind::ServiceWorker)- }- }-}--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 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_worker_global_scope_constructors<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,- global_kind: &super::thread::WorkerGlobalKind,- worker_templates: Option<&PreparedWorkerGlobalScopeTemplates>,-) -> Result<()> {- 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 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(())-}--fn install_service_worker_extendable_event_constructors<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,-) -> Result<()> {- let extendable_template = ExtendableEventTemplateDeclaration::build(scope);- let extendable_ctor = extendable_template- .get_function(scope)- .ok_or_else(|| anyhow!("failed to build ExtendableEvent constructor"))?;- let extendable_proto = constructor_prototype(scope, extendable_ctor, "ExtendableEvent")?;- set_worker_to_string_tag(scope, extendable_proto, "ExtendableEvent");- if let Some(event_ctor) = global_constructor_object(scope, "Event") {- let _ = extendable_ctor.set_prototype(scope, event_ctor.into());- }- if let Some(event_proto) = global_constructor_prototype(scope, "Event") {- let _ = extendable_proto.set_prototype(scope, event_proto.into());- }- ExtendableEventConstructorGlobalDeclaration::new(extendable_ctor)- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize ExtendableEvent global: {error}"))?;-- let message_template = ExtendableMessageEventTemplateDeclaration::build(scope);- let message_ctor = message_template- .get_function(scope)- .ok_or_else(|| anyhow!("failed to build ExtendableMessageEvent constructor"))?;- let message_proto = constructor_prototype(scope, message_ctor, "ExtendableMessageEvent")?;- set_worker_to_string_tag(scope, message_proto, "ExtendableMessageEvent");- let _ = message_ctor.set_prototype(scope, extendable_ctor.into());- let _ = message_proto.set_prototype(scope, extendable_proto.into());- ExtendableMessageEventConstructorGlobalDeclaration::new(message_ctor)- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize ExtendableMessageEvent global: {error}"))?;-- ensure_worker_interface_constructor(scope, "ServiceWorker")?;- web_api_interfaces::WindowClient::DESCRIPTOR.register(scope)?;- ensure_worker_interface_constructor(scope, "Client")?;- ensure_worker_interface_constructor(scope, "WindowClient")?;- if let Some(client_ctor) = global_constructor_object(scope, "Client")- && let Some(window_ctor) = global_constructor_object(scope, "WindowClient")- {- let _ = window_ctor.set_prototype(scope, client_ctor.into());- }- if let Some(client_proto) = global_constructor_prototype(scope, "Client")- && let Some(window_proto) = global_constructor_prototype(scope, "WindowClient")- {- let _ = window_proto.set_prototype(scope, client_proto.into());- }-- Ok(())-}--fn extendable_event_constructor_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'s, v8::Value>,-) {- if !args.is_construct_call() {- throw_type_error(- scope,- "Failed to construct 'ExtendableEvent': Please use the 'new' operator.",- );- return;- }- let Some(event_type) = extendable_event_type_argument(scope, &args, "ExtendableEvent") else {- return;- };- let Some((bubbles, cancelable, composed)) =- extendable_event_init_flags(scope, &args, "ExtendableEvent")- else {- return;- };- initialize_extendable_event_object(- scope,- args.this(),- &event_type,- bubbles,- cancelable,- composed,- );- rv.set(args.this().into());-}--fn extendable_message_event_constructor_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'s, v8::Value>,-) {- if !args.is_construct_call() {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': Please use the 'new' operator.",- );- return;- }- let Some(event_type) = extendable_event_type_argument(scope, &args, "ExtendableMessageEvent")- else {- return;- };- let init = extendable_event_init_object(&args);- let Some((bubbles, cancelable, composed)) =- extendable_event_init_flags(scope, &args, "ExtendableMessageEvent")- else {- return;- };- let Some(data) = extendable_message_event_data(scope, init) else {- return;- };- let Some(origin) = extendable_message_event_string_member(scope, init, "origin", "") else {- return;- };- let Some(last_event_id) =- extendable_message_event_string_member(scope, init, "lastEventId", "")- else {- return;- };- let Some(source) = extendable_message_event_source(scope, init) else {- return;- };- let Some(ports) = extendable_message_event_ports(scope, init) else {- return;- };-- let event = args.this();- initialize_extendable_event_object(scope, event, &event_type, bubbles, cancelable, composed);- let _ = ExtendableMessageEventStateDeclaration::new(data, origin, last_event_id, source, ports)- .initialize(scope, event);- rv.set(event.into());-}--fn extendable_event_type_argument<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: &v8::FunctionCallbackArguments<'s>,- constructor_name: &'static str,-) -> Option<String> {- if args.length() == 0 {- throw_type_error(- scope,- &format!("Failed to construct '{constructor_name}': 1 argument required."),- );- return None;- }- webidl::argument::<webidl::DomString>(- scope,- args,- 0,- webidl::Context::argument(constructor_name, 1),- )- .map(Into::into)- .map_or_else(- |error| {- webidl::throw_error(scope, &error);- None- },- Some,- )-}--fn extendable_event_init_object<'s>(- args: &v8::FunctionCallbackArguments<'s>,-) -> Option<v8::Local<'s, v8::Object>> {- if args.length() <= 1 {- return None;- }- let value = args.get(1);- if value.is_null_or_undefined() || !value.is_object() {- None- } else {- v8::Local::<v8::Object>::try_from(value).ok()- }-}--fn extendable_event_init_flags<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: &v8::FunctionCallbackArguments<'s>,- constructor_name: &'static str,-) -> Option<(bool, bool, bool)> {- let init = extendable_event_init_object(args);- Some((- extendable_event_bool_member(scope, init, constructor_name, "bubbles")?,- extendable_event_bool_member(scope, init, constructor_name, "cancelable")?,- extendable_event_bool_member(scope, init, constructor_name, "composed")?,- ))-}--fn extendable_event_bool_member<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,- prefix: &'static str,- key: &'static str,-) -> Option<bool> {- let Some(init) = init else {- return Some(false);- };- let value =- match webidl::property_result(scope, init, key, webidl::Context::member(prefix, key)) {- Ok(Some(value)) if !value.is_undefined() => value,- Ok(_) => return Some(false),- Err(error) => {- webidl::throw_error(scope, &error);- return None;- }- };- webidl::convert::<webidl::Boolean>(scope, value, webidl::Context::member(prefix, key))- .map(Into::into)- .map_or_else(- |error| {- webidl::throw_error(scope, &error);- None- },- Some,- )-}--fn initialize_extendable_event_object<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- event_type: &str,- bubbles: bool,- cancelable: bool,- composed: bool,-) {- // EventTarget dispatch and inherited Event methods require the base- // event's internal state, in addition to its visible properties.- crate::context_bootstrap::initialize_event_object(- scope, event, event_type, bubbles, cancelable,- );- ExtendableEventStateDeclaration::new(composed)- .initialize(scope, event)- .expect("extendable event state should initialize");-}--fn extendable_message_event_data<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,-) -> Option<v8::Local<'s, v8::Value>> {- let Some(init) = init else {- return Some(v8::null(scope).into());- };- match webidl::property_result(- scope,- init,- "data",- webidl::Context::member("ExtendableMessageEvent", "data"),- ) {- Ok(Some(value)) if !value.is_undefined() => Some(value),- Ok(_) => Some(v8::null(scope).into()),- Err(error) => {- webidl::throw_error(scope, &error);- None- }- }-}--fn extendable_message_event_string_member<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,- key: &'static str,- default: &'static str,-) -> Option<String> {- let Some(init) = init else {- return Some(default.to_owned());- };- let value = match webidl::property_result(- scope,- init,- key,- webidl::Context::member("ExtendableMessageEvent", key),- ) {- Ok(Some(value)) if !value.is_undefined() => value,- Ok(_) => return Some(default.to_owned()),- Err(error) => {- webidl::throw_error(scope, &error);- return None;- }- };- webidl::convert::<webidl::DomString>(- scope,- value,- webidl::Context::member("ExtendableMessageEvent", key),- )- .map(Into::into)- .map_or_else(- |error| {- webidl::throw_error(scope, &error);- None- },- Some,- )-}--fn extendable_message_event_source<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,-) -> Option<v8::Local<'s, v8::Value>> {- let Some(init) = init else {- return Some(v8::null(scope).into());- };- let value = match webidl::property_result(- scope,- init,- "source",- webidl::Context::member("ExtendableMessageEvent", "source"),- ) {- Ok(Some(value)) if !value.is_null_or_undefined() => value,- Ok(_) => return Some(v8::null(scope).into()),- Err(error) => {- webidl::throw_error(scope, &error);- return None;- }- };- let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': member source is not of type Client, ServiceWorker, or MessagePort.",- );- return None;- };- if extendable_message_event_source_object_is_valid(scope, object) {- Some(value)- } else {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': member source is not of type Client, ServiceWorker, or MessagePort.",- );- None- }-}--fn extendable_message_event_source_object_is_valid<'s>(- scope: &mut v8::PinScope<'s, '_>,- object: v8::Local<'s, v8::Object>,-) -> bool {- crate::context_bootstrap::message_port_id_from_object(scope, object).is_some()- || get_private_value(scope, object, SERVICE_WORKER_CLIENT_ID_SLOT).is_some()- || (get_private_value(scope, object, SERVICE_WORKER_VERSION_ID_SLOT).is_some()- && object- .get(scope, v8str(scope, "scriptURL").into())- .is_some_and(|value| value.is_string()))-}--fn extendable_message_event_ports<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,-) -> Option<v8::Local<'s, v8::Array>> {- let Some(init) = init else {- return Some(frozen_empty_worker_array(scope));- };- let value = match webidl::property_result(- scope,- init,- "ports",- webidl::Context::member("ExtendableMessageEvent", "ports"),- ) {- Ok(Some(value)) if !value.is_undefined() => value,- Ok(_) => return Some(frozen_empty_worker_array(scope)),- Err(error) => {- webidl::throw_error(scope, &error);- return None;- }- };- let Ok(source) = v8::Local::<v8::Array>::try_from(value) else {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': member ports is not a sequence<MessagePort>.",- );- return None;- };- let ports = v8::Array::new(scope, source.length() as i32);- for index in 0..source.length() {- let port = source.get_index(scope, index)?;- let Ok(port_object) = v8::Local::<v8::Object>::try_from(port) else {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': member ports contains a non-MessagePort value.",- );- return None;- };- if crate::context_bootstrap::message_port_id_from_object(scope, port_object).is_none() {- throw_type_error(- scope,- "Failed to construct 'ExtendableMessageEvent': member ports contains a non-MessagePort value.",- );- return None;- }- let _ = ports.set_index(scope, index, port);- }- let _ = ports.set_integrity_level(scope, v8::IntegrityLevel::Frozen);- Some(ports)-}--fn frozen_empty_worker_array<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Array> {- let array = v8::Array::new(scope, 0);- let _ = array.set_integrity_level(scope, v8::IntegrityLevel::Frozen);- array-}--fn extendable_event_wait_until_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- _args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- let exception = worker_dom_exception_value(- scope,- "ExtendableEvent.waitUntil() was called outside an active event dispatch.",- "InvalidStateError",- );- scope.throw_exception(exception);-}--fn ensure_worker_interface_constructor<'s>(- scope: &mut v8::PinScope<'s, '_>,- name: &'static str,-) -> Result<()> {- let global = scope.get_current_context().global(scope);- if global- .get(scope, v8str(scope, name).into())- .is_some_and(|value| !value.is_undefined())- {- return Ok(());- }- let constructor = worker_scope_constructor(scope, name)?;- let prototype = constructor_prototype(scope, constructor, name)?;- set_worker_to_string_tag(scope, prototype, name);- set_prop(scope, global, name, constructor.into())-}--fn worker_scope_constructor<'s>(- scope: &mut v8::PinScope<'s, '_>,- name: &'static str,-) -> Result<v8::Local<'s, v8::Function>> {- let constructor = v8::Function::builder(worker_global_scope_constructor_callback)- .build(scope)- .ok_or_else(|| anyhow!("failed to build {name} constructor"))?;- constructor.set_name(v8str(scope, name));- Ok(constructor)-}--fn constructor_prototype<'s>(- scope: &mut v8::PinScope<'s, '_>,- constructor: v8::Local<'s, v8::Function>,- name: &'static str,-) -> Result<v8::Local<'s, v8::Object>> {- let prototype_key = v8str(scope, "prototype");- let prototype = constructor- .get(scope, prototype_key.into())- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())- .ok_or_else(|| anyhow!("{name} constructor prototype missing"))?;- WorkerScopePrototypeConstructorDeclaration::new(constructor)- .initialize(scope, prototype)- .map_err(|error| anyhow!("failed to initialize {name}.prototype.constructor: {error}"))?;- Ok(prototype)-}--fn set_worker_to_string_tag<'s>(- scope: &mut v8::PinScope<'s, '_>,- prototype: v8::Local<'s, v8::Object>,- tag: &'static str,-) {- let _ = WorkerPrototypeTagDeclaration::new(tag).initialize(scope, prototype);-}--fn worker_global_scope_constructor_callback(- scope: &mut v8::PinScope<'_, '_>,- _args: v8::FunctionCallbackArguments<'_>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- throw_type_error(scope, "Illegal constructor.");-}--/// Retrieve the `WorkerGlobalState` from a callback scope.-pub(crate) fn get_worker_state<'s>(- scope: &mut v8::PinScope<'s, '_>,-) -> Option<Rc<RefCell<WorkerGlobalState>>> {- let global = scope.get_current_context().global(scope);- let val = get_private_value(scope, global, WORKER_STATE_SLOT)?;- let external = v8::Local::<v8::External>::try_from(val).ok()?;- let ptr = external.value() as *const RefCell<WorkerGlobalState>;- // Safety: the Rc is kept alive by the worker thread for the lifetime of- // the context. We increment the ref-count here so we get our own Rc.- unsafe {- Rc::increment_strong_count(ptr);- Some(Rc::from_raw(ptr))- }-}--pub(super) fn service_worker_fetch_handler_type<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,-) -> WorkerFetchHandlerType {- let listeners = simple_object_event_listeners_snapshot(- scope,- global,- WORKER_GLOBAL_LISTENERS_SLOT,- "fetch",- );- if listeners.is_empty() {- return WorkerFetchHandlerType::NoHandler;- }- if listeners.iter().all(|listener| {- listener- .callable_function()- .is_some_and(|callback| function_source_has_empty_body(scope, callback))- }) {- WorkerFetchHandlerType::EmptyFetchHandler- } else {- WorkerFetchHandlerType::NotSkippable- }-}--fn function_source_has_empty_body<'s>(- scope: &mut v8::PinScope<'s, '_>,- function: v8::Local<'s, v8::Function>,-) -> bool {- let Some(source) = function.to_string(scope) else {- return false;- };- let normalized = source- .to_rust_string_lossy(scope)- .chars()- .filter(|ch| !ch.is_whitespace())- .collect::<String>();- let Some(open_brace) = normalized.find('{') else {- return false;- };- let Some(close_brace) = normalized.rfind('}') else {- return false;- };- open_brace < close_brace && normalized[open_brace + 1..close_brace].is_empty()-}--pub(crate) fn worker_message_port_wake_sender(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<mpsc::UnboundedSender<super::handle::WorkerMessage>> {- Some(get_worker_state(scope)?.borrow().worker_wake_tx.clone())-}--pub(crate) fn worker_message_port_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<SharedMessagePortRegistry> {- Some(- get_worker_state(scope)?- .borrow()- .message_port_registry- .clone(),- )-}--pub(crate) fn worker_broadcast_channel_wake_sender(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<mpsc::UnboundedSender<super::handle::WorkerMessage>> {- Some(get_worker_state(scope)?.borrow().worker_wake_tx.clone())-}--pub(crate) fn worker_broadcast_channel_registry(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<SharedBroadcastChannelRegistry> {- Some(- get_worker_state(scope)?- .borrow()- .broadcast_channel_registry- .clone(),- )-}--pub(crate) fn worker_broadcast_channel_storage_key(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<MoliStorageKey> {- Some(- get_worker_state(scope)?- .borrow()- .broadcast_channel_storage_key- .clone(),- )-}--pub(crate) fn worker_global_is_closed(scope: &mut v8::PinScope<'_, '_>) -> bool {- get_worker_state(scope).is_some_and(|state| state.borrow().closed)-}--pub(crate) fn worker_termination_requested(scope: &mut v8::PinScope<'_, '_>) -> bool {- get_worker_state(scope)- .is_some_and(|state| state.borrow().termination_requested.load(Ordering::Acquire))-}--pub(crate) fn worker_storage_key(scope: &mut v8::PinScope<'_, '_>) -> Option<MoliStorageKey> {- Some(get_worker_state(scope)?.borrow().storage_key.clone())-}--pub(crate) fn worker_storage_partition_identity(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<crate::runtime::RendererStoragePartitionIdentity> {- Some(- get_worker_state(scope)?- .borrow()- .worker_context_runtime- .storage_partition_identity(),- )-}--pub(crate) fn worker_current_script_url(scope: &mut v8::PinScope<'_, '_>) -> Option<Url> {- get_worker_state(scope)?.borrow().current_script_url.clone()-}--pub(crate) fn worker_global_origin(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<moli_url::WebOrigin> {- let global = scope.get_current_context().global(scope);- let origin = get_private_value(scope, global, WORKER_GLOBAL_ORIGIN_SLOT)?;- let origin = v8::Local::<v8::String>::try_from(origin).ok()?;- Some(moli_url::WebOrigin::from_serialized(- &origin.to_rust_string_lossy(scope),- ))-}--pub(crate) fn worker_allows_trusted_type_policy_name(- scope: &mut v8::PinScope<'_, '_>,- name: &str,-) -> Option<bool> {- Some(- crate::content_security_policy::content_security_policy_allows_trusted_type_policy_name(- &get_worker_state(scope)?.borrow().content_security_policies,- name,- ),- )-}--pub(crate) fn worker_requires_trusted_types_for_script(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<bool> {- Some(- crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(- &get_worker_state(scope)?.borrow().content_security_policies,- ),- )-}--pub(crate) fn worker_allows_trusted_types_eval(scope: &mut v8::PinScope<'_, '_>) -> Option<bool> {- Some(- crate::content_security_policy::content_security_policy_allows_trusted_types_eval(- &get_worker_state(scope)?.borrow().content_security_policies,- ),- )-}--pub(crate) fn dispatch_worker_trusted_types_sink_violation_event(- scope: &mut v8::PinScope<'_, '_>,- sink: &str,- sample: &str,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- content_security_policy::dispatch_worker_trusted_types_sink_violation_event_for_state(- scope, &state, sink, sample,- );-}--pub(crate) fn worker_exception_report_target(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<(mpsc::UnboundedSender<WorkerToParentMessage>, String)> {- let state = get_worker_state(scope)?;- let state = state.borrow();- let script_url = state- .current_script_url- .as_ref()- .map(ToString::to_string)- .unwrap_or_default();- Some((state.parent_tx.clone(), script_url))-}--pub(crate) fn worker_uses_shared_worker_agent_cluster(scope: &mut v8::PinScope<'_, '_>) -> bool {- get_worker_state(scope).is_some_and(|state| {- matches!(- state.borrow().global_kind,- super::thread::WorkerGlobalKind::Shared { .. }- )- })-}--pub(crate) fn register_worker_message_port_wrapper(- scope: &mut v8::PinScope<'_, '_>,- port_id: MessagePortId,- port: v8::Local<'_, v8::Object>,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- state.borrow_mut().message_port_wrappers.insert(- port_id,- WorkerMessagePortWrapperEntry {- wrapper: v8::Global::new(scope, port),- },- );-}--pub(crate) fn register_shared_worker_connection_port(- scope: &mut v8::PinScope<'_, '_>,- port_id: MessagePortId,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- state- .borrow_mut()- .shared_worker_connection_ports- .insert(port_id);-}--pub(crate) fn forget_worker_message_port_wrapper(- scope: &mut v8::PinScope<'_, '_>,- port_id: MessagePortId,-) {- if let Some(state) = get_worker_state(scope) {- state.borrow_mut().message_port_wrappers.remove(&port_id);- }-}--pub(crate) fn worker_message_port_wrapper<'s>(- scope: &mut v8::PinScope<'s, '_>,- port_id: MessagePortId,-) -> Option<v8::Local<'s, v8::Object>> {- let state = get_worker_state(scope)?;- let state = state.borrow();- state- .message_port_wrappers- .get(&port_id)- .map(|entry| v8::Local::new(scope, &entry.wrapper))-}--pub(crate) fn register_worker_broadcast_channel_wrapper(- scope: &mut v8::PinScope<'_, '_>,- channel_id: BroadcastChannelId,- channel: v8::Local<'_, v8::Object>,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- state- .borrow_mut()- .broadcast_channel_wrappers- .insert(channel_id, v8::Global::new(scope, channel));-}--pub(crate) fn forget_worker_broadcast_channel_wrapper(- scope: &mut v8::PinScope<'_, '_>,- channel_id: BroadcastChannelId,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- state- .borrow_mut()- .broadcast_channel_wrappers- .remove(&channel_id);-}--pub(crate) fn worker_broadcast_channel_wrapper<'s>(- scope: &mut v8::PinScope<'s, '_>,- channel_id: BroadcastChannelId,-) -> Option<v8::Local<'s, v8::Object>> {- let state = get_worker_state(scope)?;- let state = state.borrow();- state- .broadcast_channel_wrappers- .get(&channel_id)- .map(|handle| v8::Local::new(scope, handle))-}--pub(super) fn close_worker_owned_message_ports(state: &Rc<RefCell<WorkerGlobalState>>) {- let (registry, port_ids): (SharedMessagePortRegistry, Vec<MessagePortId>) = {- let mut state = state.borrow_mut();- let shared_worker_connection_ports =- std::mem::take(&mut state.shared_worker_connection_ports);- (- state.message_port_registry.clone(),- state- .message_port_wrappers- .drain()- .filter_map(|(port_id, _)| {- (!shared_worker_connection_ports.contains(&port_id)).then_some(port_id)- })- .collect(),- )- };- for port_id in port_ids {- registry.close_message_port(port_id);- }-}--pub(super) fn close_worker_owned_broadcast_channels(state: &Rc<RefCell<WorkerGlobalState>>) {- let (registry, channel_ids): (SharedBroadcastChannelRegistry, Vec<BroadcastChannelId>) = {- let mut state = state.borrow_mut();- (- state.broadcast_channel_registry.clone(),- state- .broadcast_channel_wrappers- .drain()- .map(|(channel_id, _)| channel_id)- .collect(),- )- };- for channel_id in channel_ids {- registry.close_broadcast_channel(channel_id);- }-}--fn next_fetch_id(state: &mut WorkerGlobalState) -> u32 {- state.next_fetch_id = state- .next_fetch_id- .checked_add(1)- .expect("worker fetch id space exhausted");- state.next_fetch_id-}--fn next_xhr_id(state: &mut WorkerGlobalState) -> u32 {- state.next_xhr_id = state- .next_xhr_id- .checked_add(1)- .expect("worker XHR id space exhausted");- state.next_xhr_id-}--fn next_websocket_id(state: &mut WorkerGlobalState) -> u64 {- state.next_websocket_id = state- .next_websocket_id- .checked_add(1)- .expect("worker WebSocket id space exhausted");- state.next_websocket_id-}--fn worker_url_blocked(patterns: &[String], url: &Url) -> bool {- let value = url.as_str();- patterns- .iter()- .any(|pattern| moli_fetch::url_pattern_matches(pattern, value))-}--fn merge_worker_request_headers(- context_headers: &moli_fetch::RequestHeaders,- request_headers: &moli_fetch::RequestHeaders,-) -> moli_fetch::RequestHeaders {- let mut headers = context_headers.clone();- headers.overlay(request_headers.clone());- headers-}--fn worker_post_message_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- if args.length() == 0 {- throw_type_error(- scope,- "Failed to execute 'postMessage' on 'DedicatedWorkerGlobalScope': 1 argument required, but only 0 present.",- );- return;- }- let val = args.get(0);- let transfer_arg = (args.length() > 1).then(|| args.get(1));- let Some(data) = crate::context_bootstrap::structured_serialize_value_for_post_message(- scope,- val,- transfer_arg,- "DedicatedWorkerGlobalScope",- ) else {- return;- };- let _ = state- .borrow()- .parent_tx- .send(WorkerToParentMessage::Post(data));-}--fn worker_structured_clone_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- if let Some(value) = crate::context_bootstrap::structured_clone_value_with_options(- scope,- args.get(0),- args.get(1),- ) {- rv.set(value);- } else {- rv.set_undefined();- }-}--fn worker_import_scripts_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- let Some(state) = get_worker_state(scope) else {- return;- };- if state.borrow().script_kind == super::thread::WorkerScriptKind::Module {- throw_type_error(scope, "Module scripts don't support importScripts().");- return;- }- let require_trusted_types_for_script =- crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(- &state.borrow().content_security_policies,- );- let mut prepared = Vec::with_capacity(args.length() as usize);- for i in 0..args.length() {- let Some(specifier) = crate::context_bootstrap::trusted_script_url_string_or_throw(- scope,- args.get(i),- crate::content_security_policy::TrustedTypesForScriptRequirements::enforced_only(- require_trusted_types_for_script,- ),- "WorkerGlobalScope importScripts",- "importScripts",- ) else {- return;- };- let resolved_url = match resolve_import_script_url(state.clone(), &specifier) {- Ok(url) => url,- Err(error) => {- error.throw(scope);- return;- }- };- let source = if matches!(resolved_url.scheme(), "data" | "blob") {- match materialize_worker_import_source(scope, &state, &resolved_url) {- Ok(import_source) => Some(import_source.source),- Err(error) => {- error.throw(scope);- return;- }- }- } else {- None- };- prepared.push(PreparedWorkerImportScript {- final_url: resolved_url,- source,- muted_errors: false,- });- }- for mut script in prepared {- if script.source.is_none() {- let import_source =- match materialize_worker_import_source(scope, &state, &script.final_url) {- Ok(result) => result,- Err(error) => {- error.throw(scope);- return;- }- };- script.final_url = import_source.final_url;- script.source = Some(import_source.source);- script.muted_errors = import_source.muted_errors;- }- let source = script.source.as_deref().unwrap_or_default();- if let Err(error) = evaluate_worker_script(- scope,- state.clone(),- &script.final_url,- source,- script.muted_errors,- ) {- error.throw(scope);- return;- }- }-}--// ─── close ──────────────────────────────────────────────────────────────────--fn worker_close_callback(- scope: &mut v8::PinScope<'_, '_>,- _args: v8::FunctionCallbackArguments<'_>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- if let Some(state) = get_worker_state(scope) {- state.borrow_mut().closed = true;- close_worker_owned_broadcast_channels(&state);- }-}--fn install_console<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,-) -> Result<()> {- let console_key = v8str(scope, "console");- if let Some(original_console) = global.get(scope, console_key.into()) {- set_private_value(- scope,- global,- WORKER_ORIGINAL_CONSOLE_SLOT,- original_console,- );- }- let _ = global.delete(scope, console_key.into());-- let console = WorkerConsoleObjectDeclaration::default()- .bind(scope)- .map_err(|error| anyhow!("failed to create worker console: {error}"))?;-- WorkerGlobalConsoleDeclaration::new(console)- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker console: {error}"))-}--fn install_worker_performance<'s>(- scope: &mut v8::PinScope<'s, '_>,- global: v8::Local<'s, v8::Object>,-) -> Result<()> {- let time_origin = monotonic_unix_epoch_millis();- let performance = WorkerPerformanceObjectDeclaration::new(time_origin)- .bind(scope)- .map_err(|error| anyhow!("failed to create worker performance: {error}"))?;- WorkerGlobalPerformanceDeclaration::new(performance)- .initialize(scope, global)- .map_err(|error| anyhow!("failed to initialize worker performance: {error}"))-}--fn worker_performance_now_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- let time_origin = args.data().number_value(scope).unwrap_or(0.0);- rv.set(- v8::Number::new(- scope,- moli_time::coarsened_dom_time_millis(- (monotonic_unix_epoch_millis() - time_origin).max(0.0),- ),- )- .into(),- );-}--fn unix_epoch_millis() -> f64 {- SystemTime::now()- .duration_since(UNIX_EPOCH)- .map(|duration| duration.as_secs_f64() * 1000.0)- .unwrap_or(0.0)-}--fn monotonic_unix_epoch_millis() -> f64 {- static BASE: OnceLock<(f64, Instant)> = OnceLock::new();- let (epoch_millis, instant) = BASE.get_or_init(|| (unix_epoch_millis(), Instant::now()));- epoch_millis + instant.elapsed().as_secs_f64() * 1000.0-}--fn format_console_args(- scope: &mut v8::PinScope<'_, '_>,- args: &v8::FunctionCallbackArguments<'_>,-) -> String {- let mut parts = Vec::new();- for i in 0..args.length() {- let val = args.get(i);- if let Some(s) = val.to_detail_string(scope) {- parts.push(s.to_rust_string_lossy(scope));- }- }- parts.join(" ")-}--fn console_arg_snapshots_json(- scope: &mut v8::PinScope<'_, '_>,- args: &v8::FunctionCallbackArguments<'_>,-) -> Vec<serde_json::Value> {- let mut snapshots = Vec::with_capacity(args.length().max(0) as usize);- for index in 0..args.length() {- snapshots.push(crate::context_bootstrap::console_arg_remote_object_json(- scope,- args.get(index),- ));- }- snapshots-}--fn console_log_callback(- scope: &mut v8::PinScope<'_, '_>,- args: v8::FunctionCallbackArguments<'_>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {- let level = args- .data()- .to_string(scope)- .map(|value| value.to_rust_string_lossy(scope))- .unwrap_or_else(|| "log".to_owned());- let text = format_console_args(scope, &args);- let message = format!("{level}: {text}");- let arg_snapshots = console_arg_snapshots_json(scope, &args);- let stack = crate::context_bootstrap::current_console_stack(scope);- tracing::trace!("{}", message);- if let Some(state) = get_worker_state(scope) {- let parent_tx = state.borrow().parent_tx.clone();- let _ = parent_tx.send(WorkerToParentMessage::Console(WorkerConsoleMessage {- message,- args: arg_snapshots,- stack,- }));- }-}--fn console_noop_callback(- _scope: &mut v8::PinScope<'_, '_>,- _args: v8::FunctionCallbackArguments<'_>,- _rv: v8::ReturnValue<'_, v8::Value>,-) {-}--fn console_profile_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- call_original_worker_console_method(scope, &args, "profile");- rv.set_undefined();-}--fn console_profile_end_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- call_original_worker_console_method(scope, &args, "profileEnd");- rv.set_undefined();-}--fn call_original_worker_console_method<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: &v8::FunctionCallbackArguments<'s>,- method_name: &'static str,-) {- let global = scope.get_current_context().global(scope);- let Some(original_console) = get_private_value(scope, global, WORKER_ORIGINAL_CONSOLE_SLOT)- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())- else {- return;- };- let Some(method) = original_console- .get(scope, v8str(scope, method_name).into())- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())- else {- return;- };-- let mut forwarded_args = Vec::with_capacity(args.length().max(0) as usize);- for index in 0..args.length() {- forwarded_args.push(args.get(index));- }- let _ = method.call(scope, original_console.into(), &forwarded_args);-}--// ─── timers (minimal stubs) ─────────────────────────────────────────────────--fn create_script_origin<'s>(scope: &mut v8::PinScope<'s, '_>, url: &str) -> v8::ScriptOrigin<'s> {- let name = v8::String::new(scope, url).expect("worker script origin");- v8::ScriptOrigin::new(- scope,- name.into(),- 0,- 0,- false,- -1,- None,- false,- false,- false,- None,- )-}--fn set_prop(- scope: &mut v8::PinScope<'_, '_>,- obj: v8::Local<'_, v8::Object>,- name: &str,- value: v8::Local<'_, v8::Value>,-) -> Result<()> {- let key =- v8_string(scope, name).ok_or_else(|| anyhow!("failed to allocate worker key `{name}`"))?;- obj.define_own_property(scope, key.into(), value, v8::PropertyAttribute::DONT_ENUM)- .unwrap_or(false)- .then_some(())- .ok_or_else(|| anyhow!("failed to set worker global `{name}`"))-}--// ─── timer info (used by the event loop in thread.rs) ───────────────────────--#[derive(Clone, Default)]-pub(super) struct WorkerIsolateTimerQueues {- pending: Rc<RefCell<Vec<TimerInfo>>>,- cancelled: Rc<RefCell<Vec<u32>>>,-}--impl WorkerIsolateTimerQueues {- pub(super) fn push_pending(&self, timer: TimerInfo) {- self.pending.borrow_mut().push(timer);- }-- pub(super) fn clear_pending_and_active(&self, timer_id: u32) {- self.pending- .borrow_mut()- .retain(|timer| timer.id != timer_id);- self.cancel_active(timer_id);- }-- pub(super) fn cancel_active(&self, timer_id: u32) {- self.cancelled.borrow_mut().push(timer_id);- }-- pub(super) fn drain_pending(&self) -> Vec<TimerInfo> {- self.pending.borrow_mut().drain(..).collect()- }-- pub(super) fn drain_cancelled(&self) -> Vec<u32> {- self.cancelled.borrow_mut().drain(..).collect()- }-}--pub(super) fn worker_isolate_timer_queues(- scope: &mut v8::PinScope<'_, '_>,-) -> Option<WorkerIsolateTimerQueues> {- scope.get_slot::<WorkerIsolateTimerQueues>().cloned()-}--pub(super) struct TimerInfo {- pub(super) id: u32,- pub(super) callback: super::timer_callback::WorkerTimerCallback,- pub(super) delay_ms: u64,- pub(super) is_interval: bool,- pub(super) extra_args: Vec<v8::Global<v8::Value>>,-}--pub(crate) fn worker_allows_eval_code_generation_by_csp(- scope: &mut v8::PinScope<'_, '_>,- allow_trusted_types_eval: bool,- source: Option<&str>,-) -> Option<bool> {- use crate::content_security_policy::ContentSecurityPolicyNonUrlKind;- let kind = if allow_trusted_types_eval {- ContentSecurityPolicyNonUrlKind::TrustedTypesEval- } else {- ContentSecurityPolicyNonUrlKind::Eval- };- worker_allows_compilation_by_csp(scope, kind, source)-}--fn worker_allows_compilation_by_csp(- scope: &mut v8::PinScope<'_, '_>,- kind: crate::content_security_policy::ContentSecurityPolicyNonUrlKind,- source: Option<&str>,-) -> Option<bool> {- let state = get_worker_state(scope)?;- let (wake_tx, mut report_only_violations, mut enforce_violations) = {- let state = state.borrow();- let Some(protected_url) = state.current_script_url.as_ref() else {- return Some(true);- };- (- state.worker_wake_tx.clone(),- content_security_policy::worker_compilation_content_security_policy_violations(- &state,- protected_url,- kind,- source,- crate::content_security_policy::ContentSecurityPolicyDisposition::Report,- ),- content_security_policy::worker_compilation_content_security_policy_violations(- &state,- protected_url,- kind,- source,- crate::content_security_policy::ContentSecurityPolicyDisposition::Enforce,- ),- )- };- if kind != crate::content_security_policy::ContentSecurityPolicyNonUrlKind::WasmEval- && (!report_only_violations.is_empty() || !enforce_violations.is_empty())- && let Some((source_file, line_number, column_number)) =- crate::content_security_policy::current_script_violation_location(scope)- {- for violation in [&mut report_only_violations, &mut enforce_violations]- .into_iter()- .flatten()- {- violation.source_file.clone_from(&source_file);- violation.line_number = line_number;- violation.column_number = column_number;- }- }- let allowed = enforce_violations.is_empty();- for violation in report_only_violations.into_iter().chain(enforce_violations) {- let _ = wake_tx.send(- super::handle::WorkerMessage::DispatchContentSecurityPolicyViolation(Box::new(- violation,- )),- );- }- Some(allowed)-}--pub(super) fn dispatch_worker_csp_violation_event_for_state<'s>(- scope: &mut v8::PinScope<'s, '_>,- state: &Rc<RefCell<WorkerGlobalState>>,- violation: &crate::content_security_policy::ContentSecurityPolicyUrlViolation,-) {- content_security_policy::dispatch_worker_content_security_policy_violation_event_for_state(- scope, state, violation,- );-}+pub(super) use async_tasks::{+ PendingWorkerWebCryptoTask, WorkerOpfsOwnerState, drain_worker_opfs_completion,+ drain_worker_webcrypto_completion,+};+pub(crate) use async_tasks::{+ WorkerOpfsCompletion, WorkerWebCryptoCompletion, cancel_worker_opfs_task,+ ensure_worker_opfs_directory_iterator_registry, ensure_worker_opfs_handle_registry,+ register_worker_opfs_iterator_task, register_worker_opfs_move_task, register_worker_opfs_task,+ register_worker_webcrypto_task, worker_opfs_directory_iterator_registry,+ worker_opfs_handle_registry,+};+use bootstrap::{+ constructor_prototype, ensure_worker_interface_constructor, set_worker_to_string_tag,+};+pub(super) use bootstrap::{install_worker_global_scope, prepare_worker_global_scope_templates};+use console::install_console;+pub(super) use content_security_policy::{+ dispatch_worker_csp_violation_event, dispatch_worker_csp_violation_event_for_state,+};+pub(crate) use content_security_policy::{+ dispatch_worker_trusted_types_sink_violation_event, worker_allows_eval_code_generation_by_csp,+ worker_allows_trusted_type_policy_name, worker_allows_trusted_types_eval,+ worker_requires_trusted_types_for_script,+};+use event_handlers::install_worker_global_event_handler_accessors;+pub(super) use event_handlers::{WORKER_GLOBAL_LISTENERS_SLOT, service_worker_fetch_handler_type};+use extendable_events::install_service_worker_extendable_event_constructors;+pub(super) use extendable_events::{+ PendingServiceWorkerFetchEvent, PendingServiceWorkerLifecycleEvent,+ PendingServiceWorkerMessageEvent, PendingServiceWorkerNavigationPreload,+ PendingServiceWorkerNotificationEvent, PendingServiceWorkerPeriodicSyncEvent,+ PendingServiceWorkerPushEvent, PendingServiceWorkerSyncEvent,+};+pub(super) use import_scripts::{+ WORKER_EXCEPTION_COLUMN_SLOT, WORKER_EXCEPTION_LINE_SLOT, WORKER_EXCEPTION_SOURCE_SLOT,+};+use messaging::{DedicatedWorkerGlobalPostMessageDeclaration, worker_structured_clone_callback};+pub(super) use messaging::{+ WorkerMessagePortWrapperEntry, close_worker_owned_broadcast_channels,+ close_worker_owned_message_ports,+};+pub(crate) use messaging::{+ forget_worker_broadcast_channel_wrapper, forget_worker_message_port_wrapper,+ register_shared_worker_connection_port, register_worker_broadcast_channel_wrapper,+ register_worker_message_port_wrapper, worker_broadcast_channel_registry,+ worker_broadcast_channel_storage_key, worker_broadcast_channel_wake_sender,+ worker_broadcast_channel_wrapper, worker_message_port_registry,+ worker_message_port_wake_sender, worker_message_port_wrapper,+};+pub(super) use nested_workers::dispatch_nested_worker_event;+pub(crate) use nested_workers::{+ NestedWorkerContext, forget_nested_worker_context, reserve_nested_worker_context,+};+pub(super) use network_state::{+ PausedWorkerSubresourceResponse, PendingWorkerCspReport, PendingWorkerFetch,+ PendingWorkerFetchNetworkRecord, PendingWorkerXhr, WorkerFetchCompletion, WorkerFetchEvent,+ WorkerFetchResponse, WorkerFetchStreamingChunk, WorkerFetchStreamingFinished,+ WorkerFetchStreamingStarted, WorkerWebSocketState, WorkerXhrCompletion, WorkerXhrResponse,+};+use network_state::{+ WorkerFetchResponseParts, merge_worker_request_headers, next_fetch_id, next_websocket_id,+ next_xhr_id, worker_url_blocked,+};+pub(crate) use origin::worker_global_origin;+use origin::{WorkerGlobalOriginDeclaration, WorkerGlobalOriginPrototypeDeclaration};+use performance::{install_worker_performance, monotonic_unix_epoch_millis};+pub(super) use service_worker_results::{+ PendingServiceWorkerClientFocus, PendingServiceWorkerClientNavigate,+ PendingServiceWorkerClientQuery, PendingServiceWorkerClientQueryType,+ PendingServiceWorkerClientsOpenWindow, PendingServiceWorkerGetNotifications,+ PendingServiceWorkerPeriodicSyncGetTags, PendingServiceWorkerPeriodicSyncRegistration,+ PendingServiceWorkerPeriodicSyncUnregistration, PendingServiceWorkerPushGetSubscription,+ PendingServiceWorkerPushSubscribe, PendingServiceWorkerPushUnsubscribe,+ PendingServiceWorkerShowNotification, PendingServiceWorkerSyncGetTags,+ PendingServiceWorkerSyncRegistration, WorkerServiceWorkerRequestIdAllocator,+ drain_service_worker_client_focus_result, drain_service_worker_client_navigate_result,+ drain_service_worker_client_query_result, drain_service_worker_clients_open_window_result,+ drain_service_worker_get_notifications_result,+ drain_service_worker_periodic_sync_get_tags_result,+ drain_service_worker_periodic_sync_registration_result,+ drain_service_worker_periodic_sync_unregistration_result,+ drain_service_worker_push_get_subscription_result, drain_service_worker_push_subscribe_result,+ drain_service_worker_push_unsubscribe_result, drain_service_worker_show_notification_result,+ drain_service_worker_sync_get_tags_result, drain_service_worker_sync_registration_result,+};+use state::worker_close_callback;+pub(crate) use state::{+ WORKER_STATE_SLOT, WorkerGlobalState, get_worker_state, worker_current_script_url,+ worker_exception_report_target, worker_global_is_closed, worker_service_worker_control_state,+ worker_storage_key, worker_storage_partition_identity, worker_termination_requested,+ worker_uses_shared_worker_agent_cluster,+};+pub(super) use timers::{TimerInfo, WorkerIsolateTimerQueues, worker_isolate_timer_queues};diff --git a/moli-renderer-v8/src/worker/global_scope/nested_workers.rs b/moli-renderer-v8/src/worker/global_scope/nested_workers.rsnew file mode 100644index 000000000..f581efe1e--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/nested_workers.rs@@ -0,0 +1,153 @@+//! Nested worker ownership, creation snapshots and parent event delivery.++use super::*;++pub(crate) struct NestedWorkerContext {+ pub(crate) worker_id: DedicatedWorkerId,+ pub(crate) base_url: Url,+ pub(crate) loader: crate::network::context::WorkerResourceLoader,+ pub(crate) worker_context_runtime: crate::runtime::RendererWorkerContextRuntime,+ pub(crate) service_worker_runtime:+ Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,+ pub(crate) service_worker_client_id:+ Option<crate::service_worker_runtime::ServiceWorkerClientId>,+ pub(crate) storage_key_top_level_site: String,+ pub(crate) creator_storage_key: MoliStorageKey,+ pub(crate) indexed_db_manager: Option<crate::context_bootstrap::WeakIndexedDbManager>,+ pub(crate) storage_bucket_store: Option<crate::context_bootstrap::SharedStorageBucketStore>,+ pub(crate) module_static_import_content_security_policies: Vec<String>,+ pub(crate) require_trusted_types_for_script: bool,+ pub(crate) network_policy: crate::worker::handle::WorkerNetworkPolicy,+ pub(crate) policy_context: crate::types::SubresourcePolicyContext,+ pub(crate) wake_tx: mpsc::UnboundedSender<crate::worker::handle::WorkerMessage>,+}++pub(crate) fn reserve_nested_worker_context(+ scope: &mut v8::PinScope<'_, '_>,+ worker: v8::Local<'_, v8::Object>,+) -> Option<NestedWorkerContext> {+ let state = get_worker_state(scope)?;+ let mut state = state.borrow_mut();+ let base_url = state.current_script_url.clone()?;+ let worker_id = DedicatedWorkerId::new(state.next_nested_worker_id);+ state.next_nested_worker_id = state+ .next_nested_worker_id+ .checked_add(1)+ .expect("nested worker id space exhausted");+ state+ .nested_worker_wrappers+ .insert(worker_id, v8::Global::new(scope, worker));+ Some(NestedWorkerContext {+ worker_id,+ base_url,+ loader: state.loader.clone(),+ worker_context_runtime: state.worker_context_runtime.clone(),+ service_worker_runtime: state.service_worker_runtime.clone(),+ service_worker_client_id: state.service_worker_client_id,+ storage_key_top_level_site: state.storage_key.top_level_site().to_owned(),+ creator_storage_key: state.storage_key.clone(),+ indexed_db_manager: state.indexed_db_manager.clone(),+ storage_bucket_store: state.storage_bucket_store.clone(),+ module_static_import_content_security_policies: state.content_security_policies.clone(),+ require_trusted_types_for_script:+ crate::content_security_policy::content_security_policy_requires_trusted_types_for_script(+ &state.content_security_policies,+ ),+ network_policy: crate::worker::handle::WorkerNetworkPolicy {+ secure_context: state.secure_context,+ permission_overrides: state.permission_overrides.clone(),+ extra_http_headers: state.extra_http_headers.clone(),+ network_offline: state.network_offline,+ blocked_url_patterns: state.blocked_url_patterns.clone(),+ network_partition_key: state.network_partition_key.clone(),+ fetch_subresource_interception_enabled: state.fetch_subresource_interception_enabled,+ fetch_subresource_interception_resource_type: state+ .fetch_subresource_interception_resource_type,+ },+ policy_context: state.policy_context,+ wake_tx: state.worker_wake_tx.clone(),+ })+}++pub(in crate::worker) struct NestedWorkerUnhandledError {+ pub(in crate::worker) message: String,+ pub(in crate::worker) filename: String,+ pub(in crate::worker) lineno: u32,+ pub(in crate::worker) colno: u32,+ pub(in crate::worker) event_kind: crate::worker::handle::WorkerParentErrorEventKind,+}++pub(in crate::worker) struct NestedWorkerDispatchResult {+ pub(in crate::worker) dispatched: bool,+ pub(in crate::worker) unhandled_error: Option<NestedWorkerUnhandledError>,+}++pub(crate) fn forget_nested_worker_context(+ scope: &mut v8::PinScope<'_, '_>,+ worker_id: DedicatedWorkerId,+) -> bool {+ let Some(state) = get_worker_state(scope) else {+ return false;+ };+ let mut state = state.borrow_mut();+ state.nested_worker_wrappers.remove(&worker_id).is_some()+}++pub(in crate::worker) fn dispatch_nested_worker_event(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ worker_id: DedicatedWorkerId,+ message: &crate::worker::handle::WorkerToParentMessage,+) -> NestedWorkerDispatchResult {+ let Some(worker) = state+ .borrow()+ .nested_worker_wrappers+ .get(&worker_id)+ .map(|worker| v8::Local::new(scope, worker))+ else {+ return NestedWorkerDispatchResult {+ dispatched: false,+ unhandled_error: None,+ };+ };++ match message {+ crate::worker::handle::WorkerToParentMessage::Post(_) => {+ let has_message_delivery_listener =+ crate::context_bootstrap::worker_has_message_delivery_listener(scope, worker);+ let _ = crate::context_bootstrap::dispatch_worker_event(scope, worker, message);+ NestedWorkerDispatchResult {+ dispatched: has_message_delivery_listener,+ unhandled_error: None,+ }+ }+ crate::worker::handle::WorkerToParentMessage::Error {+ message: error_message,+ filename,+ lineno,+ colno,+ event_kind,+ phase,+ ..+ } => {+ let unhandled = crate::context_bootstrap::dispatch_worker_event(scope, worker, message);+ // Bootstrap failures only fire an Event at the child Worker. Only+ // uncanceled runtime errors propagate to its owner's global scope.+ let propagate = unhandled && *phase == crate::worker::handle::WorkerErrorPhase::Runtime;+ NestedWorkerDispatchResult {+ dispatched: true,+ unhandled_error: propagate.then(|| NestedWorkerUnhandledError {+ message: error_message.clone(),+ filename: filename.clone(),+ lineno: *lineno,+ colno: *colno,+ event_kind: *event_kind,+ }),+ }+ }+ _ => NestedWorkerDispatchResult {+ dispatched: crate::context_bootstrap::dispatch_worker_event(scope, worker, message),+ unhandled_error: None,+ },+ }+}diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rsnew file mode 100644index 000000000..0eab8e2c5--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs@@ -0,0 +1,265 @@+//! Pending worker network requests, response snapshots and shared request helpers.++use super::*;++pub(in crate::worker) struct PendingWorkerFetch {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+ pub(in crate::worker) document_url: Url,+ pub(in crate::worker) credentials_mode: RequestCredentialsMode,+ pub(in crate::worker) request_mode: moli_fetch::RequestMode,+ pub(in crate::worker) redirect_mode: RequestRedirectMode,+ pub(in crate::worker) request_priority: Option<moli_fetch::FetchPriorityHint>,+ pub(in crate::worker) request_metadata:+ crate::service_worker_runtime::ServiceWorkerFetchRequestMetadata,+ pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext,+ pub(in crate::worker) signal_id: Option<u32>,+ pub(in crate::worker) load: ResourceLoadLease,+ pub(in crate::worker) request_url: Url,+ pub(in crate::worker) request_method: String,+ pub(in crate::worker) request_headers: moli_fetch::RequestHeaders,+ pub(in crate::worker) request_body: Option<String>,+ pub(in crate::worker) network_request_handle: Option<SubresourceNetworkRequestHandle>,+ pub(in crate::worker) network_record: Option<PendingWorkerFetchNetworkRecord>,+ pub(in crate::worker) paused_response: Option<PausedWorkerSubresourceResponse>,+ pub(in crate::worker) streaming_body_source_id: Option<NetworkBodySourceId>,+}++pub(in crate::worker) enum WorkerFetchEvent {+ Completion(Box<WorkerFetchCompletion>),+ StreamingStarted(WorkerFetchStreamingStarted),+ StreamingChunk(WorkerFetchStreamingChunk),+ StreamingFinished(WorkerFetchStreamingFinished),+}++pub(in crate::worker) struct WorkerFetchCompletion {+ pub(super) fetch_id: u32,+ pub(super) network_request_headers: Option<Vec<(String, String)>>,+ pub(super) result: Result<WorkerFetchResponse, String>,+}++pub(in crate::worker) struct WorkerFetchStreamingStarted {+ pub(super) fetch_id: u32,+ pub(super) body_source_id: NetworkBodySourceId,+ pub(super) head: ResponseHead,+ pub(super) network_request_headers: Option<Vec<(String, String)>>,+}++pub(in crate::worker) struct WorkerFetchStreamingChunk {+ pub(super) body_source_id: NetworkBodySourceId,+ pub(super) bytes: Vec<u8>,+}++pub(in crate::worker) struct WorkerFetchStreamingFinished {+ pub(super) fetch_id: u32,+ pub(super) body_source_id: NetworkBodySourceId,+ pub(super) head: ResponseHead,+ pub(super) result: Result<SubresourceResponseBody, String>,+}++pub(in crate::worker) enum WorkerFetchResponse {+ Materialized(Box<Response>),+ Streamed {+ head: Box<ResponseHead>,+ body: SubresourceResponseBody,+ },+}++impl WorkerFetchResponse {+ pub(super) fn head(&self) -> ResponseHead {+ match self {+ Self::Materialized(response) => response.head(),+ Self::Streamed { head, .. } => head.as_ref().clone(),+ }+ }++ pub(super) fn subresource_response_body(&self) -> SubresourceResponseBody {+ match self {+ Self::Materialized(response) => SubresourceResponseBody::from_fetch_response(response),+ Self::Streamed { body, .. } => body.clone(),+ }+ }++ pub(super) fn into_fetch_parts(self) -> WorkerFetchResponseParts {+ match self {+ Self::Materialized(response) => {+ let (head, body) = response.into_body();+ WorkerFetchResponseParts::Materialized {+ head,+ body: Box::new(body),+ }+ }+ Self::Streamed { head, body } => {+ WorkerFetchResponseParts::Subresource { head: *head, body }+ }+ }+ }+}++pub(super) enum WorkerFetchResponseParts {+ Materialized {+ head: ResponseHead,+ body: Box<ResponseBody>,+ },+ Subresource {+ head: ResponseHead,+ body: SubresourceResponseBody,+ },+}++#[derive(Clone)]+pub(in crate::worker) struct PendingWorkerFetchNetworkRecord {+ pub(crate) redirect_headers: Option<moli_fetch::RequestHeaders>,+ pub(in crate::worker) internal_id: u64,+ pub(in crate::worker) url: Url,+ pub(in crate::worker) method: String,+ pub(in crate::worker) request_headers: moli_fetch::RequestHeaders,+ pub(in crate::worker) request_body: Option<String>,+ pub(in crate::worker) initial_network_request_headers: Option<Vec<(String, String)>>,+ pub(in crate::worker) intercept_response: bool,+ pub(in crate::worker) handle_auth_requests: bool,+}++impl PendingWorkerFetchNetworkRecord {+ pub(super) fn follow_redirects(&mut self, head: &ResponseHead) {+ if head.redirect_chain.is_empty() {+ return;+ }+ let mut request = Request::get_with_url(self.url.clone())+ .with_redirect_headers(self.redirect_headers.take());+ request.method = std::mem::take(&mut self.method);+ request.body = self.request_body.clone().map(String::into_bytes);+ request.request_headers = std::mem::take(&mut self.request_headers);+ for redirect in &head.redirect_chain {+ request.apply_redirect_status(redirect.status);+ }+ self.url = head.final_url.clone();+ self.method = request.method;+ self.request_headers = request.request_headers;+ if request.body.is_none() {+ self.request_body = None;+ }+ }+}++pub(in crate::worker) struct PendingWorkerXhr {+ pub(in crate::worker) xhr: v8::Global<v8::Object>,+ pub(in crate::worker) document_url: Url,+ pub(in crate::worker) credentials_mode: RequestCredentialsMode,+ pub(in crate::worker) load: ResourceLoadLease,+ pub(in crate::worker) request_paused: bool,+ pub(in crate::worker) request_url: Url,+ pub(in crate::worker) request_method: String,+ pub(in crate::worker) request_headers: moli_fetch::RequestHeaders,+ pub(in crate::worker) request_body: Option<String>,+ pub(in crate::worker) network_request_handle: Option<SubresourceNetworkRequestHandle>,+ pub(in crate::worker) network_record: Option<PendingWorkerFetchNetworkRecord>,+ pub(in crate::worker) paused_response: Option<PausedWorkerSubresourceResponse>,+}++pub(in crate::worker) struct PendingWorkerCspReport {+ pub(in crate::worker) load: ResourceLoadLease,+ pub(in crate::worker) document_url: Url,+ pub(in crate::worker) request: Request,+ pub(in crate::worker) request_body: Option<String>,+ pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext,+ pub(in crate::worker) service_worker_runtime:+ Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,+ pub(in crate::worker) service_worker_client_id:+ Option<crate::service_worker_runtime::ServiceWorkerClientId>,+}++pub(in crate::worker) struct PausedWorkerSubresourceResponse {+ pub(in crate::worker) head: ResponseHead,+ pub(in crate::worker) body: SubresourceResponseBody,+}++pub(in crate::worker) struct WorkerXhrCompletion {+ pub(in crate::worker) xhr_id: u32,+ pub(in crate::worker) network_request_headers: Option<Vec<(String, String)>>,+ pub(in crate::worker) result: Result<WorkerXhrResponse, String>,+}++pub(in crate::worker) enum WorkerXhrResponse {+ Materialized(Box<Response>),+ Streamed {+ head: Box<ResponseHead>,+ body: SubresourceResponseBody,+ },+}++impl WorkerXhrResponse {+ pub(super) fn head(&self) -> ResponseHead {+ match self {+ Self::Materialized(response) => response.head(),+ Self::Streamed { head, .. } => head.as_ref().clone(),+ }+ }++ pub(super) fn subresource_response_body(&self) -> SubresourceResponseBody {+ match self {+ Self::Materialized(response) => SubresourceResponseBody::from_fetch_response(response),+ Self::Streamed { body, .. } => body.clone(),+ }+ }++ pub(super) fn into_body_source(self) -> Result<(ResponseHead, ResponseBody), String> {+ match self {+ Self::Materialized(response) => Ok(response.into_body()),+ Self::Streamed { head, body } => body+ .materialize_bytes()+ .map(|bytes| (*head, ResponseBody::materialized_bytes(bytes)))+ .map_err(|error| format!("failed to materialize worker XHR body: {error}")),+ }+ }+}++pub(in crate::worker) struct WorkerWebSocketState {+ pub(in crate::worker) wrapper: v8::Global<v8::Object>,+ pub(in crate::worker) connection: WebSocketConnectionHandle,+ pub(in crate::worker) document_url: Url,+ pub(in crate::worker) url: Url,+ pub(in crate::worker) loader: crate::network::context::WorkerResourceLoader,+ pub(in crate::worker) load: Option<ResourceLoadLease>,+ pub(in crate::worker) opened: bool,+ pub(in crate::worker) network_recorded: bool,+}++pub(super) fn next_fetch_id(state: &mut WorkerGlobalState) -> u32 {+ state.next_fetch_id = state+ .next_fetch_id+ .checked_add(1)+ .expect("worker fetch id space exhausted");+ state.next_fetch_id+}++pub(super) fn next_xhr_id(state: &mut WorkerGlobalState) -> u32 {+ state.next_xhr_id = state+ .next_xhr_id+ .checked_add(1)+ .expect("worker XHR id space exhausted");+ state.next_xhr_id+}++pub(super) fn next_websocket_id(state: &mut WorkerGlobalState) -> u64 {+ state.next_websocket_id = state+ .next_websocket_id+ .checked_add(1)+ .expect("worker WebSocket id space exhausted");+ state.next_websocket_id+}++pub(super) fn worker_url_blocked(patterns: &[String], url: &Url) -> bool {+ let value = url.as_str();+ patterns+ .iter()+ .any(|pattern| moli_fetch::url_pattern_matches(pattern, value))+}++pub(super) fn merge_worker_request_headers(+ context_headers: &moli_fetch::RequestHeaders,+ request_headers: &moli_fetch::RequestHeaders,+) -> moli_fetch::RequestHeaders {+ let mut headers = context_headers.clone();+ headers.overlay(request_headers.clone());+ headers+}diff --git a/moli-renderer-v8/src/worker/global_scope/origin.rs b/moli-renderer-v8/src/worker/global_scope/origin.rsnew file mode 100644index 000000000..44f885f21--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/origin.rs@@ -0,0 +1,73 @@+//! Captured worker origin and the replaceable public origin property.++use super::*;++const WORKER_GLOBAL_ORIGIN_SLOT: &str = "__moliWorkerGlobalOrigin";++#[derive(WebApiObject)]+#[webapi(plain)]+pub(super) struct WorkerGlobalOriginDeclaration {+ #[webapi(slot = WORKER_GLOBAL_ORIGIN_SLOT)]+ origin: String,+}++#[derive(Default, WebApiObject)]+#[webapi(fragment, prototype = "WorkerGlobalScope", enumerable)]+pub(super) struct WorkerGlobalOriginPrototypeDeclaration {+ #[webapi(+ accessor_property,+ getter = worker_global_origin_getter,+ setter = worker_global_origin_setter+ )]+ origin: (),+}++fn worker_global_origin_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'s, v8::Value>,+) {+ let global = scope.get_current_context().global(scope);+ if !args.this().strict_equals(global.into()) {+ throw_type_error(scope, "Illegal invocation");+ return;+ }+ let origin = get_private_value(scope, global, WORKER_GLOBAL_ORIGIN_SLOT)+ .unwrap_or_else(|| v8str(scope, "null").into());+ rv.set(origin);+}++fn worker_global_origin_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'s, v8::Value>,+) {+ let global = scope.get_current_context().global(scope);+ if !args.this().strict_equals(global.into()) {+ throw_type_error(scope, "Illegal invocation");+ return;+ }+ // [Replaceable] creates an own data property without converting the value+ // or changing the origin returned by the original getter.+ match global.define_own_property(+ scope,+ v8str(scope, "origin").into(),+ args.get(0),+ v8::PropertyAttribute::NONE,+ ) {+ Some(true) => {}+ Some(false) => throw_type_error(scope, "Cannot redefine WorkerGlobalScope.origin"),+ None => {}+ }+}++pub(crate) fn worker_global_origin(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<moli_url::WebOrigin> {+ let global = scope.get_current_context().global(scope);+ let origin = get_private_value(scope, global, WORKER_GLOBAL_ORIGIN_SLOT)?;+ let origin = v8::Local::<v8::String>::try_from(origin).ok()?;+ Some(moli_url::WebOrigin::from_serialized(+ &origin.to_rust_string_lossy(scope),+ ))+}diff --git a/moli-renderer-v8/src/worker/global_scope/performance.rs b/moli-renderer-v8/src/worker/global_scope/performance.rsnew file mode 100644index 000000000..a0dd296a1--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/performance.rs@@ -0,0 +1,62 @@+//! Worker performance clock and time origin.++use super::*;++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerGlobalPerformanceDeclaration<'scope> {+ #[webapi(data_property)]+ performance: v8::Local<'scope, v8::Object>,+}++#[derive(WebApiObject)]+#[webapi(prototype = "Object", interface = web_api_interfaces::Performance)]+struct WorkerPerformanceObjectDeclaration {+ #[webapi(data_property, readonly)]+ time_origin: f64,+ #[webapi(method, callback = worker_performance_now_callback, data = self.time_origin)]+ now: (),+}++pub(super) fn install_worker_performance<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ global: v8::Local<'s, v8::Object>,+) -> Result<()> {+ let time_origin = monotonic_unix_epoch_millis();+ let performance = WorkerPerformanceObjectDeclaration::new(time_origin)+ .bind(scope)+ .map_err(|error| anyhow!("failed to create worker performance: {error}"))?;+ WorkerGlobalPerformanceDeclaration::new(performance)+ .initialize(scope, global)+ .map_err(|error| anyhow!("failed to initialize worker performance: {error}"))+}++fn worker_performance_now_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let time_origin = args.data().number_value(scope).unwrap_or(0.0);+ rv.set(+ v8::Number::new(+ scope,+ moli_time::coarsened_dom_time_millis(+ (monotonic_unix_epoch_millis() - time_origin).max(0.0),+ ),+ )+ .into(),+ );+}++fn unix_epoch_millis() -> f64 {+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .map(|duration| duration.as_secs_f64() * 1000.0)+ .unwrap_or(0.0)+}++pub(super) fn monotonic_unix_epoch_millis() -> f64 {+ static BASE: OnceLock<(f64, Instant)> = OnceLock::new();+ let (epoch_millis, instant) = BASE.get_or_init(|| (unix_epoch_millis(), Instant::now()));+ epoch_millis + instant.elapsed().as_secs_f64() * 1000.0+}diff --git a/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs b/moli-renderer-v8/src/worker/global_scope/service_worker_api.rsindex d6894e5ff..d9f27e404 100644--- a/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs+++ b/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs@@ -1827,3 +1827,319 @@ pub(super) fn service_worker_window_client_navigate_callback<'s>(fn service_worker_window_client_can_display_url(url: &Url) -> bool {matches!(url.scheme(), "http" | "https")}++const SERVICE_WORKER_REGISTRATION_SCOPE_SLOT: &str = "__moliServiceWorkerRegistrationScope";++const SERVICE_WORKER_REGISTRATION_ID_SLOT: &str = "__moliServiceWorkerRegistrationId";++pub(super) const SERVICE_WORKER_VERSION_ID_SLOT: &str = "__moliServiceWorkerVersionId";++const SERVICE_WORKER_WORKER_EVENTS_SLOT: &str = "__moliServiceWorkerWorkerEvents";++const SERVICE_WORKER_NAVIGATION_PRELOAD_MANAGER_SCOPE_SLOT: &str =+ "__moliServiceWorkerNavigationPreloadManagerScope";++pub(super) const SERVICE_WORKER_CLIENT_ID_SLOT: &str = "__lmServiceWorkerClientId";++#[derive(Default, WebApiObject)]+#[webapi(interface = web_api_interfaces::Clients, prototype = "Object")]+struct ServiceWorkerClientsDeclaration {+ #[webapi(method, callback = service_worker_clients_claim_callback, length = 0)]+ claim: (),+ #[webapi(method, callback = service_worker_clients_get_callback, length = 1)]+ get: (),+ #[webapi(+ method = "matchAll",+ callback = service_worker_clients_match_all_callback,+ length = 0+ )]+ match_all: (),+ #[webapi(+ method = "openWindow",+ callback = service_worker_clients_open_window_callback,+ length = 1+ )]+ open_window: (),+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct ServiceWorkerGlobalRuntimeDeclaration<'scope> {+ #[webapi(data_property, readonly)]+ registration: v8::Local<'scope, v8::Object>,+ #[webapi(data_property, readonly)]+ clients: v8::Local<'scope, v8::Object>,+ #[webapi(method = "skipWaiting", callback = service_worker_skip_waiting_callback, length = 0)]+ skip_waiting: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::ServiceWorkerRegistration,)]+struct ServiceWorkerGlobalRegistrationDeclaration<'scope> {+ #[webapi(data_property, readonly)]+ scope: String,++ #[webapi(+ accessor_property = "installing",+ getter = service_worker_registration_installing_getter+ )]+ installing: (),++ #[webapi(+ accessor_property = "waiting",+ getter = service_worker_registration_waiting_getter+ )]+ waiting: (),++ #[webapi(+ accessor_property = "active",+ getter = service_worker_registration_active_getter+ )]+ active: (),++ #[webapi(method, callback = service_worker_registration_unregister_callback, length = 0)]+ unregister: (),++ #[webapi(+ method = "showNotification",+ callback = service_worker_registration_show_notification_callback,+ length = 1+ )]+ show_notification: (),++ #[webapi(+ method = "getNotifications",+ callback = service_worker_registration_get_notifications_callback,+ length = 0+ )]+ get_notifications: (),++ #[webapi(data_property, readonly)]+ sync: v8::Local<'scope, v8::Object>,++ #[webapi(data_property = "periodicSync", readonly)]+ periodic_sync: v8::Local<'scope, v8::Object>,++ #[webapi(data_property = "pushManager", readonly)]+ push_manager: v8::Local<'scope, v8::Object>,++ #[webapi(data_property = "navigationPreload", readonly)]+ navigation_preload: v8::Local<'scope, v8::Object>,+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::ServiceWorker,)]+struct ServiceWorkerGlobalServiceWorkerDeclaration {+ #[webapi(data_property = "scriptURL", readonly)]+ script_url: String,++ #[webapi(data_property, readonly)]+ state: String,++ #[webapi(method = "postMessage", callback = service_worker_worker_post_message_callback, length = 1)]+ post_message: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::SyncManager)]+struct ServiceWorkerGlobalSyncManagerDeclaration {+ #[webapi(+ method = "register",+ callback = service_worker_sync_manager_register_callback,+ length = 1+ )]+ register: (),++ #[webapi(+ method = "getTags",+ callback = service_worker_sync_manager_get_tags_callback,+ length = 0+ )]+ get_tags: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::PeriodicSyncManager)]+struct ServiceWorkerGlobalPeriodicSyncManagerDeclaration {+ #[webapi(+ method = "register",+ callback = service_worker_periodic_sync_manager_register_callback,+ length = 1+ )]+ register: (),++ #[webapi(+ method = "getTags",+ callback = service_worker_periodic_sync_manager_get_tags_callback,+ length = 0+ )]+ get_tags: (),++ #[webapi(+ method = "unregister",+ callback = service_worker_periodic_sync_manager_unregister_callback,+ length = 1+ )]+ unregister: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::PushManager)]+struct ServiceWorkerGlobalPushManagerDeclaration {+ #[webapi(+ method = "subscribe",+ callback = service_worker_push_manager_subscribe_callback,+ length = 0+ )]+ subscribe: (),++ #[webapi(+ method = "getSubscription",+ callback = service_worker_push_manager_get_subscription_callback,+ length = 0+ )]+ get_subscription: (),++ #[webapi(+ method = "permissionState",+ callback = service_worker_push_manager_permission_state_callback,+ length = 0+ )]+ permission_state: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::NavigationPreloadManager)]+struct ServiceWorkerGlobalNavigationPreloadManagerDeclaration {+ #[webapi(+ method,+ callback = service_worker_navigation_preload_manager_enable_callback,+ length = 0+ )]+ enable: (),++ #[webapi(+ method,+ callback = service_worker_navigation_preload_manager_disable_callback,+ length = 0+ )]+ disable: (),++ #[webapi(+ method = "setHeaderValue",+ callback = service_worker_navigation_preload_manager_set_header_value_callback,+ length = 1+ )]+ set_header_value: (),++ #[webapi(+ method = "getState",+ callback = service_worker_navigation_preload_manager_get_state_callback,+ length = 0+ )]+ get_state: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::PushSubscription)]+struct ServiceWorkerPushSubscriptionDeclaration<'scope> {+ #[webapi(data_property, readonly)]+ endpoint: String,++ #[webapi(data_property = "expirationTime", readonly)]+ expiration_time: v8::Local<'scope, v8::Value>,++ #[webapi(data_property, readonly)]+ options: v8::Local<'scope, v8::Object>,++ #[webapi(method, callback = service_worker_push_subscription_unsubscribe_callback, length = 0)]+ unsubscribe: (),++ #[webapi(+ method = "toJSON",+ callback = service_worker_push_subscription_to_json_callback,+ length = 0+ )]+ to_json: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::PushSubscriptionOptions, prototype = "Object")]+struct ServiceWorkerPushSubscriptionOptionsDeclaration<'scope> {+ #[webapi(data_property = "userVisibleOnly", readonly)]+ user_visible_only: bool,++ #[webapi(data_property = "applicationServerKey", readonly)]+ application_server_key: v8::Local<'scope, v8::Value>,+}++#[derive(WebApiObject)]+#[webapi(plain)]+struct WorkerNavigationPreloadStateDeclaration {+ #[webapi(data_property, enumerable)]+ enabled: bool,++ #[webapi(data_property = "headerValue", enumerable)]+ header_value: String,+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::Client)]+pub(in crate::worker) struct ServiceWorkerBaseClientDeclaration<'scope> {+ #[webapi(data_property, readonly)]+ id: String,++ #[webapi(data_property, readonly)]+ url: v8::Local<'scope, v8::String>,++ #[webapi(data_property = "type", readonly)]+ client_type: &'static str,++ #[webapi(method = "postMessage", callback = service_worker_client_post_message_callback, length = 1)]+ post_message: (),+}++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::WindowClient)]+pub(in crate::worker) struct ServiceWorkerWindowClientDeclaration<'scope> {+ #[webapi(data_property, readonly)]+ id: String,++ #[webapi(data_property, readonly)]+ url: v8::Local<'scope, v8::String>,++ #[webapi(data_property = "type", readonly)]+ client_type: &'static str,++ #[webapi(data_property = "frameType", readonly)]+ frame_type: &'static str,++ #[webapi(data_property = "lifecycleState", readonly)]+ lifecycle_state: &'static str,++ #[webapi(data_property = "visibilityState", readonly)]+ visibility_state: &'static str,++ #[webapi(data_property, readonly)]+ focused: bool,++ #[webapi(method = "postMessage", callback = service_worker_client_post_message_callback, length = 1)]+ post_message: (),++ #[webapi(method, callback = service_worker_window_client_focus_callback, length = 0)]+ focus: (),++ #[webapi(method, callback = service_worker_window_client_navigate_callback, length = 1)]+ navigate: (),+}++#[derive(Default, webidl::WebIdlDictionary)]+#[webidl(prefix = "BackgroundSyncOptions")]+struct BackgroundSyncOptions {+ #[webidl(+ name = "minInterval",+ converter = "enforce_range_unsigned_long_long",+ default = 0+ )]+ min_interval: u64,+}diff --git a/moli-renderer-v8/src/worker/global_scope/service_worker_results.rs b/moli-renderer-v8/src/worker/global_scope/service_worker_results.rsnew file mode 100644index 000000000..091681a72--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/service_worker_results.rs@@ -0,0 +1,908 @@+//! Service Worker API request ids, pending promises and result delivery.++use super::*;++pub(in crate::worker) struct PendingServiceWorkerClientQuery {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+ pub(in crate::worker) query_type: PendingServiceWorkerClientQueryType,+}++pub(in crate::worker) struct PendingServiceWorkerClientNavigate {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerClientFocus {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerClientsOpenWindow {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerShowNotification {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerGetNotifications {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerSyncRegistration {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerSyncGetTags {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncRegistration {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncGetTags {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncUnregistration {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPushSubscribe {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPushGetSubscription {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++pub(in crate::worker) struct PendingServiceWorkerPushUnsubscribe {+ pub(in crate::worker) resolver: v8::Global<v8::PromiseResolver>,+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(in crate::worker) enum PendingServiceWorkerClientQueryType {+ Get,+ MatchAll,+}++/// Checked allocator for one operation-local Service Worker request namespace.+///+/// The parent/worker protocol intentionally gives each operation its own+/// namespace. Keeping that shape avoids coupling unrelated APIs while making+/// exhaustion fail instead of overwriting a live pending resolver.+#[derive(Debug)]+pub(in crate::worker) struct WorkerServiceWorkerRequestIdAllocator {+ next: u64,+}++impl Default for WorkerServiceWorkerRequestIdAllocator {+ fn default() -> Self {+ Self { next: 1 }+ }+}++impl WorkerServiceWorkerRequestIdAllocator {+ fn allocate(&mut self) -> u64 {+ let request_id = self.next;+ self.next = request_id+ .checked_add(1)+ .expect("worker Service Worker request id space exhausted");+ request_id+ }+}++impl WorkerGlobalState {+ pub(in crate::worker) fn register_pending_service_worker_client_query(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ query_type: PendingServiceWorkerClientQueryType,+ ) -> u64 {+ let request_id = self.service_worker_client_query_request_ids.allocate();+ self.pending_service_worker_client_queries.insert(+ request_id,+ PendingServiceWorkerClientQuery {+ resolver,+ query_type,+ },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_client_query(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerClientQuery> {+ self.pending_service_worker_client_queries+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_client_navigate(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_client_navigate_request_ids.allocate();+ self.pending_service_worker_client_navigates+ .insert(request_id, PendingServiceWorkerClientNavigate { resolver });+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_client_navigate(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerClientNavigate> {+ self.pending_service_worker_client_navigates+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_client_focus(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_client_focus_request_ids.allocate();+ self.pending_service_worker_client_focuses+ .insert(request_id, PendingServiceWorkerClientFocus { resolver });+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_client_focus(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerClientFocus> {+ self.pending_service_worker_client_focuses+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_clients_open_window(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_clients_open_window_request_ids+ .allocate();+ self.pending_service_worker_clients_open_windows.insert(+ request_id,+ PendingServiceWorkerClientsOpenWindow { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_clients_open_window(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerClientsOpenWindow> {+ self.pending_service_worker_clients_open_windows+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_show_notification(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_show_notification_request_ids.allocate();+ self.pending_service_worker_show_notifications.insert(+ request_id,+ PendingServiceWorkerShowNotification { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_show_notification(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerShowNotification> {+ self.pending_service_worker_show_notifications+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_get_notifications(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_get_notifications_request_ids.allocate();+ self.pending_service_worker_get_notifications.insert(+ request_id,+ PendingServiceWorkerGetNotifications { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_get_notifications(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerGetNotifications> {+ self.pending_service_worker_get_notifications+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_sync_registration(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_sync_registration_request_ids.allocate();+ self.pending_service_worker_sync_registrations.insert(+ request_id,+ PendingServiceWorkerSyncRegistration { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_sync_registration(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerSyncRegistration> {+ self.pending_service_worker_sync_registrations+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_sync_get_tags(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_sync_get_tags_request_ids.allocate();+ self.pending_service_worker_sync_get_tags+ .insert(request_id, PendingServiceWorkerSyncGetTags { resolver });+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_sync_get_tags(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerSyncGetTags> {+ self.pending_service_worker_sync_get_tags+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_periodic_sync_registration(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_periodic_sync_registration_request_ids+ .allocate();+ self.pending_service_worker_periodic_sync_registrations+ .insert(+ request_id,+ PendingServiceWorkerPeriodicSyncRegistration { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_periodic_sync_registration(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPeriodicSyncRegistration> {+ self.pending_service_worker_periodic_sync_registrations+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_periodic_sync_get_tags(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_periodic_sync_get_tags_request_ids+ .allocate();+ self.pending_service_worker_periodic_sync_get_tags.insert(+ request_id,+ PendingServiceWorkerPeriodicSyncGetTags { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_periodic_sync_get_tags(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPeriodicSyncGetTags> {+ self.pending_service_worker_periodic_sync_get_tags+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_periodic_sync_unregistration(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_periodic_sync_unregistration_request_ids+ .allocate();+ self.pending_service_worker_periodic_sync_unregistrations+ .insert(+ request_id,+ PendingServiceWorkerPeriodicSyncUnregistration { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_periodic_sync_unregistration(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPeriodicSyncUnregistration> {+ self.pending_service_worker_periodic_sync_unregistrations+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_push_subscribe(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self.service_worker_push_subscription_request_ids.allocate();+ self.pending_service_worker_push_subscriptions+ .insert(request_id, PendingServiceWorkerPushSubscribe { resolver });+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_push_subscribe(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPushSubscribe> {+ self.pending_service_worker_push_subscriptions+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_push_get_subscription(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_push_get_subscription_request_ids+ .allocate();+ self.pending_service_worker_push_get_subscriptions.insert(+ request_id,+ PendingServiceWorkerPushGetSubscription { resolver },+ );+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_push_get_subscription(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPushGetSubscription> {+ self.pending_service_worker_push_get_subscriptions+ .remove(&request_id)+ }++ pub(in crate::worker) fn register_pending_service_worker_push_unsubscribe(+ &mut self,+ resolver: v8::Global<v8::PromiseResolver>,+ ) -> u64 {+ let request_id = self+ .service_worker_push_unsubscription_request_ids+ .allocate();+ self.pending_service_worker_push_unsubscriptions+ .insert(request_id, PendingServiceWorkerPushUnsubscribe { resolver });+ request_id+ }++ pub(in crate::worker) fn take_pending_service_worker_push_unsubscribe(+ &mut self,+ request_id: u64,+ ) -> Option<PendingServiceWorkerPushUnsubscribe> {+ self.pending_service_worker_push_unsubscriptions+ .remove(&request_id)+ }++ pub(in crate::worker) fn consume_service_worker_window_interaction(&mut self) -> bool {+ if self.service_worker_window_interaction_allowed_count == 0 {+ return false;+ }++ self.service_worker_window_interaction_allowed_count = self+ .service_worker_window_interaction_allowed_count+ .saturating_sub(1);++ if let Some((_, pending)) = self+ .pending_service_worker_message_events+ .iter_mut()+ .find(|(_, pending)| pending.window_interaction_allowed)+ {+ pending.window_interaction_allowed = false;+ return true;+ }++ if let Some((_, pending)) = self+ .pending_service_worker_notification_events+ .iter_mut()+ .find(|(_, pending)| pending.window_interaction_allowed)+ {+ pending.window_interaction_allowed = false;+ }++ true+ }+}++pub(in crate::worker) fn drain_service_worker_client_query_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerClientQueryResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_client_query(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match pending.query_type {+ PendingServiceWorkerClientQueryType::Get => {+ let value = result+ .clients+ .into_iter()+ .next()+ .and_then(|client| build_service_worker_client_object_from_snapshot(scope, &client))+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::undefined(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ PendingServiceWorkerClientQueryType::MatchAll => {+ let array = v8::Array::new(scope, result.clients.len() as i32);+ for (index, client) in result.clients.iter().enumerate() {+ if let Some(object) =+ build_service_worker_client_object_from_snapshot(scope, client)+ {+ let _ = array.set_index(scope, index as u32, object.into());+ }+ }+ let _ = resolver.resolve(scope, array.into());+ }+ }+}++pub(in crate::worker) fn drain_service_worker_client_navigate_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerClientNavigateResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_client_navigate(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(Some(client)) => {+ let value = build_service_worker_client_object_from_snapshot(scope, &client)+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::null(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ Ok(None) => {+ let _ = resolver.resolve(scope, v8::null(scope).into());+ }+ Err(error) => match error {+ ServiceWorkerClientNavigateError::TypeError(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ },+ }+}++pub(in crate::worker) fn drain_service_worker_client_focus_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: crate::runtime::ServiceWorkerClientFocusResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_client_focus(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(client) => {+ let value = build_service_worker_client_object_from_snapshot(scope, &client)+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::null(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ Err(error) => {+ reject_service_worker_client_focus_error(scope, resolver, error);+ }+ }+}++fn reject_service_worker_client_focus_error<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ resolver: v8::Local<'s, v8::PromiseResolver>,+ error: ServiceWorkerClientFocusError,+) {+ match error {+ ServiceWorkerClientFocusError::DomException { name, message } => {+ let reason = worker_dom_exception_value(scope, &message, name);+ let _ = resolver.reject(scope, reason);+ }+ ServiceWorkerClientFocusError::TypeError(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let reason = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, reason);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_clients_open_window_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerClientsOpenWindowResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) =+ state.take_pending_service_worker_clients_open_window(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(Some(client)) => {+ let value = build_service_worker_client_object_from_snapshot(scope, &client)+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::null(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ Ok(None) => {+ let _ = resolver.resolve(scope, v8::null(scope).into());+ }+ Err(error) => match error {+ ServiceWorkerClientsOpenWindowError::TypeError(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ },+ }+}++pub(in crate::worker) fn drain_service_worker_show_notification_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerShowNotificationResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_show_notification(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(()) => {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_get_notifications_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerGetNotificationsResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_get_notifications(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ let notifications = match result.result {+ Ok(notifications) => notifications,+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ return;+ }+ };+ let array = v8::Array::new(scope, notifications.len() as i32);+ for (index, notification) in notifications.iter().enumerate() {+ if let Some(object) =+ crate::context_bootstrap::build_notification_object_from_snapshot(scope, notification)+ {+ let _ = array.set_index(scope, index as u32, object.into());+ }+ }+ let _ = resolver.resolve(scope, array.into());+}++pub(in crate::worker) fn drain_service_worker_sync_registration_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerSyncRegistrationResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_sync_registration(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(()) => {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_sync_get_tags_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerSyncGetTagsResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_sync_get_tags(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(tags) => {+ let array = v8::Array::new(scope, tags.len() as i32);+ for (index, tag) in tags.iter().enumerate() {+ if let Some(value) = v8_string(scope, tag) {+ let _ = array.set_index(scope, index as u32, value.into());+ }+ }+ let _ = resolver.resolve(scope, array.into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_periodic_sync_registration_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: crate::runtime::ServiceWorkerPeriodicSyncRegistrationResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) =+ state.take_pending_service_worker_periodic_sync_registration(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(()) => {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_periodic_sync_get_tags_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: crate::runtime::ServiceWorkerPeriodicSyncGetTagsResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) =+ state.take_pending_service_worker_periodic_sync_get_tags(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(tags) => {+ let array = v8::Array::new(scope, tags.len() as i32);+ for (index, tag) in tags.iter().enumerate() {+ if let Some(value) = v8_string(scope, tag) {+ let _ = array.set_index(scope, index as u32, value.into());+ }+ }+ let _ = resolver.resolve(scope, array.into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_periodic_sync_unregistration_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: crate::runtime::ServiceWorkerPeriodicSyncUnregistrationResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) =+ state.take_pending_service_worker_periodic_sync_unregistration(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(()) => {+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_push_subscribe_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerPushSubscribeResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_push_subscribe(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(subscription) => {+ let value = build_service_worker_push_subscription_object(scope, &subscription)+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::null(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_push_get_subscription_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerPushGetSubscriptionResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) =+ state.take_pending_service_worker_push_get_subscription(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(Some(subscription)) => {+ let value = build_service_worker_push_subscription_object(scope, &subscription)+ .map(v8::Local::into)+ .unwrap_or_else(|| v8::null(scope).into());+ let _ = resolver.resolve(scope, value);+ }+ Ok(None) => {+ let _ = resolver.resolve(scope, v8::null(scope).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++pub(in crate::worker) fn drain_service_worker_push_unsubscribe_result(+ scope: &mut v8::PinScope<'_, '_>,+ state: &Rc<RefCell<WorkerGlobalState>>,+ result: ServiceWorkerPushUnsubscribeResult,+) {+ let pending = {+ let mut state = state.borrow_mut();+ let Some(pending) = state.take_pending_service_worker_push_unsubscribe(result.request_id)+ else {+ return;+ };+ pending+ };+ let resolver = v8::Local::new(scope, &pending.resolver);+ match result.result {+ Ok(unsubscribed) => {+ let _ = resolver.resolve(scope, v8::Boolean::new(scope, unsubscribed).into());+ }+ Err(message) => {+ let Some(message) = v8_string(scope, &message) else {+ let _ = resolver.reject(scope, v8::undefined(scope).into());+ return;+ };+ let error = v8::Exception::type_error(scope, message);+ let _ = resolver.reject(scope, error);+ }+ }+}++#[cfg(test)]+mod service_worker_request_id_allocator_tests {+ use super::WorkerServiceWorkerRequestIdAllocator;++ #[test]+ #[should_panic(expected = "worker Service Worker request id space exhausted")]+ fn operation_local_request_ids_never_wrap() {+ let mut ids = WorkerServiceWorkerRequestIdAllocator { next: u64::MAX };+ let _ = ids.allocate();+ }+}diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rsnew file mode 100644index 000000000..ff8ed6881--- /dev/null+++ b/moli-renderer-v8/src/worker/global_scope/state.rs@@ -0,0 +1,323 @@+//! WorkerGlobalScope runtime state and native queries for the current worker.++use super::*;++pub(crate) const WORKER_STATE_SLOT: &str = "__workerState";++pub(crate) struct WorkerGlobalState {+ /// Weak handles and native cleanups owned by this worker isolate. Worker+ /// teardown clears this registry before `OwnedIsolate` is destroyed.+ pub(crate) v8_finalizers: crate::v8_finalizer::V8FinalizerRegistry,+ /// Channel to send messages back to the parent.+ pub(in crate::worker) parent_tx: mpsc::UnboundedSender<WorkerToParentMessage>,+ /// Internal wake channel used by worker-owned async runtime surfaces.+ pub(crate) worker_wake_tx: mpsc::UnboundedSender<crate::worker::handle::WorkerMessage>,+ /// Shared lifecycle bit published by `Worker.terminate()` before V8 is+ /// interrupted. Worker-side task delivery must not rely on cross-thread+ /// timing between that interrupt and already-selected work.+ pub(crate) termination_requested: Arc<AtomicBool>,+ /// Whether `close()` has been called.+ pub(in crate::worker) closed: bool,+ /// HTML's per-global guard against recursively reporting an error event.+ pub(in crate::worker) in_error_reporting_mode: bool,+ /// Timer id counter.+ pub(in crate::worker) next_timer_id: u32,+ /// Inside-settings resource authority for every request owned by this+ /// WorkerGlobalScope. Even data/blob workers retain the creator's browser+ /// backend so later fetch/XHR/module/WebSocket work has an exact owner.+ pub(in crate::worker) loader: crate::network::context::WorkerResourceLoader,+ /// Whether this runtime is a dedicated or shared worker global.+ pub(in crate::worker) global_kind: crate::worker::thread::WorkerGlobalKind,+ /// Whether this worker was constructed as a classic or module worker.+ pub(in crate::worker) script_kind: crate::worker::thread::WorkerScriptKind,+ /// Base URL used to resolve relative worker script fetches.+ pub(in crate::worker) current_script_url: Option<Url>,+ /// Referrer policy parsed from the top-level worker script response.+ pub(in crate::worker) referrer_policy: Option<String>,+ /// CSP policies from outside settings used for module static imports.+ pub(in crate::worker) module_static_import_content_security_policies: Vec<String>,+ /// Enforce CSP policies parsed from the top-level worker script response.+ pub(in crate::worker) content_security_policies: Vec<String>,+ /// Report-only CSP policies parsed from the top-level worker script response.+ pub(in crate::worker) content_security_report_only_policies: Vec<String>,+ /// Reporting API endpoints parsed from the top-level worker script response.+ pub(in crate::worker) content_security_reporting_endpoints:+ ContentSecurityPolicyReportingEndpoints,+ /// Whether this worker global is a secure context for `[SecureContext]` APIs.+ pub(in crate::worker) secure_context: bool,+ /// Network.setExtraHTTPHeaders headers inherited from the owning page/CDP session.+ pub(in crate::worker) extra_http_headers: moli_fetch::RequestHeaders,+ /// Permission overrides inherited from the owning page/CDP session.+ pub(in crate::worker) permission_overrides:+ Vec<crate::protocol_types::PermissionOverrideRegistration>,+ /// Network.emulateNetworkConditions offline state inherited from the owning page/CDP session.+ pub(in crate::worker) network_offline: bool,+ /// Network.setBlockedURLs patterns inherited from the owning page/CDP session.+ pub(in crate::worker) blocked_url_patterns: Vec<String>,+ /// Current document network/cache partition key inherited by worker-owned requests.+ pub(in crate::worker) network_partition_key: Option<String>,+ /// COEP/DIP policy container state inherited by worker-owned subresource requests.+ pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext,+ /// Fetch domain subresource interception inherited from the owning page/CDP session.+ pub(in crate::worker) fetch_subresource_interception_enabled: bool,+ pub(in crate::worker) fetch_subresource_interception_resource_type:+ Option<SubresourceResourceType>,+ /// Async fetch completions routed back onto the worker event loop.+ pub(in crate::worker) fetch_completion_tx: mpsc::UnboundedSender<WorkerFetchEvent>,+ /// Promise resolvers pending async fetch completion.+ pub(in crate::worker) pending_fetches: HashMap<u32, PendingWorkerFetch>,+ /// Worker-local pending body sources for headers-first worker fetch.+ pub(crate) pending_network_body_sources:+ HashMap<NetworkBodySourceId, crate::network_host::PendingNetworkBodySourceState>,+ pub(crate) pending_network_body_clones: HashMap<NetworkBodySourceId, Vec<NetworkBodySourceId>>,+ /// Fetch id counter.+ pub(in crate::worker) next_fetch_id: u32,+ /// Async XHR completions routed back onto the worker event loop.+ pub(in crate::worker) xhr_completion_tx: mpsc::UnboundedSender<WorkerXhrCompletion>,+ /// In-flight worker XHR requests keyed by internal id.+ pub(in crate::worker) pending_xhrs: HashMap<u32, PendingWorkerXhr>,+ /// Worker XHR id counter.+ pub(in crate::worker) next_xhr_id: u32,+ /// Worker-owned CSP report requests paused for Fetch domain request-stage interception.+ pub(in crate::worker) pending_csp_reports: HashMap<u32, PendingWorkerCspReport>,+ /// Worker-local TextDecoder state. TextEncoder is stateless, but TextDecoder+ /// can stream and needs decoder state tied to this worker's isolate.+ pub(crate) text_codecs: TextCodecStore,+ /// Worker-local AbortController/AbortSignal runtime state.+ pub(in crate::worker) abort: Rc<RefCell<WorkerAbortStore>>,+ /// Worker-thread view of the creator's browser-context/partition runtime.+ pub(in crate::worker) worker_context_runtime: crate::runtime::RendererWorkerContextRuntime,+ /// Browser-context Service Worker owner inherited by real worker clients.+ pub(in crate::worker) service_worker_runtime:+ Option<crate::service_worker_runtime::ServiceWorkerRuntimeService>,+ /// Live Service Worker client id for DedicatedWorker/SharedWorker globals.+ pub(in crate::worker) service_worker_client_id:+ Option<crate::service_worker_runtime::ServiceWorkerClientId>,+ /// Owner-scoped MessagePort state shared with page and nested worker contexts.+ pub(in crate::worker) message_port_registry: SharedMessagePortRegistry,+ /// Worker-owned MessagePort wrappers keyed by runtime port id.+ pub(in crate::worker) message_port_wrappers:+ HashMap<MessagePortId, WorkerMessagePortWrapperEntry>,+ /// SharedWorker connect-event ports whose lifetime is owned by the shared worker runtime.+ pub(in crate::worker) shared_worker_connection_ports: HashSet<MessagePortId>,+ /// Worker-owned BroadcastChannel wrappers keyed by runtime channel id.+ pub(in crate::worker) broadcast_channel_registry: SharedBroadcastChannelRegistry,+ pub(in crate::worker) broadcast_channel_storage_key: MoliStorageKey,+ pub(in crate::worker) storage_key: MoliStorageKey,+ pub(in crate::worker) broadcast_channel_wrappers:+ HashMap<BroadcastChannelId, v8::Global<v8::Object>>,+ /// IndexedDB storage manager inherited from the owning browser context.+ pub(in crate::worker) indexed_db_manager:+ Option<crate::context_bootstrap::WeakIndexedDbManager>,+ /// Storage Buckets registry inherited from the owning browser context.+ pub(in crate::worker) storage_bucket_store:+ Option<crate::context_bootstrap::SharedStorageBucketStore>,+ /// Async WebSocket transport events routed back onto this worker loop.+ pub(in crate::worker) websocket_event_tx: tokio::sync::mpsc::Sender<WebSocketEvent>,+ /// Worker-owned classic WebSocket connections keyed by socket id.+ pub(in crate::worker) websockets: HashMap<u64, WorkerWebSocketState>,+ /// Worker-local WebSocket id counter.+ pub(in crate::worker) next_websocket_id: u64,+ /// Worker-local dedicated workers created through `new Worker(...)`.+ pub(in crate::worker) next_nested_worker_id: u64,+ pub(in crate::worker) nested_worker_wrappers:+ HashMap<DedicatedWorkerId, v8::Global<v8::Object>>,+ /// Heavyweight WebCrypto completions routed back onto the worker event loop.+ pub(in crate::worker) webcrypto_completion_tx: mpsc::UnboundedSender<WorkerWebCryptoCompletion>,+ /// In-flight worker WebCrypto blocking tasks keyed by task id.+ pub(in crate::worker) pending_webcrypto: HashMap<u64, PendingWorkerWebCryptoTask>,+ /// Worker WebCrypto task id counter (never zero so 0 can mean "unset").+ pub(in crate::worker) next_webcrypto_task_id: u64,+ /// OPFS completions routed from the partition-owned storage IO sequence.+ pub(in crate::worker) opfs_completion_tx: mpsc::UnboundedSender<WorkerOpfsCompletion>,+ pub(in crate::worker) opfs_owner_state: Option<WorkerOpfsOwnerState>,+ /// In-flight Service Worker `periodicsync` events keyed by runtime event id.+ pub(in crate::worker) pending_service_worker_periodic_sync_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerPeriodicSyncEvent>,+ /// In-flight Service Worker `clients.get()` / `clients.matchAll()` queries keyed by request id.+ pub(in crate::worker) pending_service_worker_client_queries:+ HashMap<u64, PendingServiceWorkerClientQuery>,+ /// In-flight Service Worker `WindowClient.navigate()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_client_navigates:+ HashMap<u64, PendingServiceWorkerClientNavigate>,+ /// In-flight Service Worker `WindowClient.focus()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_client_focuses:+ HashMap<u64, PendingServiceWorkerClientFocus>,+ /// In-flight Service Worker `clients.openWindow()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_clients_open_windows:+ HashMap<u64, PendingServiceWorkerClientsOpenWindow>,+ /// In-flight Service Worker `registration.showNotification()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_show_notifications:+ HashMap<u64, PendingServiceWorkerShowNotification>,+ /// In-flight Service Worker `registration.getNotifications()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_get_notifications:+ HashMap<u64, PendingServiceWorkerGetNotifications>,+ /// In-flight Service Worker `registration.sync.register()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_sync_registrations:+ HashMap<u64, PendingServiceWorkerSyncRegistration>,+ /// In-flight Service Worker `registration.sync.getTags()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_sync_get_tags:+ HashMap<u64, PendingServiceWorkerSyncGetTags>,+ /// In-flight Service Worker `registration.periodicSync.register()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_periodic_sync_registrations:+ HashMap<u64, PendingServiceWorkerPeriodicSyncRegistration>,+ /// In-flight Service Worker `registration.periodicSync.getTags()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_periodic_sync_get_tags:+ HashMap<u64, PendingServiceWorkerPeriodicSyncGetTags>,+ /// In-flight Service Worker `registration.periodicSync.unregister()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_periodic_sync_unregistrations:+ HashMap<u64, PendingServiceWorkerPeriodicSyncUnregistration>,+ /// In-flight Service Worker `registration.pushManager.subscribe()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_push_subscriptions:+ HashMap<u64, PendingServiceWorkerPushSubscribe>,+ /// In-flight Service Worker `registration.pushManager.getSubscription()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_push_get_subscriptions:+ HashMap<u64, PendingServiceWorkerPushGetSubscription>,+ /// In-flight Service Worker `PushSubscription.unsubscribe()` requests keyed by request id.+ pub(in crate::worker) pending_service_worker_push_unsubscriptions:+ HashMap<u64, PendingServiceWorkerPushUnsubscribe>,+ pub(in crate::worker) service_worker_client_query_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_client_navigate_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_client_focus_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_clients_open_window_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_show_notification_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_get_notifications_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_sync_registration_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_sync_get_tags_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_periodic_sync_registration_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_periodic_sync_get_tags_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_periodic_sync_unregistration_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_push_subscription_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_push_get_subscription_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ pub(in crate::worker) service_worker_push_unsubscription_request_ids:+ WorkerServiceWorkerRequestIdAllocator,+ /// Count of active Service Worker events that allow window interaction.+ pub(in crate::worker) service_worker_window_interaction_allowed_count: usize,+ /// Service Worker lifecycle events currently waiting for dispatch and+ /// `ExtendableEvent.waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_lifecycle_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerLifecycleEvent>,+ /// Service Worker fetch events currently waiting for dispatch, `respondWith()`,+ /// and minimal `waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_fetch_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerFetchEvent>,+ /// Navigation preload promises and response bodies stay alive until preload complete/error.+ pub(in crate::worker) pending_service_worker_navigation_preloads:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerNavigationPreload>,+ /// Service Worker message events currently waiting for dispatch and+ /// `ExtendableEvent.waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_message_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerMessageEvent>,+ /// Service Worker notification events currently waiting for dispatch and+ /// `ExtendableEvent.waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_notification_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerNotificationEvent>,+ /// Service Worker push events currently waiting for dispatch and+ /// `ExtendableEvent.waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_push_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerPushEvent>,+ /// Service Worker sync events currently waiting for dispatch and+ /// `ExtendableEvent.waitUntil()` promises to finish.+ pub(in crate::worker) pending_service_worker_sync_events:+ HashMap<ServiceWorkerEventId, PendingServiceWorkerSyncEvent>,+}++pub(crate) fn worker_service_worker_control_state(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::runtime::ServiceWorkerControlState> {+ let state = get_worker_state(scope)?;+ let state = state.borrow();+ let runtime = state.service_worker_runtime.as_ref()?;+ let client_id = state.service_worker_client_id?;+ runtime.matching_controller_for_client(client_id)+}++/// Retrieve the `WorkerGlobalState` from a callback scope.+pub(crate) fn get_worker_state<'s>(+ scope: &mut v8::PinScope<'s, '_>,+) -> Option<Rc<RefCell<WorkerGlobalState>>> {+ let global = scope.get_current_context().global(scope);+ let val = get_private_value(scope, global, WORKER_STATE_SLOT)?;+ let external = v8::Local::<v8::External>::try_from(val).ok()?;+ let ptr = external.value() as *const RefCell<WorkerGlobalState>;+ // Safety: the Rc is kept alive by the worker thread for the lifetime of+ // the context. We increment the ref-count here so we get our own Rc.+ unsafe {+ Rc::increment_strong_count(ptr);+ Some(Rc::from_raw(ptr))+ }+}++pub(crate) fn worker_global_is_closed(scope: &mut v8::PinScope<'_, '_>) -> bool {+ get_worker_state(scope).is_some_and(|state| state.borrow().closed)+}++pub(crate) fn worker_termination_requested(scope: &mut v8::PinScope<'_, '_>) -> bool {+ get_worker_state(scope)+ .is_some_and(|state| state.borrow().termination_requested.load(Ordering::Acquire))+}++pub(crate) fn worker_storage_key(scope: &mut v8::PinScope<'_, '_>) -> Option<MoliStorageKey> {+ Some(get_worker_state(scope)?.borrow().storage_key.clone())+}++pub(crate) fn worker_storage_partition_identity(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<crate::runtime::RendererStoragePartitionIdentity> {+ Some(+ get_worker_state(scope)?+ .borrow()+ .worker_context_runtime+ .storage_partition_identity(),+ )+}++pub(crate) fn worker_current_script_url(scope: &mut v8::PinScope<'_, '_>) -> Option<Url> {+ get_worker_state(scope)?.borrow().current_script_url.clone()+}++pub(crate) fn worker_exception_report_target(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<(mpsc::UnboundedSender<WorkerToParentMessage>, String)> {+ let state = get_worker_state(scope)?;+ let state = state.borrow();+ let script_url = state+ .current_script_url+ .as_ref()+ .map(ToString::to_string)+ .unwrap_or_default();+ Some((state.parent_tx.clone(), script_url))+}++pub(crate) fn worker_uses_shared_worker_agent_cluster(scope: &mut v8::PinScope<'_, '_>) -> bool {+ get_worker_state(scope).is_some_and(|state| {+ matches!(+ state.borrow().global_kind,+ crate::worker::thread::WorkerGlobalKind::Shared { .. }+ )+ })+}++pub(super) fn worker_close_callback(+ scope: &mut v8::PinScope<'_, '_>,+ _args: v8::FunctionCallbackArguments<'_>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ if let Some(state) = get_worker_state(scope) {+ state.borrow_mut().closed = true;+ close_worker_owned_broadcast_channels(&state);+ }+}diff --git a/moli-renderer-v8/src/worker/global_scope/timers.rs b/moli-renderer-v8/src/worker/global_scope/timers.rsindex 45ae5ed66..79ea38f63 100644--- a/moli-renderer-v8/src/worker/global_scope/timers.rs+++ b/moli-renderer-v8/src/worker/global_scope/timers.rs@@ -262,3 +262,79 @@ pub(super) fn worker_request_animation_frame_callback<'s>(}rv.set_uint32(timer_id);}++#[derive(Default, WebApiObject)]+#[webapi(plain)]+pub(super) struct WorkerGlobalTimerOperationsDeclaration {+ #[webapi(method = "setTimeout", callback = worker_set_timeout_callback, length = 1)]+ set_timeout: (),+ #[webapi(method = "clearTimeout", callback = worker_clear_timeout_callback, length = 1)]+ clear_timeout: (),+ #[webapi(method = "setInterval", callback = worker_set_interval_callback, length = 1)]+ set_interval: (),+ #[webapi(method = "clearInterval", callback = worker_clear_interval_callback, length = 1)]+ clear_interval: (),+ #[webapi(+ method = "requestAnimationFrame",+ callback = worker_request_animation_frame_callback,+ length = 1+ )]+ request_animation_frame: (),+ #[webapi(+ method = "cancelAnimationFrame",+ callback = worker_clear_timeout_callback,+ length = 1+ )]+ cancel_animation_frame: (),+ #[webapi(+ method = "queueMicrotask",+ callback = worker_queue_microtask_callback,+ length = 1+ )]+ queue_microtask: (),+}++#[derive(Clone, Default)]+pub(in crate::worker) struct WorkerIsolateTimerQueues {+ pending: Rc<RefCell<Vec<TimerInfo>>>,+ cancelled: Rc<RefCell<Vec<u32>>>,+}++impl WorkerIsolateTimerQueues {+ pub(in crate::worker) fn push_pending(&self, timer: TimerInfo) {+ self.pending.borrow_mut().push(timer);+ }++ pub(in crate::worker) fn clear_pending_and_active(&self, timer_id: u32) {+ self.pending+ .borrow_mut()+ .retain(|timer| timer.id != timer_id);+ self.cancel_active(timer_id);+ }++ pub(in crate::worker) fn cancel_active(&self, timer_id: u32) {+ self.cancelled.borrow_mut().push(timer_id);+ }++ pub(in crate::worker) fn drain_pending(&self) -> Vec<TimerInfo> {+ self.pending.borrow_mut().drain(..).collect()+ }++ pub(in crate::worker) fn drain_cancelled(&self) -> Vec<u32> {+ self.cancelled.borrow_mut().drain(..).collect()+ }+}++pub(in crate::worker) fn worker_isolate_timer_queues(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<WorkerIsolateTimerQueues> {+ scope.get_slot::<WorkerIsolateTimerQueues>().cloned()+}++pub(in crate::worker) struct TimerInfo {+ pub(in crate::worker) id: u32,+ pub(in crate::worker) callback: crate::worker::timer_callback::WorkerTimerCallback,+ pub(in crate::worker) delay_ms: u64,+ pub(in crate::worker) is_interval: bool,+ pub(in crate::worker) extra_args: Vec<v8::Global<v8::Value>>,+}