Skip to content

armgit / moli

Public Imported from GitHub
0

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

65.4 KB
Raw Blame
use std::{
    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
    path::PathBuf,
};

use moli_cookie_jar::{
    BrowserCookieStore, CookieSource, NetworkCookieRequestContext, SharedBrowserCookieStore,
    StoredCookie, StoredCookieQueryReport, new_shared_browser_cookie_store,
};
use moli_core::network::{SharedWebStorageStore, new_shared_web_storage_store};
use moli_core::runtime::{
    NavigationEngine, NavigationPageStorageHandles, NavigationResourceStorageHandles,
    NavigationRuntimeConfig, RendererBrowserContextRuntime, RendererBrowserContextRuntimeOwner,
    RendererBrowserContextRuntimeOwnerAccess, RendererSharedWorkerRuntimeDiagnostics,
    storage_partition::StoragePartitionState,
};
use moli_core::storage::{
    SharedIndexedDbManager, SharedStorageBucketStore, StorageBucketIdentity, WeakIndexedDbManager,
    new_shared_storage_bucket_store_with_indexed_db_manager,
};
use moli_shared_worker::SharedWorkerInstanceId;
use serde_json::{Value, json};

use crate::conn::cookie_manager_surface::BrowserContextCookieManagerSurface;

use super::{
    DevToolsSessionState,
    dedicated_worker_target::DedicatedWorkerTargetState,
    emulation::{
        EmulatedDeviceMetrics, EmulatedGeolocationOverrideState, EmulatedNetworkConditions,
    },
    javascript_dialog::TargetPreparedJavaScriptDialog,
    page_slot::{DocumentNavigationToken, DocumentStartScript},
    page_target_host::{PageTargetHost, PageTargetRegistry},
    service_worker_target::ServiceWorkerTargetState,
    shared_worker_target::SharedWorkerTargetState,
    target_state::TargetOwnerState,
};

pub struct BrowserContext {
    pub id: String,
    storage_partition: BrowserContextStoragePartition,
    pub(crate) page_targets: PageTargetRegistry,
    /// Browser focus is independent of which context is selected for routing.
    pub(crate) window_is_focused: bool,
    pub(crate) named_auxiliary_targets: std::collections::HashSet<String>,
    /// Policy retained while the context has no page target yet. The first
    /// target inherits it; once targets exist, each target owns its surface.
    pub(crate) default_document_cookie_manager_surface: BrowserContextCookieManagerSurface,
    // Chromium exposes the live creator target, immutable creator frame, and
    // window.opener access as three independent TargetInfo properties.
    pub target_opener_ids: HashMap<String, String>,
    pub target_opener_frame_ids: HashMap<String, String>,
    /// Targets whose DOM Window retains script access to its opener.
    ///
    /// DevTools creator identity is stored separately in the opener maps:
    /// an implicit-noopener `_blank` target still has an `openerId`, but is
    /// intentionally absent from this set.
    pub(crate) target_can_access_opener: HashSet<String>,
    pub target_popup_ids: HashMap<String, u64>,
    pending_popup_javascript_dialogs: HashMap<u64, Vec<TargetPreparedJavaScriptDialog>>,
    pub(crate) shared_worker_targets: BTreeMap<SharedWorkerInstanceId, SharedWorkerTargetState>,
    pub(crate) dedicated_worker_targets: BTreeMap<u64, DedicatedWorkerTargetState>,
    pub(crate) service_worker_targets: BTreeMap<u64, ServiceWorkerTargetState>,
    pub(crate) service_worker_domain_sessions: BTreeSet<Option<String>>,
    pub(crate) default_extra_headers: moli_fetch::RequestHeaders,
    pub(crate) global_extra_headers: moli_fetch::RequestHeaders,
    default_browser_identity: super::BaseBrowserIdentityOverrideState,
    environment_owner: moli_core::ProcessEnvironmentOwner,
    pub(crate) default_network_conditions: Option<EmulatedNetworkConditions>,
    pub(crate) default_geolocation_override: Option<EmulatedGeolocationOverrideState>,
    pub(crate) global_network_conditions: Option<EmulatedNetworkConditions>,
    pub(crate) global_geolocation_override: Option<EmulatedGeolocationOverrideState>,
    pub(crate) global_cache_disabled: bool,
    pub(crate) default_http_proxy_override: Option<String>,
    pub(crate) default_http_no_proxy_override: Option<String>,
    pub(crate) default_tls_verify_host_override: Option<bool>,
    pub proxy_autoconfig_url: Option<String>,
    pub proxy_socks_version: Option<u8>,
    pub(crate) default_emulated_device_metrics: Option<EmulatedDeviceMetrics>,
    pub(crate) next_default_document_start_script_id: u32,
    pub(crate) default_document_start_scripts: Vec<(String, DocumentStartScript)>,
    pub(crate) storage_quota_overrides: HashMap<String, f64>,
    pub(crate) http_cache_root: Option<PathBuf>,
    pub(crate) http_cache_max_bytes: Option<u64>,
    pub(crate) page_navigation_runtime_config: Option<NavigationRuntimeConfig>,
    renderer_output_transport_sender: Option<moli_core::RendererOutputTransportSender>,
    // Keep the sole strong per-context network owner last. Protocol teardown
    // must drop pages and NavigationEngines before this field is released.
    pub(crate) renderer_runtime_owner: Option<RendererBrowserContextRuntimeOwner>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum BrowserContextStoragePartitionKind {
    ProfileBacked,
    Ephemeral,
}

#[derive(Clone, PartialEq, Eq)]
pub(crate) struct BrowserContextStoragePartitionIdentity {
    kind: BrowserContextStoragePartitionKind,
    id: String,
}

#[derive(Clone)]
struct BrowserContextStoragePartition {
    identity: BrowserContextStoragePartitionIdentity,
    handles: BrowserContextStoragePartitionHandles,
}

#[derive(Clone)]
pub(crate) struct BrowserContextStoragePartitionHandles {
    cookie_store: SharedBrowserCookieStore,
    web_storage_store: SharedWebStorageStore,
    indexed_db_manager: SharedIndexedDbManager,
    storage_bucket_store: SharedStorageBucketStore,
}

#[derive(Clone)]
pub(crate) struct BrowserContextResourceStorageHandles {
    pub(crate) cookie_store: SharedBrowserCookieStore,
    pub(crate) web_storage_store: SharedWebStorageStore,
    pub(crate) session_storage_store: SharedWebStorageStore,
}

#[derive(Clone)]
pub(crate) struct BrowserContextPageStorageHandles {
    pub(crate) cookie_store: SharedBrowserCookieStore,
    pub(crate) web_storage_store: SharedWebStorageStore,
    pub(crate) session_storage_store: SharedWebStorageStore,
    pub(crate) indexed_db_manager: Option<WeakIndexedDbManager>,
    pub(crate) storage_bucket_store: Option<SharedStorageBucketStore>,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub(crate) struct BrowserContextOriginStorageUsage {
    pub(crate) local_storage_usage: u64,
    pub(crate) indexed_db_usage: u64,
    pub(crate) storage_buckets_usage: u64,
    pub(crate) total_usage: u64,
}

impl BrowserContextStoragePartition {
    fn new(
        identity: BrowserContextStoragePartitionIdentity,
        handles: BrowserContextStoragePartitionHandles,
    ) -> Self {
        Self { identity, handles }
    }

    fn identity(&self) -> &BrowserContextStoragePartitionIdentity {
        &self.identity
    }

    fn cookie_store(&self) -> &SharedBrowserCookieStore {
        &self.handles.cookie_store
    }

    fn web_storage_store(&self) -> &SharedWebStorageStore {
        &self.handles.web_storage_store
    }

    fn indexed_db_manager(&self) -> &SharedIndexedDbManager {
        &self.handles.indexed_db_manager
    }

    fn storage_bucket_store(&self) -> &SharedStorageBucketStore {
        &self.handles.storage_bucket_store
    }

    #[cfg(test)]
    fn replace_storage_bucket_store(&mut self, storage_bucket_store: SharedStorageBucketStore) {
        self.handles.storage_bucket_store = storage_bucket_store;
    }
}

impl std::fmt::Debug for BrowserContextStoragePartition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BrowserContextStoragePartition")
            .field("identity", &self.identity)
            .finish_non_exhaustive()
    }
}

impl BrowserContextStoragePartitionIdentity {
    pub(crate) fn profile_backed_default() -> Self {
        Self {
            kind: BrowserContextStoragePartitionKind::ProfileBacked,
            id: "default".to_owned(),
        }
    }

    pub(crate) fn ephemeral(id: impl Into<String>) -> Self {
        Self {
            kind: BrowserContextStoragePartitionKind::Ephemeral,
            id: id.into(),
        }
    }

    pub(crate) fn kind(&self) -> BrowserContextStoragePartitionKind {
        self.kind
    }

    pub(crate) fn id(&self) -> &str {
        &self.id
    }

    pub(crate) fn kind_label(&self) -> &'static str {
        match self.kind {
            BrowserContextStoragePartitionKind::ProfileBacked => "profile-backed",
            BrowserContextStoragePartitionKind::Ephemeral => "ephemeral",
        }
    }
}

impl BrowserContextStoragePartitionHandles {
    fn from_stores(
        cookie_store: SharedBrowserCookieStore,
        web_storage_store: SharedWebStorageStore,
        indexed_db_manager: SharedIndexedDbManager,
        storage_bucket_store: SharedStorageBucketStore,
    ) -> Self {
        Self {
            cookie_store,
            web_storage_store,
            indexed_db_manager,
            storage_bucket_store,
        }
    }

    pub(crate) fn memory() -> Self {
        Self::with_initial_cookies(Vec::new())
    }

    pub(crate) fn with_initial_cookies(
        initial_cookies: impl IntoIterator<Item = StoredCookie>,
    ) -> Self {
        let cookie_store = new_shared_browser_cookie_store();
        seed_initial_cookies(&cookie_store, initial_cookies);
        let indexed_db_manager = moli_core::storage::new_indexed_db_manager(None)
            .expect("in-memory IndexedDB manager should initialize");
        let storage_bucket_store =
            new_shared_storage_bucket_store_with_indexed_db_manager(&indexed_db_manager);
        Self::from_stores(
            cookie_store,
            new_shared_web_storage_store(),
            indexed_db_manager,
            storage_bucket_store,
        )
    }

    fn from_initial_storage_partition(
        cookie_store: SharedBrowserCookieStore,
        local_storage_store: SharedWebStorageStore,
        indexed_db_manager: SharedIndexedDbManager,
        storage_bucket_store: SharedStorageBucketStore,
    ) -> Self {
        Self::from_stores(
            cookie_store,
            local_storage_store,
            indexed_db_manager,
            storage_bucket_store,
        )
    }

    pub(crate) fn from_storage_partition(
        initial_cookies: impl IntoIterator<Item = StoredCookie>,
        storage_partition: &StoragePartitionState,
    ) -> Self {
        let cookie_store = new_shared_browser_cookie_store();
        seed_initial_cookies(&cookie_store, initial_cookies);
        let shared_storage = storage_partition.shared_storage_handles();
        Self::from_initial_storage_partition(
            cookie_store,
            shared_storage.web_storage_store(),
            shared_storage.indexed_db_manager(),
            shared_storage.storage_bucket_store(),
        )
    }

    pub(crate) fn resource_storage_handles(
        &self,
        session_storage_store: SharedWebStorageStore,
    ) -> BrowserContextResourceStorageHandles {
        BrowserContextResourceStorageHandles {
            cookie_store: self.cookie_store.clone(),
            web_storage_store: self.web_storage_store.clone(),
            session_storage_store,
        }
    }

    pub(crate) fn page_storage_handles(
        &self,
        session_storage_store: SharedWebStorageStore,
    ) -> BrowserContextPageStorageHandles {
        BrowserContextPageStorageHandles {
            cookie_store: self.cookie_store.clone(),
            web_storage_store: self.web_storage_store.clone(),
            session_storage_store,
            indexed_db_manager: Some(moli_core::storage::downgrade_indexed_db_manager(
                &self.indexed_db_manager,
            )),
            storage_bucket_store: Some(self.storage_bucket_store.clone()),
        }
    }
}

impl BrowserContextResourceStorageHandles {
    pub(crate) fn into_navigation_storage(self) -> NavigationResourceStorageHandles {
        NavigationResourceStorageHandles::new(
            self.cookie_store,
            self.web_storage_store,
            self.session_storage_store,
        )
    }
}

impl BrowserContextPageStorageHandles {
    pub(crate) fn into_navigation_storage(self) -> NavigationPageStorageHandles {
        NavigationPageStorageHandles::new(
            self.cookie_store,
            self.web_storage_store,
            self.session_storage_store,
            self.indexed_db_manager,
            self.storage_bucket_store,
        )
    }
}

impl std::fmt::Debug for BrowserContextStoragePartitionIdentity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BrowserContextStoragePartitionIdentity")
            .field("kind", &self.kind)
            .field("id", &self.id)
            .finish()
    }
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub(crate) struct SiteDataClearOptions {
    pub cookies: bool,
    pub local_storage: bool,
    pub indexed_db: bool,
    pub storage_buckets: bool,
    pub http_cache: bool,
}

impl std::fmt::Debug for BrowserContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BrowserContext")
            .field("id", &self.id)
            .field("storage_partition", &self.storage_partition)
            .field("active_target_id", &self.active_target_id())
            .field("active_session_id", &self.active_session_id())
            .field("has_loaded_page", &self.has_loaded_page())
            .finish_non_exhaustive()
    }
}

fn usize_to_u64_saturating(value: usize) -> u64 {
    u64::try_from(value).unwrap_or(u64::MAX)
}

impl BrowserContext {
    pub(crate) fn active_page_target(&self) -> &PageTargetHost {
        self.page_targets
            .active()
            .expect("BrowserContext has no active page target")
    }

    pub(crate) fn active_page_target_mut(&mut self) -> &mut PageTargetHost {
        self.page_targets
            .active_mut()
            .expect("BrowserContext has no active page target")
    }

    /// Parks a dialog only until the matching lightweight-popup target obtains
    /// a concrete protocol attachment.
    ///
    /// This is not a generic activity backlog: every value owns one popup id
    /// and one one-shot renderer completion. Removing the browser context or
    /// forgetting the popup mapping drops and dismisses the value.
    pub(crate) fn park_pending_popup_javascript_dialog(
        &mut self,
        dialog: TargetPreparedJavaScriptDialog,
    ) {
        let popup_id = dialog
            .popup_id()
            .expect("only lightweight-popup dialogs may enter popup attachment residence");
        self.pending_popup_javascript_dialogs
            .entry(popup_id)
            .or_default()
            .push(dialog);
    }

    pub(crate) fn take_pending_popup_javascript_dialogs(
        &mut self,
        popup_id: u64,
    ) -> Vec<TargetPreparedJavaScriptDialog> {
        self.pending_popup_javascript_dialogs
            .remove(&popup_id)
            .unwrap_or_default()
    }

    pub(crate) fn dismiss_pending_popup_javascript_dialogs(&mut self, popup_id: u64) {
        drop(self.take_pending_popup_javascript_dialogs(popup_id));
    }

    pub fn new(id: String) -> Self {
        Self::new_with_initial_cookies(id, Vec::new())
    }

    #[cfg(test)]
    pub(crate) fn new_with_page_for_test(
        id: impl Into<String>,
        target_id: impl Into<String>,
    ) -> Self {
        let mut context = Self::new(id.into());
        context.set_active_target_id(target_id);
        context
    }

    pub(crate) fn new_with_initial_cookies(
        id: String,
        initial_cookies: impl IntoIterator<Item = StoredCookie>,
    ) -> Self {
        Self::new_with_storage_partition_and_http_cache(
            id,
            BrowserContextStoragePartitionHandles::with_initial_cookies(initial_cookies),
            None,
            None,
            false,
        )
    }

    pub(crate) fn new_ephemeral_with_storage_partition_handles(
        id: String,
        partition: BrowserContextStoragePartitionHandles,
        http_cache_root: Option<PathBuf>,
        http_cache_max_bytes: Option<u64>,
        debugger_enabled: bool,
    ) -> Self {
        let storage_partition = BrowserContextStoragePartitionIdentity::ephemeral(id.as_str());
        Self::new_with_storage_partition_and_storage_partition_identity(
            id,
            partition,
            http_cache_root,
            http_cache_max_bytes,
            storage_partition,
            debugger_enabled,
        )
    }

    pub(crate) fn new_ephemeral_with_http_cache(
        id: String,
        http_cache_root: Option<PathBuf>,
        http_cache_max_bytes: Option<u64>,
        debugger_enabled: bool,
    ) -> Self {
        Self::new_ephemeral_with_storage_partition_handles(
            id,
            BrowserContextStoragePartitionHandles::memory(),
            http_cache_root,
            http_cache_max_bytes,
            debugger_enabled,
        )
    }

    pub(crate) fn new_with_storage_partition_and_http_cache(
        id: String,
        partition: BrowserContextStoragePartitionHandles,
        http_cache_root: Option<PathBuf>,
        http_cache_max_bytes: Option<u64>,
        debugger_enabled: bool,
    ) -> Self {
        Self::new_with_storage_partition_and_storage_partition_identity(
            id,
            partition,
            http_cache_root,
            http_cache_max_bytes,
            BrowserContextStoragePartitionIdentity::profile_backed_default(),
            debugger_enabled,
        )
    }

    pub(crate) fn new_with_storage_partition_handles_and_http_cache(
        id: String,
        partition: BrowserContextStoragePartitionHandles,
        http_cache_root: Option<PathBuf>,
        http_cache_max_bytes: Option<u64>,
        debugger_enabled: bool,
    ) -> Self {
        Self::new_with_storage_partition_and_http_cache(
            id,
            partition,
            http_cache_root,
            http_cache_max_bytes,
            debugger_enabled,
        )
    }

    fn new_with_storage_partition_and_storage_partition_identity(
        id: String,
        partition: BrowserContextStoragePartitionHandles,
        http_cache_root: Option<PathBuf>,
        http_cache_max_bytes: Option<u64>,
        identity: BrowserContextStoragePartitionIdentity,
        debugger_enabled: bool,
    ) -> Self {
        let storage_partition = BrowserContextStoragePartition::new(identity, partition);

        Self {
            id,
            storage_partition,
            page_targets: PageTargetRegistry::default(),
            window_is_focused: true,
            named_auxiliary_targets: Default::default(),
            default_document_cookie_manager_surface: BrowserContextCookieManagerSurface::default(),
            target_opener_ids: HashMap::new(),
            target_opener_frame_ids: HashMap::new(),
            target_can_access_opener: HashSet::new(),
            target_popup_ids: HashMap::new(),
            pending_popup_javascript_dialogs: HashMap::new(),
            shared_worker_targets: BTreeMap::new(),
            dedicated_worker_targets: BTreeMap::new(),
            service_worker_targets: BTreeMap::new(),
            service_worker_domain_sessions: BTreeSet::new(),
            default_extra_headers: Default::default(),
            global_extra_headers: Default::default(),
            default_browser_identity: super::BaseBrowserIdentityOverrideState::default(),
            environment_owner: Default::default(),
            default_network_conditions: None,
            default_geolocation_override: None,
            global_network_conditions: None,
            global_geolocation_override: None,
            global_cache_disabled: false,
            default_http_proxy_override: None,
            default_http_no_proxy_override: None,
            default_tls_verify_host_override: None,
            proxy_autoconfig_url: None,
            proxy_socks_version: None,
            default_emulated_device_metrics: None,
            next_default_document_start_script_id: 0,
            default_document_start_scripts: Vec::new(),
            storage_quota_overrides: HashMap::new(),
            http_cache_root,
            http_cache_max_bytes,
            page_navigation_runtime_config: None,
            renderer_output_transport_sender: None,
            renderer_runtime_owner: Some(RendererBrowserContextRuntime::new_with_debugger_enabled(
                debugger_enabled,
            )),
        }
    }

    pub(crate) fn new_page_navigation_engine_for_auxiliary(
        &self,
        config: NavigationRuntimeConfig,
        pending: Option<&moli_core::page::RendererPendingAuxiliaryPage>,
    ) -> NavigationEngine {
        let engine = match pending {
            Some(page) => NavigationEngine::new_for_pending_auxiliary_page(
                config,
                self.renderer_runtime_owner_access(),
                page,
            ),
            None => NavigationEngine::new_with_runtime_config_and_browser_context_access(
                config,
                self.renderer_runtime_owner_access(),
            ),
        }
        .expect("live BrowserContext owner must accept a page engine");
        if let Some(sender) = self.renderer_output_transport_sender.clone() {
            self.renderer_runtime()
                .delegate_auxiliary_document_responses_to_browser();
            engine.set_renderer_output_transport_sender(sender);
        }
        engine
    }

    pub(crate) fn bind_page_navigation_engines(
        &mut self,
        config: NavigationRuntimeConfig,
        renderer_output_transport_sender: Option<moli_core::RendererOutputTransportSender>,
    ) {
        self.page_navigation_runtime_config = Some(config.clone());
        self.renderer_output_transport_sender = renderer_output_transport_sender;
        if self.renderer_output_transport_sender.is_some() {
            self.renderer_runtime()
                .delegate_auxiliary_document_responses_to_browser();
        }

        let renderer_runtime = self.renderer_runtime_owner_access();
        let sender = self.renderer_output_transport_sender.clone();
        for host in self.page_targets.iter_mut() {
            if host.navigation_engine().is_some() {
                continue;
            }
            let engine = match host.runtime_slot.pending_auxiliary_page() {
                Some(page) => NavigationEngine::new_for_pending_auxiliary_page(
                    config.clone(),
                    renderer_runtime.clone(),
                    page,
                ),
                None => NavigationEngine::new_with_runtime_config_and_browser_context_access(
                    config.clone(),
                    renderer_runtime.clone(),
                ),
            }
            .expect("live BrowserContext owner must accept a page engine");
            if let Some(sender) = sender.clone() {
                engine.set_renderer_output_transport_sender(sender);
            }
            host.install_navigation_engine(engine);
        }
    }

    pub(crate) fn set_renderer_output_transport_sender(
        &mut self,
        sender: moli_core::RendererOutputTransportSender,
    ) {
        self.renderer_runtime()
            .delegate_auxiliary_document_responses_to_browser();
        self.renderer_output_transport_sender = Some(sender.clone());
        for host in self.page_targets.iter() {
            if let Some(engine) = host.navigation_engine() {
                engine.set_renderer_output_transport_sender(sender.clone());
            }
        }
    }

    pub(crate) fn page_navigation_engine(&self, target_id: &str) -> Option<&NavigationEngine> {
        self.page_target(target_id)?.navigation_engine()
    }

    pub(crate) fn page_navigation_engine_mut(
        &mut self,
        target_id: &str,
    ) -> Option<&mut NavigationEngine> {
        self.page_target_mut(target_id)?.navigation_engine_mut()
    }

    pub(crate) fn is_profile_backed_storage_partition(&self) -> bool {
        self.storage_partition.identity().kind()
            == BrowserContextStoragePartitionKind::ProfileBacked
    }

    pub(crate) fn storage_partition_id(&self) -> &str {
        self.storage_partition.identity().id()
    }

    pub(crate) fn storage_partition_kind_label(&self) -> &'static str {
        self.storage_partition.identity().kind_label()
    }

    pub(crate) fn resource_storage_handles(&self) -> BrowserContextResourceStorageHandles {
        let session_storage_store = self
            .page_targets
            .active()
            .map(|target| target.session_storage_namespace.store().clone())
            .unwrap_or_else(new_shared_web_storage_store);
        self.storage_partition
            .handles
            .resource_storage_handles(session_storage_store)
    }

    pub(crate) fn page_storage_handles(&self) -> BrowserContextPageStorageHandles {
        let session_storage_store = self
            .page_targets
            .active()
            .map(|target| target.session_storage_namespace.store().clone())
            .unwrap_or_else(new_shared_web_storage_store);
        self.storage_partition
            .handles
            .page_storage_handles(session_storage_store)
    }

    pub(crate) fn page_storage_handles_for_target(
        &self,
        target_id: &str,
    ) -> Option<BrowserContextPageStorageHandles> {
        let target = self.page_target(target_id)?;
        Some(
            self.storage_partition
                .handles
                .page_storage_handles(target.session_storage_store().clone()),
        )
    }

    #[cfg(test)]
    pub(crate) fn with_cookie_store<R>(&self, f: impl FnOnce(&BrowserCookieStore) -> R) -> R {
        let cookie_store = self.storage_partition.cookie_store().lock();
        f(&cookie_store)
    }

    pub(crate) fn with_cookie_store_mut<R>(
        &self,
        f: impl FnOnce(&mut BrowserCookieStore) -> R,
    ) -> R {
        let mut cookie_store = self.storage_partition.cookie_store().lock();
        f(&mut cookie_store)
    }

    #[cfg(test)]
    pub(crate) fn document_cookie_generation(&self) -> u64 {
        self.with_cookie_store(|store| store.document_cookie_generation())
    }

    pub(crate) fn observe_request_cookie_access_report(
        &self,
        request_url: &url::Url,
        request_context: NetworkCookieRequestContext,
    ) -> Option<StoredCookieQueryReport> {
        let mut cookie_store = self.storage_partition.cookie_store().lock();
        let report =
            cookie_store.observe_cookie_access_report_for_request(request_url, request_context);
        (!report.included_cookies.is_empty() || !report.excluded_cookies.is_empty())
            .then_some(report)
    }

    pub(crate) fn storage_quota_for_origin(&self, origin: &str) -> (f64, bool) {
        self.storage_quota_overrides
            .get(origin)
            .copied()
            .map(|quota| (quota, true))
            .unwrap_or((
                moli_core::storage::DEFAULT_ORIGIN_STORAGE_QUOTA_BYTES as f64,
                false,
            ))
    }

    pub(crate) fn set_storage_quota_override(&mut self, origin: String, quota: f64) {
        self.storage_quota_overrides.insert(origin, quota);
    }

    pub(crate) fn clear_storage_quota_override(&mut self, origin: &str) {
        self.storage_quota_overrides.remove(origin);
    }

    pub(crate) fn storage_usage_for_origin(
        &self,
        serialized_origin: &str,
    ) -> Result<BrowserContextOriginStorageUsage, String> {
        let local_storage_usage = {
            let store = self.storage_partition.web_storage_store().lock();
            usize_to_u64_saturating(store.usage_bytes_for_origin_areas(serialized_origin))
        };
        let indexed_db_usage = moli_core::storage::indexed_db_origins_with_prefix_usage_bytes(
            self.storage_partition.indexed_db_manager(),
            &moli_storage_key::storage_key_prefix_for_origin(serialized_origin),
        )?;
        let storage_buckets_usage = self.storage_bucket_usage_for_origin(serialized_origin)?;
        Ok(BrowserContextOriginStorageUsage {
            local_storage_usage,
            indexed_db_usage,
            storage_buckets_usage,
            total_usage: local_storage_usage
                .saturating_add(indexed_db_usage)
                .saturating_add(storage_buckets_usage),
        })
    }

    fn storage_bucket_usage_for_origin(&self, serialized_origin: &str) -> Result<u64, String> {
        let (bucket_identities, cache_usage, storage_service) = {
            let store = self.storage_partition.storage_bucket_store().lock();
            (
                store.bucket_identities_for_origin_areas(serialized_origin),
                store.cache_usage_for_origin_areas(serialized_origin),
                store.storage_service(),
            )
        };
        let mut usage = cache_usage;
        for identity in bucket_identities {
            let indexed_db_usage = moli_core::storage::indexed_db_origin_usage_bytes(
                self.storage_partition.indexed_db_manager(),
                &identity.indexed_db_storage_key(),
            )?;
            let opfs_usage = storage_service
                .opfs_usage(&identity.locator())
                .map_err(|error| format!("FailedToReadStorageBucketOpfsUsage: {error}"))?;
            usage = usage
                .saturating_add(indexed_db_usage)
                .saturating_add(opfs_usage);
        }
        Ok(usage)
    }

    fn complete_storage_bucket_deletions(
        &self,
        cleanups: Vec<StorageBucketIdentity>,
    ) -> Result<(), String> {
        let bucket_store = self.storage_partition.storage_bucket_store();
        for cleanup in cleanups {
            moli_core::storage::complete_storage_bucket_deletion(bucket_store, &cleanup)
                .map_err(|error| format!("FailedToCompleteStorageBucketDeletion: {error}"))?;
        }
        Ok(())
    }

    pub(crate) fn renderer_runtime(&self) -> RendererBrowserContextRuntime {
        self.renderer_runtime_owner
            .as_ref()
            .expect("BrowserContext renderer owner was already taken for teardown")
            .handle()
    }

    pub(crate) fn renderer_runtime_owner_access(&self) -> RendererBrowserContextRuntimeOwnerAccess {
        self.renderer_runtime_owner
            .as_ref()
            .expect("BrowserContext renderer owner was already taken for teardown")
            .owner_access()
    }

    pub(crate) fn take_renderer_runtime_owner_for_teardown(
        &mut self,
    ) -> Option<RendererBrowserContextRuntimeOwner> {
        self.renderer_runtime_owner.take()
    }

    pub(crate) fn routes_renderer_browser_context_runtime(
        &self,
        runtime_id: moli_core::RendererBrowserContextRuntimeId,
    ) -> bool {
        self.renderer_runtime().id() == runtime_id
    }

    pub(crate) fn target_id_for_renderer_owner_local_host_id(
        &self,
        owner_local_host_id: moli_core::RendererOwnerLocalHostId,
    ) -> Option<String> {
        if self
            .loaded_page()
            .is_some_and(|page| page.renderer_owner_local_host_id() == owner_local_host_id)
        {
            return self.active_target_id_owned();
        }
        self.background_targets().find_map(|target| {
            target
                .loaded_page()
                .is_some_and(|page| page.renderer_owner_local_host_id() == owner_local_host_id)
                .then(|| target.target_id().to_owned())
        })
    }

    pub(crate) fn moli_memory_diagnostics(&self) -> Value {
        let target_infos = self.devtools_target_infos();
        let loaded_document_page_count = self.loaded_document_page_count();
        let pending_document_page_build_count = self.pending_document_page_build_count();
        let loaded_document_renderer_owner_count = self
            .loaded_document_renderer_owner_ids_for_diagnostics()
            .len();
        let estimated_document_isolate_count =
            self.loaded_document_isolate_ids_for_diagnostics().len()
                + pending_document_page_build_count;
        let page_target_pending_inspector_await_count =
            self.page_target_pending_inspector_await_count_for_diagnostics();
        let shared_worker_target_pending_inspector_await_count =
            self.shared_worker_target_pending_inspector_await_count_for_diagnostics();
        let service_worker_target_pending_inspector_await_count =
            self.service_worker_target_pending_inspector_await_count_for_diagnostics();
        let active_target = self.page_targets.active();
        let runtime_session_diagnostics = active_target
            .map(|target| {
                let primary = target.devtools_sessions.primary();
                let attached_pending_inspector_await_count: usize = target
                    .devtools_sessions
                    .attached_states()
                    .map(DevToolsSessionState::pending_inspector_await_count)
                    .sum();
                json!({
                    "runtimeEnabled": primary.runtime_session_state.runtime_frontend_enabled,
                    "inspectorEnabled": primary.runtime_session_state.inspector_enabled,
                    "inspectorTargetCrashedDelivered": primary.runtime_session_state.inspector_target_crashed_delivered(),
                    "profilerCommandStateSource": "renderer-v8-inspector-agent",
                    "v8InspectorStateBytes": primary.inspector_session_state.v8_state.as_ref().map_or(0, |state| state.len()),
                    "attachedDevToolsSessionStateCount": target.devtools_sessions.attached_len(),
                    "pendingInspectorAwaitCount": target.devtools_sessions.pending_inspector_await_count(),
                    "primaryPendingInspectorAwaitCount": primary.pending_inspector_await_count(),
                    "attachedPendingInspectorAwaitCount": attached_pending_inspector_await_count,
                })
            })
            .unwrap_or(Value::Null);
        let page_session_diagnostics = active_target
            .map(|target| {
                let primary = target.devtools_sessions.primary();
                json!({
                    "pageLifecycleEvents": primary.page_session_state.page_lifecycle_events,
                    "logEnabled": primary.page_session_state.log_enabled,
                    "consoleEnabled": primary.console_output_session_state.console_enabled,
                    "performanceEnabled": primary
                        .page_session_state
                        .performance
                        .enabled(),
                    "performanceTimeDomain": primary
                        .page_session_state
                        .performance
                        .time_domain()
                        .as_str(),
                    "pageFontFamilyCount": primary.page_session_state.page_font_families.len(),
                })
            })
            .unwrap_or(Value::Null);
        let target_host_state_diagnostics = json!({
            "targetHostCount": self.page_targets.len(),
            "pageSessionStateCount": self.page_targets.iter()
                .filter(|target| target.has_non_default_session_state())
                .count(),
            "targetOwnerStateWithPendingInspectorAwaitCount": self.page_targets.iter()
                .filter(|target| target.has_pending_inspector_awaits())
                .count(),
            "pendingInspectorAwaitCount": self.page_targets.iter()
                .map(|target| target.pending_inspector_await_count())
                .sum::<usize>(),
            "nonEmptyFetchStateCount": self.page_targets.iter()
                .filter(|target| !target.fetch_owner.pending_state().is_empty())
                .count(),
            "ownerStates": self.page_targets.iter().map(|target| json!({
                "targetId": target.target_id(),
                "ownerState": target.owner_state.moli_memory_diagnostics(),
            })).collect::<Vec<_>>(),
        });
        json!({
            "id": self.id,
            "storagePartition": {
                "kind": self.storage_partition_kind_label(),
                "id": self.storage_partition_id(),
            },
            "hasActiveTarget": self.has_active_target(),
            "activeTargetId": self.active_target_id(),
            "hasActiveSession": self.has_active_session(),
            "activeLoadedPage": self.has_loaded_page(),
            "activePageAttachment": self.page_attachment_id().map(|attachment_id| json!({
                "id": attachment_id.get(),
                "targetId": self.active_target_id(),
            })),
            "backgroundTargetCount": self.background_target_count(),
            "backgroundLoadedPageCount": self
                .background_targets()
                .filter(|target| target.has_loaded_page())
                .count(),
            "targetInfoCount": target_infos.len(),
            "attachedTargetInfoCount": target_infos
                .iter()
                .filter(|info| info.attached)
                .count(),
            "attachedTargetSessionCount": self
                .page_targets
                .iter()
                .map(|target| target.devtools_sessions.attached_len())
                .sum::<usize>(),
            "targetOpenerCount": self.target_opener_ids.len(),
            "targetOpenerFrameCount": self.target_opener_frame_ids.len(),
            "targetCanAccessOpenerCount": self.target_can_access_opener.len(),
            "targetWindowNameCount": self.named_auxiliary_targets.len(),
            "defaultDocumentStartScriptCount": self.default_document_start_scripts.len(),
            "domRemoteObjectNodeCacheCount": active_target
                .map_or(0, |target| target.dom_remote_object_node_cache.len()),
            "sharedWorkerTargetCount": self.shared_worker_targets.len(),
            "serviceWorkerTargetCount": self.service_worker_targets.len(),
            "pendingInspectorAwaitCount": page_target_pending_inspector_await_count
                + shared_worker_target_pending_inspector_await_count
                + service_worker_target_pending_inspector_await_count,
            "pageTargetPendingInspectorAwaitCount": page_target_pending_inspector_await_count,
            "pageTargetWithPendingInspectorAwaitCount": self
                .page_target_with_pending_inspector_await_count_for_diagnostics(),
            "sharedWorkerTargetPendingInspectorAwaitCount": shared_worker_target_pending_inspector_await_count,
            "sharedWorkerTargetWithPendingInspectorAwaitCount": self
                .shared_worker_target_with_pending_inspector_await_count_for_diagnostics(),
            "serviceWorkerTargetPendingInspectorAwaitCount": service_worker_target_pending_inspector_await_count,
            "serviceWorkerTargetWithPendingInspectorAwaitCount": self
                .service_worker_target_with_pending_inspector_await_count_for_diagnostics(),
            "isolateScope": {
                "documentPageAccountingModel": "distinct-loaded-isolates-plus-pending-pages",
                "loadedDocumentPageCount": loaded_document_page_count,
                "loadedDocumentRendererOwnerCount": loaded_document_renderer_owner_count,
                "pendingDocumentPageBuildCount": pending_document_page_build_count,
                "estimatedDocumentIsolateCount": estimated_document_isolate_count,
                "sharedWorkerTargetCount": self.shared_worker_targets.len(),
                "serviceWorkerTargetCount": self.service_worker_targets.len(),
                "browserContextRuntime": self.renderer_runtime().moli_memory_diagnostics(),
            },
            "runtimeSession": runtime_session_diagnostics,
            "pageSession": page_session_diagnostics,
            "activeRuntimeSlot": active_target
                .map(|target| target.runtime_slot.moli_memory_diagnostics()),
            "activeFetch": active_target
                .map(|target| target.fetch_owner.moli_memory_diagnostics()),
            "activeOwnerState": active_target
                .map(|target| target.owner_state.moli_memory_diagnostics()),
            "targetHosts": target_host_state_diagnostics,
        })
    }

    pub(crate) fn loaded_document_page_count(&self) -> usize {
        self.page_targets
            .iter()
            .filter(|target| target.has_loaded_page())
            .count()
    }

    pub(crate) fn pending_document_page_build_count(&self) -> usize {
        self.page_targets
            .iter()
            .filter(|target| {
                target
                    .runtime_slot()
                    .has_pending_initial_document_page_build()
            })
            .count()
    }

    pub(crate) fn target_has_pending_initial_document_page_build(&self, target_id: &str) -> bool {
        self.page_target(target_id).is_some_and(|target| {
            target
                .runtime_slot()
                .has_pending_initial_document_page_build()
        })
    }

    pub(crate) fn target_transient_no_page_reason_for_protocol_output(
        &self,
        target_id: &str,
    ) -> Option<&'static str> {
        self.page_target(target_id).and_then(|target| {
            target
                .runtime_slot()
                .transient_no_page_reason_for_protocol_output()
        })
    }

    pub(crate) fn assert_target_materialized_initial_empty_document_has_page(
        &self,
        target_id: &str,
    ) -> Result<(), String> {
        let Some(target) = self.page_target(target_id) else {
            return Ok(());
        };
        materialized_initial_empty_document_missing_page_error(
            target_id,
            &target.owner_state,
            target.has_loaded_page(),
        )
        .map_or(Ok(()), Err)
    }

    pub(crate) fn can_install_current_initial_empty_document_page(&self, target_id: &str) -> bool {
        let Some(target) = self.page_target(target_id) else {
            return false;
        };
        !target.has_loaded_page()
            && target
                .owner_state
                .can_install_current_initial_empty_document_page()
    }

    /// Reports whether one exact Page target is still on its materialized
    /// initial empty Document and has a non-empty target URL left to load.
    ///
    /// This target-addressed query is used when the last debugger barrier is
    /// released by detaching its session, after that session can no longer be
    /// used as a routing key.
    pub(crate) fn target_needs_initial_document_navigation(&self, target_id: &str) -> bool {
        let Some(target) = self.page_target(target_id) else {
            return false;
        };
        let owner_state = &target.owner_state;
        let Some(initial_url) = owner_state.initial_empty_document_url_if_current() else {
            return false;
        };
        target.target_url() != initial_url
            && !owner_state.initial_empty_document_pending_cross_document_navigation()
    }

    pub(crate) fn loaded_document_isolate_ids_for_diagnostics(&self) -> HashSet<usize> {
        self.loaded_pages_for_diagnostics()
            .map(moli_core::page::Page::document_isolate_identity_for_diagnostics)
            .collect()
    }

    pub(crate) fn loaded_document_renderer_owner_ids_for_diagnostics(&self) -> HashSet<u64> {
        let mut owner_ids = HashSet::new();
        if let Some(page) = self.loaded_page() {
            owner_ids.insert(page.renderer_owner_local_host_id().as_u64());
        }
        for target in self.background_targets() {
            if let Some(page) = target.loaded_page() {
                owner_ids.insert(page.renderer_owner_local_host_id().as_u64());
            }
        }
        owner_ids
    }

    pub(crate) fn pending_document_renderer_owner_ids_for_diagnostics(&self) -> HashSet<u64> {
        HashSet::new()
    }

    pub(crate) fn document_renderer_owner_ids_for_diagnostics(&self) -> HashSet<u64> {
        let mut owner_ids = self.loaded_document_renderer_owner_ids_for_diagnostics();
        owner_ids.extend(self.pending_document_renderer_owner_ids_for_diagnostics());
        owner_ids
    }

    pub(crate) fn dedicated_worker_running_worker_isolate_count_for_diagnostics(&self) -> usize {
        self.loaded_pages_for_diagnostics()
            .map(
                moli_core::page::Page::dedicated_worker_running_worker_isolate_count_for_diagnostics,
            )
            .sum()
    }

    fn loaded_pages_for_diagnostics(&self) -> impl Iterator<Item = &moli_core::page::Page> {
        self.loaded_page().into_iter().chain(
            self.background_targets()
                .filter_map(|target| target.loaded_page()),
        )
    }

    pub(crate) fn page_target_pending_inspector_await_count_for_diagnostics(&self) -> usize {
        self.page_targets
            .iter()
            .map(|target| target.pending_inspector_await_count())
            .sum()
    }

    pub(crate) fn has_pending_javascript_dialog(&self) -> bool {
        self.page_targets
            .iter()
            .any(PageTargetHost::has_pending_javascript_dialog)
    }

    pub(crate) fn page_target_with_pending_inspector_await_count_for_diagnostics(&self) -> usize {
        self.page_targets
            .iter()
            .filter(|target| target.has_pending_inspector_awaits())
            .count()
    }

    pub(crate) fn shared_worker_target_pending_inspector_await_count_for_diagnostics(
        &self,
    ) -> usize {
        self.shared_worker_targets
            .values()
            .map(SharedWorkerTargetState::pending_inspector_await_count_all_sessions)
            .sum()
    }

    pub(crate) fn shared_worker_target_with_pending_inspector_await_count_for_diagnostics(
        &self,
    ) -> usize {
        self.shared_worker_targets
            .values()
            .filter(|target| target.has_pending_inspector_awaits())
            .count()
    }

    pub(crate) fn service_worker_target_pending_inspector_await_count_for_diagnostics(
        &self,
    ) -> usize {
        self.service_worker_targets
            .values()
            .map(ServiceWorkerTargetState::pending_inspector_await_count_all_sessions)
            .sum()
    }

    pub(crate) fn service_worker_target_with_pending_inspector_await_count_for_diagnostics(
        &self,
    ) -> usize {
        self.service_worker_targets
            .values()
            .filter(|target| target.has_pending_inspector_awaits())
            .count()
    }

    pub(crate) fn shared_worker_runtime_diagnostics_for_diagnostics(
        &self,
    ) -> RendererSharedWorkerRuntimeDiagnostics {
        self.renderer_runtime()
            .shared_worker_runtime_diagnostics_for_diagnostics()
    }

    #[cfg(test)]
    pub(crate) fn start_document_navigation_for_active_target(
        &mut self,
        loader_id: String,
    ) -> Option<DocumentNavigationToken> {
        let target_id = self.active_target_id()?.to_owned();
        self.start_document_navigation_for_target(&target_id, loader_id)
    }

    pub(crate) fn start_document_navigation_for_target(
        &mut self,
        target_id: &str,
        loader_id: String,
    ) -> Option<DocumentNavigationToken> {
        let target = self.page_target_mut(target_id)?;
        let token = target
            .runtime_slot
            .start_document_navigation(target_id.to_owned(), loader_id);
        self.mark_target_initial_empty_document_pending_cross_document_navigation(target_id);
        Some(token)
    }

    pub(crate) fn accepts_pending_document_navigation_event(
        &self,
        token: &DocumentNavigationToken,
    ) -> bool {
        self.page_target(&token.target_id).is_some_and(|target| {
            target
                .runtime_slot()
                .accepts_pending_document_navigation_event(token)
        })
    }

    pub(crate) fn document_navigation_cancellation_handle(
        &self,
        token: &DocumentNavigationToken,
    ) -> Option<moli_fetch::FetchCancelHandle> {
        self.page_target(&token.target_id).and_then(|target| {
            target
                .runtime_slot()
                .document_navigation_cancellation_handle(token)
        })
    }

    pub(crate) fn settle_background_navigation_completion(
        &mut self,
        token: &DocumentNavigationToken,
    ) -> bool {
        self.page_target_mut(&token.target_id)
            .is_some_and(|target| {
                target
                    .runtime_slot
                    .settle_background_navigation_completion(token)
            })
    }

    pub(crate) fn has_inflight_background_navigation(&self) -> bool {
        self.page_targets
            .iter()
            .any(|target| target.runtime_slot().has_inflight_background_navigation())
    }

    pub(crate) fn has_inflight_background_navigation_for_target(&self, target_id: &str) -> bool {
        self.page_target(target_id)
            .is_some_and(|target| target.runtime_slot().has_inflight_background_navigation())
    }

    pub(crate) fn accepts_document_body_completion_event(
        &self,
        token: &DocumentNavigationToken,
    ) -> bool {
        self.page_target(&token.target_id).is_some_and(|target| {
            target
                .runtime_slot()
                .accepts_document_body_completion_event(token)
        })
    }

    pub(crate) fn has_pending_document_navigation_for_target(
        &self,
        target_id: Option<&str>,
    ) -> bool {
        let Some(target_id) = target_id else {
            return false;
        };
        self.page_target(target_id)
            .is_some_and(|target| target.runtime_slot().has_pending_document_navigation())
    }

    pub(crate) fn clear_pending_document_navigation_for_target_if_loader_matches(
        &mut self,
        target_id: Option<&str>,
        loader_id: &str,
    ) {
        let Some(target_id) = target_id else {
            return;
        };
        let cleared = self.page_target_mut(target_id).is_some_and(|target| {
            target
                .runtime_slot
                .clear_pending_document_navigation_if_loader_matches(loader_id)
        });
        if cleared {
            self.clear_target_initial_empty_document_pending_cross_document_navigation(target_id);
        }
    }

    pub(crate) fn commit_document_navigation_if_matches(
        &mut self,
        token: &DocumentNavigationToken,
    ) {
        let committed = self
            .page_target_mut(&token.target_id)
            .is_some_and(|target| {
                target
                    .runtime_slot
                    .commit_pending_document_navigation_if_matches(token)
            });
        if committed {
            self.mark_target_initial_empty_document_exited(&token.target_id);
        }
    }

    #[cfg(test)]
    pub(crate) fn clear_document_navigation_state_for_active_target(&mut self) {
        self.active_page_target_mut()
            .runtime_slot
            .clear_document_navigation_state();
    }

    pub(crate) fn clear_indexed_db_origin(&self, origin: &str) -> Result<(), String> {
        moli_core::storage::clear_indexed_db_origin(
            self.storage_partition.indexed_db_manager(),
            origin,
        )
    }

    pub(crate) fn clear_site_data_for_origin(
        &mut self,
        origin: &url::Url,
        options: SiteDataClearOptions,
    ) -> Result<(), String> {
        if options.cookies
            && let Some(host) = origin.host_str().map(str::to_ascii_lowercase)
        {
            let mut cookie_store = self.storage_partition.cookie_store().lock();
            cookie_store.delete_cookies(None, None, None, Some(host.as_str()));
        }

        let serialized_origin = origin.origin().ascii_serialization();
        if options.local_storage {
            let mut store = self.storage_partition.web_storage_store().lock();
            store
                .try_clear_origin_areas(&serialized_origin)
                .map_err(|error| format!("FailedToClearLocalStorage: {error}"))?;
        }

        if options.indexed_db {
            moli_core::storage::clear_indexed_db_origins_with_prefix(
                self.storage_partition.indexed_db_manager(),
                &moli_storage_key::storage_key_prefix_for_origin(&serialized_origin),
            )?;
        }

        if options.storage_buckets {
            let cleanups = self
                .storage_partition
                .storage_bucket_store()
                .lock()
                .clear_origin_areas(&serialized_origin)
                .map_err(|error| format!("FailedToClearStorageBuckets: {error}"))?;
            self.complete_storage_bucket_deletions(cleanups)?;
        }

        if options.http_cache {
            self.clear_http_cache_for_origin(origin)?;
        }

        Ok(())
    }

    pub(crate) fn clear_site_data_for_storage_key(
        &mut self,
        storage_key: &moli_storage_key::MoliStorageKey,
        options: SiteDataClearOptions,
    ) -> Result<(), String> {
        let origin = url::Url::parse(storage_key.origin())
            .map_err(|error| format!("UnableToDeserializeStorageKeyOrigin: {error}"))?;
        if origin.origin().ascii_serialization() != storage_key.origin() {
            return Err("UnableToDeserializeStorageKeyOrigin".to_owned());
        }

        if options.cookies
            && let Some(host) = origin.host_str().map(str::to_ascii_lowercase)
        {
            let mut cookie_store = self.storage_partition.cookie_store().lock();
            cookie_store.delete_cookies(None, None, None, Some(host.as_str()));
        }

        let serialized_storage_key = storage_key.serialized_storage_key();
        if options.local_storage {
            let mut store = self.storage_partition.web_storage_store().lock();
            store
                .try_clear_origin(&serialized_storage_key)
                .map_err(|error| format!("FailedToClearLocalStorage: {error}"))?;
        }

        if options.indexed_db {
            self.clear_indexed_db_origin(&serialized_storage_key)?;
        }

        if options.storage_buckets {
            let cleanups = self
                .storage_partition
                .storage_bucket_store()
                .lock()
                .clear_origin(&serialized_storage_key)
                .map_err(|error| format!("FailedToClearStorageBuckets: {error}"))?;
            self.complete_storage_bucket_deletions(cleanups)?;
        }

        if options.http_cache {
            self.clear_http_cache_for_origin(&origin)?;
        }

        Ok(())
    }

    pub(crate) fn clear_http_cache(&self) -> Result<(), String> {
        let Some(cache_root) = self.http_cache_root.as_ref() else {
            return Ok(());
        };
        moli_fetch::clear_http_cache_root(cache_root, self.http_cache_max_bytes)
            .map_err(|error| format!("FailedToClearHttpCache: {error}"))
    }

    pub(crate) fn clear_http_cache_for_origin(&self, origin: &url::Url) -> Result<usize, String> {
        let Some(cache_root) = self.http_cache_root.as_ref() else {
            return Ok(0);
        };
        moli_fetch::clear_http_cache_root_for_origin(cache_root, self.http_cache_max_bytes, origin)
            .map_err(|error| format!("FailedToClearHttpCache: {error}"))
    }

    pub(crate) fn snapshot_cookies(&self) -> Vec<StoredCookie> {
        self.storage_partition.cookie_store().lock().cookies()
    }

    #[cfg(test)]
    pub(crate) fn store_response_cookie_headers_for_test(
        &self,
        response_url: &url::Url,
        response_headers: &[(String, Vec<u8>)],
    ) {
        self.with_cookie_store_mut(|store| {
            store.store_response_headers(response_url, response_headers);
        });
    }

    #[cfg(test)]
    pub(crate) fn cookie_store_for_test(&self) -> &SharedBrowserCookieStore {
        self.storage_partition.cookie_store()
    }

    #[cfg(test)]
    pub(crate) fn web_storage_store_for_test(&self) -> &SharedWebStorageStore {
        self.storage_partition.web_storage_store()
    }

    #[cfg(test)]
    pub(crate) fn session_storage_store_for_test(&self) -> &SharedWebStorageStore {
        self.active_page_target().session_storage_namespace.store()
    }

    #[cfg(test)]
    pub(crate) fn indexed_db_manager_for_test(&self) -> &SharedIndexedDbManager {
        self.storage_partition.indexed_db_manager()
    }

    #[cfg(test)]
    pub(crate) fn storage_bucket_store_for_test(&self) -> &SharedStorageBucketStore {
        self.storage_partition.storage_bucket_store()
    }

    #[cfg(test)]
    pub(crate) fn replace_storage_bucket_store_for_test(
        &mut self,
        storage_bucket_store: SharedStorageBucketStore,
    ) {
        self.storage_partition
            .replace_storage_bucket_store(storage_bucket_store);
    }

    #[cfg(test)]
    pub(crate) fn upsert_cookie_for_test(
        &self,
        cookie: StoredCookie,
    ) -> moli_cookie_jar::StoredCookieSetReport {
        self.with_cookie_store_mut(|store| {
            store.upsert_with_request_url_report(cookie, None, CookieSource::Cdp)
        })
    }

    #[cfg(test)]
    pub(crate) fn test_last_cookie_access_index(
        &self,
        domain: &str,
        path: &str,
        name: &str,
    ) -> Option<u64> {
        self.with_cookie_store(|store| store.test_last_access_index(domain, path, name))
    }

    #[cfg(test)]
    pub(crate) fn delete_cookies(
        &mut self,
        name: Option<&str>,
        domain: Option<&str>,
        path: Option<&str>,
        url_host: Option<&str>,
    ) {
        self.delete_cookies_with_partition_key(name, domain, path, url_host, None);
    }

    pub(crate) fn delete_cookies_with_partition_key(
        &mut self,
        name: Option<&str>,
        domain: Option<&str>,
        path: Option<&str>,
        url_host: Option<&str>,
        partition_key: Option<&moli_cookie_jar::StoredCookiePartitionKey>,
    ) {
        let mut cookie_store = self.storage_partition.cookie_store().lock();
        cookie_store.delete_cookies_with_partition_key(name, domain, path, url_host, partition_key);
    }

    pub(crate) fn active_target_id(&self) -> Option<&str> {
        self.page_targets.active_target_id()
    }

    pub(crate) fn active_target_id_owned(&self) -> Option<String> {
        self.active_target_id().map(str::to_owned)
    }

    pub(crate) fn effective_active_browser_identity_override_owned(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.page_targets
            .active()
            .and_then(|host| host.effective_policy().browser_identity_override().cloned())
            .or_else(|| self.default_browser_identity.profile_owned())
    }

    pub(crate) fn effective_active_user_agent_override(&self) -> Option<&str> {
        self.page_targets
            .active()
            .and_then(PageTargetHost::effective_user_agent_override)
            .or_else(|| {
                self.default_browser_identity
                    .profile()
                    .map(moli_browser_profile::BrowserIdentityProfile::user_agent)
            })
    }

    pub(crate) fn effective_active_renderer_browser_identity_override_owned(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.page_targets
            .active()
            .and_then(|host| host.effective_renderer_browser_identity_override_owned())
            .or_else(|| self.default_browser_identity.profile_owned())
    }

    pub(crate) fn default_browser_identity_override(
        &self,
    ) -> Option<&moli_browser_profile::BrowserIdentityProfile> {
        self.default_browser_identity.profile()
    }

    pub(crate) fn default_browser_identity_override_owned(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.default_browser_identity.profile_owned()
    }

    pub(crate) fn set_default_user_agent_override(
        &mut self,
        user_agent: Option<String>,
        fallback: &moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.default_browser_identity
            .set_user_agent(user_agent, fallback);
    }

    pub(crate) fn set_default_locale_override(
        &mut self,
        locale: Option<String>,
        fallback: &moli_browser_profile::BrowserIdentityProfile,
    ) -> Result<(), &'static str> {
        self.environment_owner.set_locale(locale.as_deref())?;
        self.default_browser_identity
            .set_accept_language(locale, fallback);
        Ok(())
    }

    pub(crate) fn set_default_timezone_override(
        &mut self,
        timezone: Option<String>,
    ) -> Result<(), &'static str> {
        self.environment_owner.set_timezone(timezone.as_deref())
    }

    #[cfg(test)]
    pub(crate) fn replace_default_browser_identity_override_for_test(
        &mut self,
        identity: moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.default_browser_identity.replace_profile(identity);
    }

    pub(crate) fn effective_active_network_conditions(&self) -> Option<EmulatedNetworkConditions> {
        self.page_targets
            .active()
            .and_then(|host| host.effective_emulation_state.network_conditions)
            .or(self.default_network_conditions)
            .or(self.global_network_conditions)
    }

    pub(crate) fn effective_active_http_proxy_override_owned(&self) -> Option<String> {
        self.page_targets
            .active()
            .and_then(|host| host.http_proxy_override.clone())
            .or_else(|| self.default_http_proxy_override.clone())
    }

    pub(crate) fn effective_active_http_no_proxy_override_owned(&self) -> Option<String> {
        self.page_targets
            .active()
            .and_then(|host| host.http_no_proxy_override.clone())
            .or_else(|| self.default_http_no_proxy_override.clone())
    }

    pub(crate) fn effective_active_tls_verify_host_override(&self) -> Option<bool> {
        self.page_targets
            .active()
            .and_then(|host| host.tls_verify_host_override)
            .or(self.default_tls_verify_host_override)
    }

    pub(crate) fn effective_active_geolocation_override(
        &self,
    ) -> Option<EmulatedGeolocationOverrideState> {
        self.page_targets
            .active()
            .and_then(|host| host.effective_emulation_state.geolocation_override.clone())
            .or_else(|| self.default_geolocation_override.clone())
            .or_else(|| self.global_geolocation_override.clone())
    }

    pub(crate) fn effective_active_network_offline(&self) -> bool {
        self.effective_active_network_conditions()
            .is_some_and(|conditions| !conditions.navigator_online())
    }

    pub(crate) fn effective_network_conditions_for_target(
        &self,
        target_id: &str,
    ) -> Option<EmulatedNetworkConditions> {
        self.page_target(target_id)
            .and_then(|state| state.effective_emulation_state.network_conditions)
            .or(self.default_network_conditions)
            .or(self.global_network_conditions)
    }

    pub(crate) fn effective_network_offline_for_target(&self, target_id: &str) -> bool {
        self.effective_network_conditions_for_target(target_id)
            .is_some_and(|conditions| !conditions.navigator_online())
    }

    pub(crate) fn has_active_target(&self) -> bool {
        self.page_targets.active().is_some()
    }

    pub(crate) fn is_active_target(&self, target_id: &str) -> bool {
        self.active_target_id() == Some(target_id)
    }

    pub(crate) fn set_active_target_id(&mut self, target_id: impl Into<String>) {
        let target_id = target_id.into();
        if self.page_targets.get(&target_id).is_none() {
            let inserted = self.insert_page_target_host(PageTargetHost::empty(target_id.clone()));
            debug_assert!(inserted, "new page target id must be unique");
        }
        let selected = self.page_targets.select(&target_id);
        debug_assert!(selected, "registered page target must be selectable");
    }

    pub(crate) fn active_session_id(&self) -> Option<&str> {
        self.page_targets.active()?.session_id()
    }

    pub(crate) fn active_session_id_owned(&self) -> Option<String> {
        self.active_session_id().map(str::to_owned)
    }

    pub(crate) fn has_active_session(&self) -> bool {
        self.active_session_id().is_some()
    }

    pub(crate) fn active_target_is_unclaimed_default_placeholder(
        &self,
        default_target_id: &str,
    ) -> bool {
        self.active_target_id() == Some(default_target_id)
            && !self.has_active_session()
            && !self.has_loaded_page()
            && self.background_target_count() == 0
            && self.shared_worker_targets.is_empty()
            && self.dedicated_worker_targets.is_empty()
            && self.service_worker_targets.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn attach_active_session(&mut self, session_id: impl Into<String>) {
        self.active_page_target_mut()
            .attach_session(session_id.into());
    }

    #[cfg(test)]
    pub(crate) fn detach_active_session(&mut self) -> Option<String> {
        self.page_targets.active_mut()?.detach_session()
    }

    pub(crate) fn target_url(&self) -> &str {
        self.active_page_target().target_identity.url()
    }

    pub(crate) fn set_target_url(&mut self, url: String) {
        self.active_page_target_mut().target_identity.set_url(url);
    }

    #[cfg(test)]
    pub(crate) fn set_target_security_origin(&mut self, security_origin: String) {
        self.active_page_target_mut()
            .target_identity
            .set_security_origin(security_origin);
    }

    #[cfg(test)]
    pub(crate) fn set_target_secure_context_type(&mut self, secure_context_type: String) {
        self.active_page_target_mut()
            .target_identity
            .set_secure_context_type(secure_context_type);
    }
}

fn materialized_initial_empty_document_missing_page_error(
    target_id: &str,
    owner_state: &TargetOwnerState,
    has_loaded_page: bool,
) -> Option<String> {
    if owner_state.has_materialized_current_initial_empty_document() && !has_loaded_page {
        return Some(format!(
            "TargetInitialEmptyDocumentMissingPage: target {target_id} has materialized current initial empty document without loaded Page"
        ));
    }
    None
}

pub(crate) fn seed_initial_cookies(
    cookie_store: &SharedBrowserCookieStore,
    initial_cookies: impl IntoIterator<Item = StoredCookie>,
) {
    let mut store = cookie_store.lock();
    for cookie in initial_cookies {
        let _ = store.upsert_with_request_url_report(cookie, None, CookieSource::Cdp);
    }
}