Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(emulation): support worker user agent overrides
ldm0312b0ffc6b7d
diff --git a/README.md b/README.mdindex cb832505f..74bebb3e4 100644--- a/README.md+++ b/README.md@@ -356,20 +356,6 @@ Its current intentional boundaries include:paint architecture.- It does not pursue pixel-for-pixel parity with Chrome or providehigh-fidelity Canvas/WebGL/media playback.-- Emulation supports offline mode, but CPU throttling, network latency/throughput,- packet shaping, and connection type overrides return a protocol error. CPU rates- at or below 1 disable throttling; non-positive latency and throughput values- disable network throttling. Unsupported combinations are rejected before- changing offline state.-- Device metrics support desktop geometry and capture transforms. `mobile:true`- returns an unsupported error; mobile viewport-meta processing, text autosizing- and overlay scrollbars are not implemented. Display features, device posture,- forced overlay scrollbars, orientation-lock emulation and explicit viewport-meta- processing are also rejected before changing existing metrics. Default scrollbar- and viewport-meta settings, and disabling orientation-lock emulation, are accepted.-- `Emulation.setUserAgentOverride` and `Network.setUserAgentOverride` support Page- targets. Worker targets return an unsupported error; these rejected commands do- not activate a Worker Emulation agent or affect its override precedence.- `--layout` supports software screenshots and raster-backed CDP PDFgeneration, but not every Chrome screenshot or print mode is implemented.diff --git a/moli-browser-profile/src/identity.rs b/moli-browser-profile/src/identity.rsindex 4bd242091..bf04b3130 100644--- a/moli-browser-profile/src/identity.rs+++ b/moli-browser-profile/src/identity.rs@@ -13,6 +13,7 @@ pub struct BrowserBrandVersion {}#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]pub struct BrowserUserAgentMetadataOverride {pub brands: Option<Vec<BrowserBrandVersion>>,pub full_version_list: Option<Vec<BrowserBrandVersion>>,diff --git a/moli-browser-profile/src/lib.rs b/moli-browser-profile/src/lib.rsindex 58aeb7619..3bccc80e4 100644--- a/moli-browser-profile/src/lib.rs+++ b/moli-browser-profile/src/lib.rs@@ -5,6 +5,7 @@ mod profile_lock;mod profile_manifest;mod profile_partition_id;mod profile_paths;+mod user_agent_override;mod window_surface;pub use atomic_write::write_file_atomically;@@ -23,6 +24,7 @@ pub use profile_partition_id::{DEFAULT_PROFILE_PARTITION_ID, ProfilePartitionId, ProfilePartitionIdError,};pub use profile_paths::{BrowserProfilePartitionPaths, BrowserProfilePaths};+pub use user_agent_override::UserAgentOverride;pub use window_surface::{DEFAULT_ACCEPT_LANGUAGE, DEFAULT_CDP_PRODUCT, DEFAULT_CONNECTION_DOWNLINK,DEFAULT_CONNECTION_DOWNLINK_MAX, DEFAULT_CONNECTION_EFFECTIVE_TYPE, DEFAULT_CONNECTION_RTT,diff --git a/moli-browser-profile/src/user_agent_override.rs b/moli-browser-profile/src/user_agent_override.rsnew file mode 100644index 000000000..4dd9aa60d--- /dev/null+++ b/moli-browser-profile/src/user_agent_override.rs@@ -0,0 +1,82 @@+use serde::Deserialize;++use crate::{BrowserBrandVersion, BrowserUserAgentMetadataOverride};++/// The independent identity inputs accepted by CDP on both Pages and Workers.+/// Keep absent and empty values distinct: even an empty optional input can+/// activate an Inspector Emulation agent without contributing an override.+#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct UserAgentOverride {+ pub user_agent: String,+ pub accept_language: Option<String>,+ pub platform: Option<String>,+ pub user_agent_metadata: Option<BrowserUserAgentMetadataOverride>,+}++impl UserAgentOverride {+ pub fn activates_agent(&self) -> bool {+ !self.user_agent.is_empty() || self.accept_language.is_some() || self.platform.is_some()+ }++ pub fn validate(&self) -> Result<(), &'static str> {+ let header_value =+ |value: &str| !value.bytes().any(|byte| matches!(byte, 0 | b'\r' | b'\n'));+ if !header_value(&self.user_agent) {+ return Err("Invalid characters found in userAgent");+ }+ if self+ .accept_language+ .as_deref()+ .is_some_and(|value| !header_value(value))+ {+ return Err("Invalid characters found in acceptLanguage");+ }+ if let Some(metadata) = &self.user_agent_metadata {+ if self.user_agent.is_empty() {+ return Err("Empty userAgent invalid with userAgentMetadata provided");+ }+ validate_brands(metadata.brands.as_deref())?;+ validate_brands(metadata.full_version_list.as_deref())?;+ for (value, error) in [+ (+ metadata.full_version.as_deref(),+ "Invalid full version string",+ ),+ (Some(metadata.platform.as_str()), "Invalid platform string"),+ (+ Some(metadata.platform_version.as_str()),+ "Invalid platform version string",+ ),+ (+ Some(metadata.architecture.as_str()),+ "Invalid architecture string",+ ),+ (Some(metadata.model.as_str()), "Invalid model string"),+ (metadata.bitness.as_deref(), "Invalid bitness string"),+ ] {+ validate_field(value, error)?;+ }+ for value in metadata.form_factors.iter().flatten() {+ validate_field(Some(value), "Invalid form factor string")?;+ }+ }+ Ok(())+ }+}++fn validate_field(value: Option<&str>, error: &'static str) -> Result<(), &'static str> {+ if value.is_some_and(|value| !value.bytes().all(|byte| (0x20..=0x7e).contains(&byte))) {+ Err(error)+ } else {+ Ok(())+ }+}++fn validate_brands(brands: Option<&[BrowserBrandVersion]>) -> Result<(), &'static str> {+ for brand in brands.into_iter().flatten() {+ validate_field(Some(&brand.brand), "Invalid brand string")?;+ validate_field(Some(&brand.version), "Invalid brand version string")?;+ }+ Ok(())+}diff --git a/moli-fetch/src/blocking/cache/vary.rs b/moli-fetch/src/blocking/cache/vary.rsindex a3e261c51..5682ac21b 100644--- a/moli-fetch/src/blocking/cache/vary.rs+++ b/moli-fetch/src/blocking/cache/vary.rs@@ -84,7 +84,8 @@ fn vary_request_header_value(.map(|(_, value)| value)};if normalized_name == "user-agent" {- return explicit_value().or_else(|| Some(config.user_agent().to_owned()));+ return explicit_value()+ .or_else(|| Some(request.browser_identity(config).user_agent().to_owned()));}if normalized_name == "accept-encoding" {// libcurl synthesizes this header from `easy.accept_encoding("")`.diff --git a/moli-fetch/src/blocking/mod.rs b/moli-fetch/src/blocking/mod.rsindex e695e6cbd..206d58b87 100644--- a/moli-fetch/src/blocking/mod.rs+++ b/moli-fetch/src/blocking/mod.rs@@ -188,6 +188,14 @@ pub(crate) fn outgoing_request_headers_for_url(outgoing.push((name.clone(), value.clone()));}+ if request.has_browser_identity_override() {+ append_header_if_missing(+ &mut outgoing,+ "User-Agent",+ request.browser_identity(config).user_agent().to_owned(),+ );+ }+append_browser_navigation_headers(&mut outgoing, config, request, request_url);append_browser_subresource_headers(&mut outgoing, config, request, request_url);append_browser_storage_access_header(&mut outgoing, request, request_url);@@ -288,7 +296,10 @@ fn append_browser_navigation_headers(append_header_if_missing(outgoing,"Accept-Language",- config.browser_identity().accept_language().to_owned(),+ request+ .browser_identity(config)+ .accept_language()+ .to_owned(),);append_header_if_missing(outgoing, "Upgrade-Insecure-Requests", "1".to_owned());append_header_if_missing(outgoing, "Sec-Fetch-Mode", "navigate".to_owned());@@ -316,7 +327,7 @@ fn append_browser_navigation_headers(append_header_if_missing(outgoing, "Cache-Control", "max-age=0".to_owned());}- append_browser_client_hints(outgoing, config);+ append_browser_client_hints(outgoing, request.browser_identity(config));}fn append_browser_subresource_headers(@@ -362,7 +373,10 @@ fn append_browser_subresource_headers(append_header_if_missing(outgoing,"Accept-Language",- config.browser_identity().accept_language().to_owned(),+ request+ .browser_identity(config)+ .accept_language()+ .to_owned(),);append_header_if_missing(outgoing,@@ -392,7 +406,7 @@ fn append_browser_subresource_headers(| BrowserRequestMetadata::Xhr => "empty",};append_header_if_missing(outgoing, "Sec-Fetch-Dest", destination.to_owned());- append_browser_client_hints(outgoing, config);+ append_browser_client_hints(outgoing, request.browser_identity(config));}}}@@ -413,8 +427,10 @@ fn request_origin_header_value(request: &Request, request_url: &Url) -> Option<SSome(request.serialized_origin())}-fn append_browser_client_hints(outgoing: &mut Vec<(String, String)>, config: &FetchConfig) {- let identity = config.browser_identity();+fn append_browser_client_hints(+ outgoing: &mut Vec<(String, String)>,+ identity: &moli_browser_profile::BrowserIdentityProfile,+) {let Some(sec_ch_ua) = identity.sec_ch_ua_value() else {return;};@@ -591,7 +607,7 @@ pub(crate) fn configure_easy<H: Handler>(config.tls_config().configure(easy, request.allows_credentials_for_url(request_url))?;- easy.useragent(config.user_agent())+ easy.useragent(request.browser_identity(config).user_agent()).context("failed to set curl user-agent")?;easy.url(request_url.as_str()).with_context(|| anyhow!("failed to set curl request url to {}", request_url))?;diff --git a/moli-fetch/src/client_hints.rs b/moli-fetch/src/client_hints.rsindex 7ae3ff6cd..dbe16b752 100644--- a/moli-fetch/src/client_hints.rs+++ b/moli-fetch/src/client_hints.rs@@ -197,7 +197,7 @@ pub(crate) fn prepare_client_hint_request(request: &Request,request_url: &Url,) -> PreparedClientHintRequest {- let identity = config.browser_identity();+ let identity = request.browser_identity(config);let browser_request =request.is_navigation_request() || request.browser_request_metadata().is_some();let mut effective_request = request.clone();diff --git a/moli-fetch/src/request.rs b/moli-fetch/src/request.rsindex 750e97048..7ae14e4bb 100644--- a/moli-fetch/src/request.rs+++ b/moli-fetch/src/request.rs@@ -50,6 +50,7 @@ pub struct Request {pub cookie_context: NetworkCookieRequestContext,timeout_policy: RequestTimeoutPolicy,network_observation_recorder: Option<NetworkObservationRecorder>,+ browser_identity: Option<std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>>,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -405,6 +406,7 @@ impl Request {cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),timeout_policy: RequestTimeoutPolicy::default(),network_observation_recorder: None,+ browser_identity: None,})}@@ -435,6 +437,7 @@ impl Request {cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),timeout_policy: RequestTimeoutPolicy::default(),network_observation_recorder: None,+ browser_identity: None,}}@@ -496,9 +499,34 @@ impl Request {cookie_context: NetworkCookieRequestContext::subresource(method),timeout_policy: RequestTimeoutPolicy::default(),network_observation_recorder: None,+ browser_identity: None,}}+ /// Captures the execution context's identity for this request and redirects.+ /// Updating a Worker must not rebuild the shared transport or mutate an+ /// already admitted request's identity.+ pub fn with_browser_identity(+ mut self,+ identity: std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>,+ ) -> Self {+ self.browser_identity = Some(identity);+ self+ }++ pub(crate) fn browser_identity<'a>(+ &'a self,+ config: &'a FetchConfig,+ ) -> &'a moli_browser_profile::BrowserIdentityProfile {+ self.browser_identity+ .as_deref()+ .unwrap_or_else(|| config.browser_identity())+ }++ pub(crate) fn has_browser_identity_override(&self) -> bool {+ self.browser_identity.is_some()+ }+pub fn with_min_request_timeout(mut self, minimum_request_timeout: Duration) -> Self {self.timeout_policy.minimum_request_timeout = Some(minimum_request_timeout);selfdiff --git a/moli-page-types/src/navigator_overrides.rs b/moli-page-types/src/navigator_overrides.rsindex 14f33d7cf..63335015b 100644--- a/moli-page-types/src/navigator_overrides.rs+++ b/moli-page-types/src/navigator_overrides.rs@@ -34,13 +34,23 @@ pub struct NavigatorQueryOverrides {/// sessions use the same precedence, but each target owns its own registry.#[derive(Debug, Default, PartialEq, Eq)]pub struct NavigatorEmulationSessions {- sessions: Vec<(crate::DevToolsSessionKey, NavigatorQueryOverrides)>,+ sessions: Vec<(crate::DevToolsSessionKey, NavigatorEmulationSession)>,+}++#[derive(Debug, Default, PartialEq, Eq)]+struct NavigatorEmulationSession {+ queries: NavigatorQueryOverrides,+ user_agent: Option<moli_browser_profile::UserAgentOverride>,}impl NavigatorEmulationSessions {/// The first probe-using Emulation command activates an agent. Subsequent/// commands preserve its position, even after clearing an individual value.pub fn session_mut(&mut self, key: &crate::DevToolsSessionKey) -> &mut NavigatorQueryOverrides {+ &mut self.activate(key).queries+ }++ fn activate(&mut self, key: &crate::DevToolsSessionKey) -> &mut NavigatorEmulationSession {let index = match self.sessions.iter()@@ -49,7 +59,7 @@ impl NavigatorEmulationSessions {Some(index) => index,None => {self.sessions- .push((key.clone(), NavigatorQueryOverrides::default()));+ .push((key.clone(), NavigatorEmulationSession::default()));self.sessions.len() - 1}};@@ -65,10 +75,60 @@ impl NavigatorEmulationSessions {.find(|(existing, _)| existing == key){// Disabling alone does not activate a new Inspector agent.- settings.automation = false;+ settings.queries.automation = false;+ }+ }++ pub fn set_user_agent_override(+ &mut self,+ key: &crate::DevToolsSessionKey,+ value: moli_browser_profile::UserAgentOverride,+ ) {+ if value.activates_agent() {+ self.activate(key).user_agent = Some(value);+ } else if let Some((_, session)) = self+ .sessions+ .iter_mut()+ .find(|(existing, _)| existing == key)+ {+ session.user_agent = None;}}+ /// UA (together with its metadata) and language each use the last active+ /// agent contributing that field. Clearing a field does not reorder agents.+ pub fn effective_user_agent_override(&self) -> Option<moli_browser_profile::UserAgentOverride> {+ let mut user_agent = None;+ let mut accept_language = None;+ for (_, session) in &self.sessions {+ let Some(value) = &session.user_agent else {+ continue;+ };+ if !value.user_agent.is_empty() {+ user_agent = Some(value);+ }+ if let Some(language) = value+ .accept_language+ .as_ref()+ .filter(|value| !value.is_empty())+ {+ accept_language = Some(language.clone());+ }+ }+ (user_agent.is_some() || accept_language.is_some()).then(|| {+ moli_browser_profile::UserAgentOverride {+ user_agent: user_agent+ .map(|value| value.user_agent.clone())+ .unwrap_or_default(),+ accept_language,+ // Worker platform is fixed at creation. The parameter participates+ // in activation, but Chromium applies it only to Page settings.+ platform: None,+ user_agent_metadata: user_agent.and_then(|value| value.user_agent_metadata.clone()),+ }+ })+ }+pub fn remove(&mut self, key: &crate::DevToolsSessionKey) {self.sessions.retain(|(existing, _)| existing != key);}@@ -79,7 +139,8 @@ impl NavigatorEmulationSessions {pub fn effective(&self) -> NavigatorQueryOverrides {let mut effective = NavigatorQueryOverrides::default();- for (_, settings) in &self.sessions {+ for (_, session) in &self.sessions {+ let settings = &session.queries;effective.automation |= settings.automation;effective.data_saver = settings.data_saver.or(effective.data_saver);effective.hardware_concurrency = settingsdiff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rsindex 7c26b8dd9..1470bfa02 100644--- a/moli-protocol/src/conn/browser_context/network_owner.rs+++ b/moli-protocol/src/conn/browser_context/network_owner.rs@@ -747,16 +747,6 @@ impl CdpConnection {session_id: Option<&str>,browser_identity: Option<crate::conn::DevToolsBrowserIdentityOverride>,) -> Result<Option<PendingPageCommand>, String> {- if matches!(- self.session_route(session_id),- Some(- CdpSessionRoute::DedicatedWorkerTarget { .. }- | CdpSessionRoute::SharedWorkerTarget { .. }- | CdpSessionRoute::ServiceWorkerTarget { .. }- )- ) {- return Err("User agent overrides are not supported for workers".to_owned());- }let non_page_identity = browser_identity.as_ref().map(crate::conn::DevToolsBrowserIdentityOverride::to_browser_identity);diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rsindex 0fb7f28fb..1dcc40e81 100644--- a/moli-protocol/src/conn/dispatch.rs+++ b/moli-protocol/src/conn/dispatch.rs@@ -653,6 +653,12 @@ impl CdpConnection {},)}+ "Emulation" | "Network" if let Some(step) = crate::domains::runtime::try_start_worker_emulation_command_dispatch(self, &cmd) => {+ Some(match step {+ crate::domains::runtime::RuntimeCommandTaskStep::Pending(pending) => self.pending_step(PendingCdpCommandDispatchKind::Runtime(pending)),+ crate::domains::runtime::RuntimeCommandTaskStep::Complete(plan) => self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id),+ })+ }"Network" => Some(match crate::domains::network::start_network_domain_command_dispatch(self, &cmd) {crate::domains::network::NetworkDomainCommandTaskStep::Network(@@ -840,12 +846,6 @@ impl CdpConnection {}},),- "Emulation" if let Some(step) = crate::domains::runtime::try_start_worker_emulation_command_dispatch(self, &cmd) => {- Some(match step {- crate::domains::runtime::RuntimeCommandTaskStep::Pending(pending) => self.pending_step(PendingCdpCommandDispatchKind::Runtime(pending)),- crate::domains::runtime::RuntimeCommandTaskStep::Complete(plan) => self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id),- })- }"Emulation" => crate::domains::emulation::try_start_emulation_command_dispatch(self, &cmd,)diff --git a/moli-protocol/src/domains/network/settings.rs b/moli-protocol/src/domains/network/settings.rsindex 0361d7d60..eacece250 100644--- a/moli-protocol/src/domains/network/settings.rs+++ b/moli-protocol/src/domains/network/settings.rs@@ -1,12 +1,9 @@use crate::conn::{CdpConnection, Cmd, DevToolsBrowserIdentityOverride};use crate::domains::command_output::CommandOutputPlan;#[allow(deprecated)]-use chromiumoxide_cdp::cdp::browser_protocol::{- emulation::SetUserAgentOverrideParams,- network::{- EmulateNetworkConditionsParams, SetBypassServiceWorkerParams, SetCacheDisabledParams,- SetExtraHttpHeadersParams,- },+use chromiumoxide_cdp::cdp::browser_protocol::network::{+ EmulateNetworkConditionsParams, SetBypassServiceWorkerParams, SetCacheDisabledParams,+ SetExtraHttpHeadersParams,};use serde::Deserialize;@@ -119,130 +116,22 @@ pub(crate) fn user_agent_override_for_command(cmd: &Cmd<'_>,base: &moli_browser_profile::BrowserIdentityProfile,) -> Result<Option<DevToolsBrowserIdentityOverride>, CommandOutputPlan> {- let params: SetUserAgentOverrideParams = match cmd.get_params() {+ let params: moli_browser_profile::UserAgentOverride = match cmd.get_params() {Ok(Some(params)) => params,_ => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),};- if !params.user_agent.is_empty() && !is_valid_chromium_header_value(¶ms.user_agent) {- return Err(CommandOutputPlan::error(- -32602,- "Invalid characters found in userAgent",- ));- }- if params- .accept_language- .as_deref()- .is_some_and(|value| !value.is_empty() && !is_valid_chromium_header_value(value))- {- return Err(CommandOutputPlan::error(- -32602,- "Invalid characters found in acceptLanguage",- ));- }- if params.user_agent.is_empty() && params.user_agent_metadata.is_some() {- return Err(CommandOutputPlan::error(- -32602,- "Empty userAgent invalid with userAgentMetadata provided",- ));- }- let full_version = match cmd- .params- .and_then(|params| params.get("userAgentMetadata"))- .and_then(|metadata| metadata.get("fullVersion"))- {- None | Some(serde_json::Value::Null) => None,- Some(serde_json::Value::String(value)) => Some(value.clone()),- Some(_) => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),- };- if let Some(metadata) = params.user_agent_metadata.as_ref() {- validate_client_hint_brand_list(metadata.brands.as_deref())?;- validate_client_hint_brand_list(metadata.full_version_list.as_deref())?;- validate_client_hint_field(full_version.as_deref(), "Invalid full version string")?;- validate_client_hint_field(Some(&metadata.platform), "Invalid platform string")?;- validate_client_hint_field(- Some(&metadata.platform_version),- "Invalid platform version string",- )?;- validate_client_hint_field(Some(&metadata.architecture), "Invalid architecture string")?;- validate_client_hint_field(Some(&metadata.model), "Invalid model string")?;- validate_client_hint_field(metadata.bitness.as_deref(), "Invalid bitness string")?;- if let Some(form_factors) = metadata.form_factors.as_deref() {- for form_factor in form_factors {- validate_client_hint_field(Some(form_factor), "Invalid form factor string")?;- }- }- }- let metadata = params.user_agent_metadata.map(|metadata| {- moli_browser_profile::BrowserUserAgentMetadataOverride {- brands: metadata.brands.map(|brands| {- brands- .into_iter()- .map(|entry| moli_browser_profile::BrowserBrandVersion {- brand: entry.brand,- version: entry.version,- })- .collect()- }),- full_version_list: metadata.full_version_list.map(|brands| {- brands- .into_iter()- .map(|entry| moli_browser_profile::BrowserBrandVersion {- brand: entry.brand,- version: entry.version,- })- .collect()- }),- full_version,- platform: metadata.platform,- platform_version: metadata.platform_version,- architecture: metadata.architecture,- model: metadata.model,- mobile: metadata.mobile,- bitness: metadata.bitness,- wow64: metadata.wow64,- form_factors: metadata.form_factors,- }- });+ params+ .validate()+ .map_err(|message| CommandOutputPlan::error(-32602, message))?;Ok(DevToolsBrowserIdentityOverride::from_command(base,params.user_agent,params.accept_language,params.platform,- metadata,+ params.user_agent_metadata,))}-fn is_valid_chromium_header_value(value: &str) -> bool {- !value.bytes().any(|byte| matches!(byte, 0 | b'\r' | b'\n'))-}--fn is_ascii_printable(value: &str) -> bool {- value.bytes().all(|byte| (0x20..=0x7e).contains(&byte))-}--fn validate_client_hint_field(- value: Option<&str>,- error_message: &'static str,-) -> Result<(), CommandOutputPlan> {- if value.is_some_and(|value| !is_ascii_printable(value)) {- return Err(CommandOutputPlan::error(-32602, error_message));- }- Ok(())-}--fn validate_client_hint_brand_list(- brands: Option<&[chromiumoxide_cdp::cdp::browser_protocol::emulation::UserAgentBrandVersion]>,-) -> Result<(), CommandOutputPlan> {- let Some(brands) = brands else {- return Ok(());- };- for brand in brands {- validate_client_hint_field(Some(&brand.brand), "Invalid brand string")?;- validate_client_hint_field(Some(&brand.version), "Invalid brand version string")?;- }- Ok(())-}-fn extra_http_headers_from_params(params: SetExtraHttpHeadersParams,) -> Option<Vec<(String, String)>> {diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rsindex dbf660bf4..4cbf0a5b6 100644--- a/moli-protocol/src/domains/runtime/dispatcher.rs+++ b/moli-protocol/src/domains/runtime/dispatcher.rs@@ -919,10 +919,13 @@ pub(crate) fn try_start_worker_emulation_command_dispatch(conn: &mut CdpConnection,cmd: &Cmd<'_>,) -> Option<RuntimeCommandTaskStep> {- let action = match cmd.action {- "setHardwareConcurrencyOverride" => "Emulation.setHardwareConcurrencyOverride",- "setDataSaverOverride" => "Emulation.setDataSaverOverride",- "setAutomationOverride" => "Emulation.setAutomationOverride",+ let action = match cmd.method {+ "Emulation.setHardwareConcurrencyOverride" => "Emulation.setHardwareConcurrencyOverride",+ "Emulation.setDataSaverOverride" => "Emulation.setDataSaverOverride",+ "Emulation.setAutomationOverride" => "Emulation.setAutomationOverride",+ "Emulation.setUserAgentOverride" | "Network.setUserAgentOverride" => {+ "Emulation.setUserAgentOverride"+ }_ => return None,};let pending = match conn.session_route(cmd.session_id) {diff --git a/moli-protocol/src/domains/runtime/tests/mod.rs b/moli-protocol/src/domains/runtime/tests/mod.rsindex 4c0e7e4c1..f6fde6712 100644--- a/moli-protocol/src/domains/runtime/tests/mod.rs+++ b/moli-protocol/src/domains/runtime/tests/mod.rs@@ -203,3 +203,5 @@ mod navigation;mod objects;mod service_worker;mod shared_worker;++mod worker_emulation;diff --git a/moli-protocol/src/domains/runtime/tests/shared_worker.rs b/moli-protocol/src/domains/runtime/tests/shared_worker.rsindex f26179603..11bb5b89e 100644--- a/moli-protocol/src/domains/runtime/tests/shared_worker.rs+++ b/moli-protocol/src/domains/runtime/tests/shared_worker.rs@@ -3725,7 +3725,7 @@ async fn worker_navigator_query_overrides_are_independent_of_the_page() {}#[tokio::test(flavor = "multi_thread")]-async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands() {+async fn shared_worker_emulation_activation_tracks_user_agent_commands() {async fn snapshot(ctx: &mut TestContext, session_id: Option<&str>) -> serde_json::Value {ctx.process_and_wait_for_response_async(json!({"id": 99190, "sessionId": session_id, "method": "Runtime.evaluate",@@ -3764,22 +3764,18 @@ async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands.unwrap().to_owned();- // Unsupported UA commands must neither alter the Page nor reserve a place- // in the Worker's Emulation agent order. Both CDP spellings share the policy.+ // Invalid UA commands must not reserve a place in the Worker agent order.+ // Both CDP spellings validate before publishing any state.for method in ["Emulation.setUserAgentOverride","Network.setUserAgentOverride",] {ctx.process_and_wait_for_response_async(json!({"id": 99103, "sessionId": first, "method": method,- "params": {"userAgent": "worker-emulation-order"}+ "params": {"userAgent": "invalid\nagent"}})).await;- ctx.expect_error(- 99103,- -32000,- "User agent overrides are not supported for workers",- );+ ctx.expect_error(99103, -32602, "Invalid characters found in userAgent");assert_eq!(snapshot(&mut ctx, Some(&first)).await, baseline);assert_eq!(snapshot(&mut ctx, None).await, page_baseline);}@@ -3794,14 +3790,32 @@ async fn shared_worker_emulation_activation_ignores_rejected_user_agent_commands"HardwareConcurrency must be a positive int32",);- // Activate the second session first through Data Saver. Its later updates- // cannot overtake the first session, even when an individual value clears.+ // UA alone activates the second agent before the first sets concurrency.+ // Clearing UA must preserve that position for subsequent query overrides.+ ctx.process_and_wait_for_response_async(json!({+ "id": 99109, "sessionId": second, "method": "Emulation.setUserAgentOverride",+ "params": {"userAgent": "worker-emulation-order"}+ }))+ .await;+ ctx.expect_result(99109, json!({}), Some(&second));+ ctx.process_and_wait_for_response_async(json!({+ "id": 99110, "sessionId": first, "method": "Emulation.setHardwareConcurrencyOverride",+ "params": {"hardwareConcurrency": 2}+ }))+ .await;+ ctx.expect_result(99110, json!({}), Some(&first));+ ctx.process_and_wait_for_response_async(json!({+ "id": 99111, "sessionId": second, "method": "Network.setUserAgentOverride",+ "params": {"userAgent": ""}+ }))+ .await;+ ctx.expect_result(99111, json!({}), Some(&second));for (session, method, params, expected) in [(&second,"Emulation.setDataSaverOverride",json!({"dataSaverEnabled": true}),- json!([baseline[0], true]),+ json!([2, true]),),(&first,diff --git a/moli-protocol/src/domains/runtime/tests/worker_emulation.rs b/moli-protocol/src/domains/runtime/tests/worker_emulation.rsnew file mode 100644index 000000000..f4c5312d2--- /dev/null+++ b/moli-protocol/src/domains/runtime/tests/worker_emulation.rs@@ -0,0 +1,321 @@+use super::*;+use axum::{Json, http::HeaderMap};+use serde_json::Value;++async fn evaluate(ctx: &mut TestContext, session: &str, expression: &str) -> Value {+ ctx.process_and_wait_for_response_async(json!({+ "id": 99200, "sessionId": session, "method": "Runtime.evaluate",+ "params": {"expression": expression, "awaitPromise": true, "returnByValue": true}+ }))+ .await;+ let response = take_response_by_id(ctx, 99200);+ assert!(response.get("error").is_none(), "{response}");+ assert!(+ response["result"].get("exceptionDetails").is_none(),+ "{response}"+ );+ response["result"]["result"]["value"].clone()+}++async fn set_ua(ctx: &mut TestContext, session: &str, method: &str, params: Value) {+ ctx.process_and_wait_for_response_async(json!({+ "id": 99201, "sessionId": session, "method": method, "params": params+ }))+ .await;+ ctx.expect_result(99201, json!({}), Some(session));+}++const SNAPSHOT: &str = r#"(() => {+ globalThis.heldNavigator ??= navigator;+ globalThis.heldUaData ??= navigator.userAgentData;+ return {+ ua: heldNavigator.userAgent, app: heldNavigator.appVersion,+ platform: heldNavigator.platform, language: heldNavigator.language,+ languages: Array.from(heldNavigator.languages),+ metadata: navigator.userAgentData.toJSON(), held: heldUaData.toJSON()+ };+})()"#;+const HEADERS: &str = "fetch('/headers', {cache:'no-store'}).then(response => response.json())";++async fn worker_user_agent_override(target_type: &str, create: &str) {+ async fn page() -> impl IntoResponse {+ (+ [(CONTENT_TYPE.as_str(), "text/html")],+ "<!doctype html><body>Worker UA</body>",+ )+ }+ async fn worker() -> impl IntoResponse {+ (+ [(CONTENT_TYPE.as_str(), "text/javascript")],+ r#"+ onconnect = event => event.ports[0].postMessage('ready');+ if (typeof registration !== 'undefined') {+ addEventListener('install', event => event.waitUntil(skipWaiting()));+ addEventListener('activate', event => event.waitUntil(clients.claim()));+ }+ "#,+ )+ }+ async fn headers(headers: HeaderMap) -> Json<std::collections::BTreeMap<String, String>> {+ Json(+ headers+ .iter()+ .map(|(key, value)| (key.to_string(), value.to_str().unwrap().to_owned()))+ .collect(),+ )+ }+ async fn websocket(+ headers: HeaderMap,+ upgrade: axum::extract::ws::WebSocketUpgrade,+ ) -> impl IntoResponse {+ let ua = headers["user-agent"].to_str().unwrap().to_owned();+ upgrade.on_upgrade(move |mut socket| async move {+ socket+ .send(axum::extract::ws::Message::Text(ua.into()))+ .await+ .unwrap();+ while let Some(Ok(message)) = socket.recv().await {+ if matches!(message, axum::extract::ws::Message::Close(_)) {+ break;+ }+ }+ })+ }+ async fn imported(headers: HeaderMap) -> impl IntoResponse {+ (+ [+ ("content-type", "text/javascript"),+ ("cache-control", "max-age=3600"),+ ("vary", "User-Agent"),+ ],+ format!(+ "globalThis.importedUA = {};",+ serde_json::to_string(headers["user-agent"].to_str().unwrap()).unwrap()+ ),+ )+ }+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ axum::serve(+ listener,+ Router::new()+ .route("/page", get(page))+ .route("/worker.js", get(worker))+ .route("/headers", get(headers))+ .route("/socket", get(websocket))+ .route(+ "/redirect",+ get(|| async { axum::response::Redirect::temporary("/headers") }),+ )+ .route("/imported.js", get(imported)),+ )+ .await+ .unwrap();+ });+ let mut ctx = TestContext::new();+ with_loaded_http_document_async(+ &mut ctx,+ &format!("http://{addr}/page"),+ "SID-page",+ "TID-page",+ )+ .await;+ ctx.process_async(json!({"id":99202,"method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":false}})).await;+ ctx.expect_result(99202, json!({}), None);+ if target_type == "worker" {+ ctx.process_async(json!({"id":99208,"sessionId":"SID-page","method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":false,"flatten":true}})).await;+ ctx.expect_result(99208, json!({}), Some("SID-page"));+ }+ evaluate(&mut ctx, "SID-page", create).await;+ wait_until_message(&mut ctx, None, "Worker UA target", |message| {+ message["method"] == "Target.attachedToTarget"+ && message["params"]["targetInfo"]["type"] == target_type+ })+ .await;+ let attached = ctx.take_first_matching("Worker UA target", |message| {+ message["method"] == "Target.attachedToTarget"+ && message["params"]["targetInfo"]["type"] == target_type+ });+ let session = attached["params"]["sessionId"].as_str().unwrap().to_owned();+ let target = attached["params"]["targetInfo"]["targetId"]+ .as_str()+ .unwrap()+ .to_owned();+ let baseline = evaluate(&mut ctx, &session, SNAPSHOT).await;+ let baseline_headers = evaluate(&mut ctx, &session, HEADERS).await;+ let page_baseline = evaluate(&mut ctx, "SID-page", SNAPSHOT).await;+ let page_headers = evaluate(&mut ctx, "SID-page", HEADERS).await;+ // Seed both the renderer and HTTP caches before changing the Worker UA.+ let import = "importScripts('/imported.js'); importedUA";+ if target_type != "service_worker" {+ assert_eq!(+ evaluate(&mut ctx, &session, import).await,+ baseline_headers["user-agent"]+ );+ }++ set_ua(&mut ctx, &session, "Emulation.setUserAgentOverride", json!({+ "userAgent":"Mozilla/5.0 WorkerAgent", "acceptLanguage":"fr-FR,fr", "platform":"ignored-in-worker",+ "userAgentMetadata": {"brands":[{"brand":"Worker","version":"7"}], "platform":"WorkerOS", "platformVersion":"2", "architecture":"arm", "model":"M", "mobile":true}+ })).await;+ let mut expected = baseline.clone();+ expected["language"] = json!("fr-FR");+ expected["languages"] = json!(["fr-FR", "fr"]);+ expected["metadata"] =+ json!({"brands":[{"brand":"Worker","version":"7"}],"platform":"WorkerOS","mobile":true});+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);+ let actual = evaluate(&mut ctx, &session, HEADERS).await;+ assert_eq!(actual["user-agent"], "Mozilla/5.0 WorkerAgent");+ assert_eq!(actual["accept-language"], "fr-FR,fr");+ assert!(actual["sec-ch-ua"].as_str().unwrap().contains("Worker"));+ assert_eq!(evaluate(&mut ctx, &session, "fetch('/redirect').then(response => response.json()).then(headers => headers['user-agent'])").await, "Mozilla/5.0 WorkerAgent");+ assert_eq!(evaluate(&mut ctx, &session, "new Promise((resolve, reject) => { const socket = new WebSocket('ws://' + location.host + '/socket'); socket.onmessage = event => { socket.close(); resolve(event.data); }; socket.onerror = () => reject(new Error('websocket failed')); })").await, "Mozilla/5.0 WorkerAgent");+ if target_type != "service_worker" {+ assert_eq!(evaluate(&mut ctx, &session, "new Promise((resolve, reject) => { const xhr = new XMLHttpRequest(); xhr.open('GET','/headers'); xhr.onload = () => resolve(JSON.parse(xhr.responseText)['user-agent']); xhr.onerror = () => reject(new Error('xhr failed')); xhr.send(); })").await, "Mozilla/5.0 WorkerAgent");+ }++ if target_type != "service_worker" {+ assert_eq!(+ evaluate(&mut ctx, &session, import).await,+ "Mozilla/5.0 WorkerAgent"+ );+ }+ assert_eq!(evaluate(&mut ctx, &session, "navigator.userAgentData.getHighEntropyValues(['architecture','platformVersion']).then(x => [x.architecture,x.platformVersion])").await, json!(["arm", "2"]));+ assert_eq!(+ evaluate(&mut ctx, "SID-page", SNAPSHOT).await,+ page_baseline+ );+ assert_eq!(evaluate(&mut ctx, "SID-page", HEADERS).await, page_headers);++ // An override without metadata restores the Worker's creation metadata;+ // its UA string, appVersion and platform also remain creation-time values.+ set_ua(+ &mut ctx,+ &session,+ "Network.setUserAgentOverride",+ json!({"userAgent":"WorkerAlias", "acceptLanguage":"de-DE,de"}),+ )+ .await;+ expected = baseline.clone();+ expected["language"] = json!("de-DE");+ expected["languages"] = json!(["de-DE", "de"]);+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);+ assert_eq!(+ evaluate(&mut ctx, &session, HEADERS).await["user-agent"],+ "WorkerAlias"+ );+ if target_type != "service_worker" {+ assert_eq!(evaluate(&mut ctx, &session, import).await, "WorkerAlias");+ }+ ctx.process_and_wait_for_response_async(json!({"id":99203,"sessionId":session,"method":"Emulation.setUserAgentOverride","params":{"userAgent":"bad\nagent"}})).await;+ ctx.expect_error(99203, -32602, "Invalid characters found in userAgent");+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, expected);+ assert_eq!(+ evaluate(&mut ctx, &session, HEADERS).await["user-agent"],+ "WorkerAlias"+ );++ set_ua(+ &mut ctx,+ &session,+ "Emulation.setUserAgentOverride",+ json!({"userAgent":""}),+ )+ .await;+ assert_eq!(evaluate(&mut ctx, &session, SNAPSHOT).await, baseline);+ assert_eq!(+ evaluate(&mut ctx, &session, HEADERS).await,+ baseline_headers+ );+ // Sessions contribute UA/metadata and language independently. Updating the+ // earlier agent cannot overtake a later agent; clearing reveals its value.+ ctx.process_async(json!({"id":99206,"method":"Target.attachToTarget","params":{"targetId":target,"flatten":true}})).await;+ let second = take_response_by_id(&mut ctx, 99206)["result"]["sessionId"]+ .as_str()+ .unwrap()+ .to_owned();+ set_ua(+ &mut ctx,+ &session,+ "Emulation.setUserAgentOverride",+ json!({"userAgent":"First", "acceptLanguage":"fr-FR"}),+ )+ .await;+ set_ua(+ &mut ctx,+ &second,+ "Network.setUserAgentOverride",+ json!({"userAgent":"Second"}),+ )+ .await;+ set_ua(+ &mut ctx,+ &session,+ "Emulation.setUserAgentOverride",+ json!({"userAgent":"FirstChanged", "acceptLanguage":"it-IT"}),+ )+ .await;+ let headers = evaluate(&mut ctx, &session, HEADERS).await;+ assert_eq!(headers["user-agent"], "Second");+ assert_eq!(headers["accept-language"], "it-IT");+ set_ua(+ &mut ctx,+ &second,+ "Emulation.setUserAgentOverride",+ json!({"userAgent":""}),+ )+ .await;+ assert_eq!(+ evaluate(&mut ctx, &second, HEADERS).await["user-agent"],+ "FirstChanged"+ );+ ctx.process_async(+ json!({"id":99207,"method":"Target.detachFromTarget","params":{"sessionId":second}}),+ )+ .await;+ ctx.expect_result(99207, json!({}), None);++ set_ua(+ &mut ctx,+ &session,+ "Network.setUserAgentOverride",+ json!({"userAgent":"DetachAgent"}),+ )+ .await;+ ctx.process_async(+ json!({"id":99204,"method":"Target.detachFromTarget","params":{"sessionId":session}}),+ )+ .await;+ ctx.expect_result(99204, json!({}), None);+ ctx.process_async(json!({"id":99205,"method":"Target.attachToTarget","params":{"targetId":target,"flatten":true}})).await;+ let observer = take_response_by_id(&mut ctx, 99205)["result"]["sessionId"]+ .as_str()+ .unwrap()+ .to_owned();+ assert_eq!(evaluate(&mut ctx, &observer, SNAPSHOT).await, baseline);+ assert_eq!(+ evaluate(&mut ctx, &observer, HEADERS).await,+ baseline_headers+ );+ server.abort();+}++#[tokio::test(flavor = "multi_thread")]+async fn dedicated_worker_user_agent_override_updates_requests_and_restores_on_detach() {+ worker_user_agent_override(+ "worker",+ "globalThis.uaWorker = new Worker('/worker.js'); 'started'",+ )+ .await;+}++#[tokio::test(flavor = "multi_thread")]+async fn shared_worker_user_agent_override_updates_requests_and_restores_on_detach() {+ worker_user_agent_override("shared_worker", "globalThis.uaWorker = new SharedWorker('/worker.js', 'ua'); uaWorker.port.start(); 'started'").await;+}++#[tokio::test(flavor = "multi_thread")]+async fn service_worker_user_agent_override_updates_requests_and_restores_on_detach() {+ worker_user_agent_override("service_worker", "navigator.serviceWorker.register('/worker.js').then(() => navigator.serviceWorker.ready).then(() => 'ready')").await;+}diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rsindex 0014ca607..b0d8d2fc8 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/navigator.rs@@ -651,6 +651,45 @@ fn navigator_runtime_data_getter_callback<'s>(rv.set(v8::undefined(scope).into());return;};+ if matches!(key, "language" | "languages" | "userAgentData")+ && let Some(identity) = worker_navigator_identity(scope, backing)+ {+ match key {+ "language" => {+ if let Some(value) = v8_string(scope, identity.language()) {+ rv.set(value.into());+ }+ return;+ }+ "userAgentData" => {+ // Like Chromium, each access takes a metadata snapshot. An+ // already held NavigatorUAData keeps its original values.+ rv.set(build_navigator_ua_data_object(scope, &identity).into());+ return;+ }+ "languages" => {+ let previous = get_private_value(scope, backing, NAVIGATOR_ACCEPT_LANGUAGE_SLOT)+ .and_then(|value| value.to_string(scope))+ .map(|value| value.to_rust_string_lossy(scope));+ if previous.as_deref() != Some(identity.accept_language()) {+ if let Some(value) = v8_string(scope, identity.accept_language()) {+ set_private_value(+ scope,+ backing,+ NAVIGATOR_ACCEPT_LANGUAGE_SLOT,+ value.into(),+ );+ }+ let _ = backing.set(+ scope,+ v8str(scope, "languages").into(),+ v8::undefined(scope).into(),+ );+ }+ }+ _ => unreachable!(),+ }+ }if let Some(subobject) = NavigatorSubobject::from_key(key) {match ensure_navigator_subobject(scope, backing, subobject) {Ok(value) => rv.set(value),@@ -1092,6 +1131,9 @@ fn navigator_identity_from_backing<'s>(scope: &mut v8::PinScope<'s, '_>,backing: v8::Local<'s, v8::Object>,) -> BrowserIdentityProfile {+ if let Some(identity) = worker_navigator_identity(scope, backing) {+ return identity;+ }if let Some(identity) = navigator_identity_profile(scope, backing) {return identity;}@@ -1107,6 +1149,38 @@ fn navigator_identity_from_backing<'s>(BrowserIdentityProfile::new(user_agent, accept_language)}+fn worker_navigator_identity<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ backing: v8::Local<'s, v8::Object>,+) -> Option<BrowserIdentityProfile> {+ if !get_private_value(scope, backing, WORKER_NAVIGATOR_BACKING_SLOT)+ .is_some_and(|value| value.boolean_value(scope))+ {+ return None;+ }+ let base = navigator_identity_profile(scope, backing)?;+ let value = scope+ .get_slot::<std::rc::Rc<std::cell::RefCell<moli_page_types::NavigatorEmulationSessions>>>()+ .and_then(|sessions| sessions.borrow().effective_user_agent_override());+ Some(match value {+ Some(value) => BrowserIdentityProfile::from_devtools_override(+ &base,+ // WorkerGlobalScope falls back to its creation metadata when the+ // active UA override has no metadata. Its UA/appVersion/platform+ // getters themselves continue to use the creation-time backing.+ if value.user_agent_metadata.is_some() {+ value.user_agent+ } else {+ String::new()+ },+ value.accept_language,+ None,+ value.user_agent_metadata,+ ),+ None => base,+ })+}+pub(in crate::context_bootstrap) fn set_navigator_identity_profile<'s>(scope: &mut v8::PinScope<'s, '_>,object: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/network/policy.rs b/moli-renderer-v8/src/network/policy.rsindex ce801a5e1..6237e2dc7 100644--- a/moli-renderer-v8/src/network/policy.rs+++ b/moli-renderer-v8/src/network/policy.rs@@ -29,6 +29,7 @@ struct PageNetworkPolicyState {revision: u64,memory_cache_partition_id: u64,extra_http_headers: SharedHeaderList,+ browser_identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,blocked_url_patterns: SharedPatternList,optional_resource_fetch_mask: OptionalResourceFetchMask,subframe_loading_enabled: bool,@@ -52,6 +53,7 @@ impl Default for PageNetworkPolicyState {revision: 0,memory_cache_partition_id: next_memory_cache_partition_id(),extra_http_headers: Arc::from([]),+ browser_identity: None,blocked_url_patterns: Arc::from([]),optional_resource_fetch_mask: OptionalResourceFetchMask::NONE,subframe_loading_enabled: true,@@ -156,6 +158,7 @@ impl PageNetworkPolicy {revision: snapshot.configuration_revision,memory_cache_partition_id,extra_http_headers: snapshot.extra_http_headers,+ browser_identity: snapshot.browser_identity,blocked_url_patterns: snapshot.blocked_url_patterns,optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,subframe_loading_enabled: snapshot.subframe_loading_enabled,@@ -182,8 +185,9 @@ impl PageNetworkPolicy {Self {state: Arc::new(Mutex::new(PageNetworkPolicyState {revision: snapshot.configuration_revision,- memory_cache_partition_id: self.memory_cache_partition_id(),+ memory_cache_partition_id: snapshot.memory_cache_partition_id,extra_http_headers: snapshot.extra_http_headers,+ browser_identity: snapshot.browser_identity,blocked_url_patterns: snapshot.blocked_url_patterns,optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,subframe_loading_enabled: snapshot.subframe_loading_enabled,@@ -214,9 +218,11 @@ impl PageNetworkPolicy {let state = self.state.lock();let network_conditions = self.network_conditions.lock();PageNetworkPolicySnapshot {+ memory_cache_partition_id: state.memory_cache_partition_id,configuration_revision: state.revision,network_conditions_revision: network_conditions.revision,extra_http_headers: state.extra_http_headers.clone(),+ browser_identity: state.browser_identity.clone(),network_offline: network_conditions.offline,blocked_url_patterns: state.blocked_url_patterns.clone(),optional_resource_fetch_mask: state.optional_resource_fetch_mask,@@ -250,6 +256,27 @@ impl PageNetworkPolicy {state.advance_revision();}+ pub(crate) fn set_browser_identity_override(+ &self,+ identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,+ ) {+ let mut state = self.state.lock();+ if state.browser_identity == identity {+ return;+ }+ state.browser_identity = identity;+ // Worker imports must not reuse renderer-cache responses prepared for+ // a different identity. The shared transport/cache budget is unchanged.+ state.memory_cache_partition_id = next_memory_cache_partition_id();+ state.advance_revision();+ }++ pub(crate) fn browser_identity_override(+ &self,+ ) -> Option<Arc<moli_browser_profile::BrowserIdentityProfile>> {+ self.state.lock().browser_identity.clone()+ }+pub fn set_network_offline(&self, offline: bool) {let mut conditions = self.network_conditions.lock();if conditions.offline == offline {@@ -359,9 +386,11 @@ impl PageNetworkPolicy {/// mutation cannot alter a request already being prepared.#[derive(Debug, Clone)]pub struct PageNetworkPolicySnapshot {+ memory_cache_partition_id: u64,configuration_revision: u64,network_conditions_revision: u64,extra_http_headers: SharedHeaderList,+ browser_identity: Option<Arc<moli_browser_profile::BrowserIdentityProfile>>,network_offline: bool,blocked_url_patterns: SharedPatternList,optional_resource_fetch_mask: OptionalResourceFetchMask,@@ -408,6 +437,12 @@ impl PageNetworkPolicySnapshot {}pub(crate) fn apply_to_request(&self, mut request: Request) -> Result<Request> {+ // Worker fetch/XHR enforce their loading policy at the API boundary,+ // but still inherit the identity captured by their resource lease.+ if let Some(identity) = &self.browser_identity {+ request = request.with_browser_identity(identity.clone());+ }+if !request.uses_page_network_policy() {return Ok(request);}@@ -613,4 +648,46 @@ mod tests {"resuming online must update the same network-condition handle");}++ #[test]+ fn request_identity_is_frozen_before_later_worker_overrides() {+ let policy = PageNetworkPolicy::default();+ let config = moli_fetch::FetchConfig::default();+ let identity = |ua: &str, language: &str| {+ Arc::new(moli_browser_profile::BrowserIdentityProfile::new(+ ua, language,+ ))+ };+ policy.set_browser_identity_override(Some(identity("Worker/A", "fr-FR")));+ let request_view = policy.frozen_request_view();+ let partition = request_view.memory_cache_partition_id();+ policy.set_browser_identity_override(Some(identity("Worker/B", "de-DE")));+ assert_ne!(partition, policy.memory_cache_partition_id());+ let request = || {+ Request::get("https://example.test/worker-fetch")+ .unwrap()+ .with_browser_request_metadata(moli_fetch::BrowserRequestMetadata::Fetch)+ };+ let frozen = request_view.snapshot().apply_to_request(request()).unwrap();+ let current = policy.snapshot().apply_to_request(request()).unwrap();+ policy.set_browser_identity_override(None);+ for (request, ua, language) in [+ (frozen, "Worker/A", "fr-FR"),+ (current, "Worker/B", "de-DE"),+ ] {+ let headers = moli_fetch::outgoing_request_headers(&config, &request, None);+ assert!(+ headers+ .iter()+ .any(|(name, value)| name.eq_ignore_ascii_case("user-agent") && value == ua)+ );+ assert!(+ headers+ .iter()+ .any(|(name, value)| name.eq_ignore_ascii_case("accept-language")+ && value == language)+ );+ }+ assert!(policy.browser_identity_override().is_none());+ }}diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rsindex 937b242fc..70e3824b5 100644--- a/moli-renderer-v8/src/network/request_client.rs+++ b/moli-renderer-v8/src/network/request_client.rs@@ -951,6 +951,14 @@ impl ResourceRequestClient {self.resource_runtime.client().browser_identity()}+ pub(crate) fn effective_browser_identity(+ &self,+ ) -> std::sync::Arc<moli_browser_profile::BrowserIdentityProfile> {+ self.page_network_policy+ .browser_identity_override()+ .unwrap_or_else(|| std::sync::Arc::new(self.browser_identity().clone()))+ }+pub fn http_proxy(&self) -> Option<&str> {self.resource_runtime.client().http_proxy()}diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rsindex d1cf16af4..998d460e3 100644--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs@@ -1291,7 +1291,11 @@ pub(crate) fn register_worker_websocket<'s>(.and_then(|header| header.clone());let context = WebSocketConnectOptions {origin: moli_url::origin_ascii_serialization(&document_url),- user_agent: loader.request_client().user_agent().to_owned(),+ user_agent: loader+ .request_client()+ .effective_browser_identity()+ .user_agent()+ .to_owned(),extra_headers: extra_http_headers,http_proxy: loader.request_client().http_proxy().map(ToOwned::to_owned),http_no_proxy: loaderdiff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rsindex 146a4909c..208aa718d 100644--- a/moli-renderer-v8/src/worker/thread/mod.rs+++ b/moli-renderer-v8/src/worker/thread/mod.rs@@ -1585,6 +1585,9 @@ async fn worker_main(parent_tx.clone(),matches!(global_kind, WorkerGlobalKind::Shared { .. }),);+ worker_isolate+ .worker_runtime_inspector()+ .bind_request_client(loader.request_client().clone());install_worker_promise_rejection_dispatch(worker_isolate.worker_isolate_mut(),parent_tx.clone(),diff --git a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs b/moli-renderer-v8/src/worker/thread/runtime_inspector.rsindex 789d61079..2b0172aad 100644--- a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs+++ b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs@@ -1,5 +1,5 @@use std::{- cell::{Cell, RefCell, UnsafeCell},+ cell::{Cell, OnceCell, RefCell, UnsafeCell},collections::{HashMap, HashSet, VecDeque},rc::{Rc, Weak},};@@ -365,6 +365,7 @@ pub(super) struct WorkerRuntimeInspector {sessions: RefCell<HashMap<String, Rc<v8::inspector::V8InspectorSession>>>,detached_sessions: RefCell<HashSet<String>>,navigator_emulation: Rc<RefCell<moli_page_types::NavigatorEmulationSessions>>,+ identity: OnceCell<WorkerIdentity>,inspector: v8::inspector::V8Inspector,outbound: WorkerInspectorOutbound,default_context: Rc<RefCell<Option<v8::Global<v8::Context>>>>,@@ -374,6 +375,11 @@ pub(super) struct WorkerRuntimeInspector {shared_worker: bool,}+struct WorkerIdentity {+ client: crate::network::ResourceRequestClient,+ inherited: Option<std::sync::Arc<moli_browser_profile::BrowserIdentityProfile>>,+}+struct WorkerInspectorExecutor {isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,inspector: Weak<WorkerRuntimeInspector>,@@ -452,6 +458,7 @@ impl WorkerRuntimeInspector {sessions: RefCell::new(HashMap::new()),detached_sessions: RefCell::new(HashSet::new()),navigator_emulation,+ identity: OnceCell::new(),outbound: WorkerInspectorOutbound::default(),default_context,default_execution_context_id: Cell::new(None),@@ -495,6 +502,45 @@ impl WorkerRuntimeInspector {self.inspector.context_destroyed(context);}+ pub(super) fn bind_request_client(&self, client: crate::network::ResourceRequestClient) {+ let inherited = client.page_network_policy().browser_identity_override();+ assert!(+ self.identity+ .set(WorkerIdentity { client, inherited })+ .is_ok(),+ "Worker identity must be bound once"+ );+ }++ fn update_user_agent_override(&self) {+ let Some(worker) = self.identity.get() else {+ return;+ };+ let client = &worker.client;+ let base = worker+ .inherited+ .as_deref()+ .unwrap_or_else(|| client.browser_identity());+ let identity = self+ .navigator_emulation+ .borrow()+ .effective_user_agent_override()+ .map(|value| {+ std::sync::Arc::new(+ moli_browser_profile::BrowserIdentityProfile::from_devtools_override(+ base,+ value.user_agent,+ value.accept_language,+ None,+ value.user_agent_metadata,+ ),+ )+ });+ client+ .page_network_policy()+ .set_browser_identity_override(identity.or_else(|| worker.inherited.clone()));+ }+pub(super) fn detach_session(&self, inspector_session_id: Option<&str>) {let session_key = worker_inspector_session_key(inspector_session_id);self.sessions.borrow_mut().remove(&session_key);@@ -504,6 +550,7 @@ impl WorkerRuntimeInspector {.unwrap_or(moli_page_types::DevToolsSessionKey::Primary),);self.detached_sessions.borrow_mut().insert(session_key);+ self.update_user_agent_override();}pub(super) fn attach_session(&self, inspector_session_id: Option<&str>) {@@ -589,6 +636,20 @@ impl WorkerRuntimeInspector {let invalid =|message| Some(json!({"id":command["id"],"error":{"code":-32602,"message":message}}));match command["method"].as_str()? {+ "Emulation.setUserAgentOverride" | "Network.setUserAgentOverride" => {+ let Ok(value) = serde_json::from_value::<moli_browser_profile::UserAgentOverride>(+ command["params"].clone(),+ ) else {+ return invalid("InvalidParams");+ };+ if let Err(message) = value.validate() {+ return invalid(message);+ }+ self.navigator_emulation+ .borrow_mut()+ .set_user_agent_override(&key, value);+ self.update_user_agent_override();+ }"Emulation.setHardwareConcurrencyOverride" => {let value = command["params"]["hardwareConcurrency"].as_u64()diff --git a/moli-renderer-v8/src/worker/thread/tests/network.rs b/moli-renderer-v8/src/worker/thread/tests/network.rsindex 8db9427e0..b58e6f6a1 100644--- a/moli-renderer-v8/src/worker/thread/tests/network.rs+++ b/moli-renderer-v8/src/worker/thread/tests/network.rs@@ -1555,7 +1555,7 @@ async fn worker_navigator_uses_loader_identity_for_user_agent_data() {.expect("channel closed");assert_eq!(expect_post_json(msg),- r#"{"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","appVersion":"5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","language":"fr-CA","languages":["fr-CA","fr","en"],"constructorType":"function","constructorOwn":true,"dataType":"object","sameObject":true,"instance":true,"tag":"[object NavigatorUAData]","json":{"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"mobile":false,"platform":"Windows"},"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","formFactors","fullVersionList","mobile","platform","uaFullVersion"],"selected":{"architecture":"x86","brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"formFactors":["Desktop"],"fullVersionList":[{"brand":"Chromium","version":"146.1.2.3"},{"brand":"Not-A.Brand","version":"24.0.0.0"},{"brand":"Google Chrome","version":"146.1.2.3"}],"mobile":false,"platform":"Windows","uaFullVersion":"146.1.2.3"},"missingArgument":"TypeError"}"#+ r#"{"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","appVersion":"5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","language":"fr-CA","languages":["fr-CA","fr","en"],"constructorType":"function","constructorOwn":true,"dataType":"object","sameObject":false,"instance":true,"tag":"[object NavigatorUAData]","json":{"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"mobile":false,"platform":"Windows"},"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","formFactors","fullVersionList","mobile","platform","uaFullVersion"],"selected":{"architecture":"x86","brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"formFactors":["Desktop"],"fullVersionList":[{"brand":"Chromium","version":"146.1.2.3"},{"brand":"Not-A.Brand","version":"24.0.0.0"},{"brand":"Google Chrome","version":"146.1.2.3"}],"mobile":false,"platform":"Windows","uaFullVersion":"146.1.2.3"},"missingArgument":"TypeError"}"#);}diff --git a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs b/moli-renderer-v8/src/worker/thread/tests/postmessage.rsindex 43c461caf..07a57bd34 100644--- a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs+++ b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs@@ -2103,7 +2103,7 @@ async fn shared_worker_navigator_exposes_canonical_user_agent_data() {"JSON.stringify(__wire)",).await,- r#"{"constructorType":"function","dataType":"object","instance":true,"sameObject":true,"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","languages":["de-DE","de"],"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","mobile","platform"],"architecture":"x86"}"#+ r#"{"constructorType":"function","dataType":"object","instance":true,"sameObject":false,"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.1.2.3 Safari/537.36","languages":["de-DE","de"],"brands":[{"brand":"Chromium","version":"146"},{"brand":"Not-A.Brand","version":"24"},{"brand":"Google Chrome","version":"146"}],"emptyKeys":["brands","mobile","platform"],"selectedKeys":["architecture","brands","mobile","platform"],"architecture":"x86"}"#);}diff --git a/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html b/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.htmlindex e462ac0e4..1fd7ca294 100644--- a/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html+++ b/moli-wpt-compat/fixtures/wpt/ported/worker/worker-global-surface-basic.html@@ -271,7 +271,8 @@ promise_test(async function () {assert_equals(message.data.uaDataCtorOwn, true, "worker should expose NavigatorUAData");assert_equals(message.data.uaDataCtorType, "function", "NavigatorUAData type");assert_equals(message.data.uaDataType, "object", "navigator.userAgentData type");- assert_equals(message.data.uaDataSameObject, true, "userAgentData should be SameObject");+ // Each access returns a metadata snapshot; held snapshots retain their values.+ assert_equals(message.data.uaDataSameObject, false, "userAgentData should return a new snapshot");assert_equals(message.data.uaDataInstance,true,