Skip to content

armgit / moli

Public Imported from GitHub
0

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

60.2 KB
Raw Blame
use std::{
    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
    ops::{Index, IndexMut},
};

use super::{
    page_slot::RuntimeBindingDefinition,
    pending_renderer_command::{
        DuplicatePendingRendererCommand, PreparedRendererCallDispatch, PreparedRendererCallReplay,
        PreparedRendererCallTermination, RegisterRendererCallError, RendererCallIdExhausted,
        RendererCommandCorrelation, RendererCommandDescriptor,
    },
    session::{InspectorSessionState, TargetPageSessionState, TargetRuntimeSessionState},
    target_state::{PendingInspectorAwait, TargetPendingInspectorAwaitRegistry},
};
use moli_core::{
    network::WebStorageMutationSubscription,
    page::{
        RendererInspectorProtocolConfiguration, RendererInspectorSessionRestoreSnapshot,
        V8InspectorSessionAttach,
    },
};
use moli_page_types::{
    DevToolsSessionKey, RendererDomDebuggerEventListenerBreakpoint,
    RendererDomDebuggerXhrBreakpoint,
};

/// CDP domain-handler state owned by one DevTools session.
///
/// Browser-side policy and renderer-inspector state live together here so
/// attachment, replay, and disposal all address the same session object.
#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct DevToolsSessionState {
    pub(crate) web_mcp_enabled: bool,
    pub(crate) dom_session_state: DevToolsDomSessionState,
    pub(crate) dom_debugger_event_listener_breakpoints:
        BTreeSet<RendererDomDebuggerEventListenerBreakpoint>,
    pub(crate) dom_debugger_xhr_breakpoints: BTreeSet<RendererDomDebuggerXhrBreakpoint>,
    pub(crate) page_session_state: TargetPageSessionState,
    pub(crate) runtime_session_state: TargetRuntimeSessionState,
    pub(crate) console_output_session_state: DevToolsConsoleOutputSessionState,
    pub(crate) dom_storage_session_state: DevToolsDomStorageSessionState,
    pub(crate) network_session_state: DevToolsNetworkSessionState,
    pub(crate) emulation_session_state: DevToolsEmulationSessionState,
    pub(crate) runtime_bindings: Vec<RuntimeBindingDefinition>,
    pub(crate) runtime_binding_replay_pending: BTreeSet<(String, Option<String>)>,
    pub(crate) runtime_remote_object_ids: HashSet<String>,
    pub(crate) runtime_remote_object_groups: HashMap<String, String>,
    pub(crate) runtime_remote_object_realms: HashMap<String, String>,
    pub(crate) runtime_remote_object_aliases: HashMap<String, String>,
    pub(crate) emitted_child_default_execution_context_ids: HashSet<i64>,
    pub(crate) inspector_session_state: InspectorSessionState,
    pub(crate) pending_inspector_awaits: TargetPendingInspectorAwaitRegistry,
}

/// Every DevTools session attached to one Page target.
///
/// The renderer's implicit root session is represented by `Primary`; flattened
/// target sessions use `Attached(session_id)`. Keeping both in one ordered map
/// gives attachment, disposal, replay, and effective-domain aggregation one
/// source of truth.
#[derive(Debug, PartialEq)]
pub(crate) struct DevToolsSessionRegistry {
    primary_session_id: Option<String>,
    states: BTreeMap<DevToolsSessionKey, DevToolsSessionState>,
    attached_order: Vec<String>,
    pub(crate) navigator_emulation: moli_page_types::NavigatorEmulationSessions,
    // Live, non-cloneable authority stays outside DevToolsSessionState, whose
    // snapshots may outlive attachment. Removing an entry releases its claims.
    environment_owners: BTreeMap<DevToolsSessionKey, moli_core::ProcessEnvironmentOwner>,
}

impl Default for DevToolsSessionRegistry {
    fn default() -> Self {
        Self {
            primary_session_id: None,
            states: BTreeMap::from([(
                DevToolsSessionKey::Primary,
                DevToolsSessionState::default(),
            )]),
            attached_order: Vec::new(),
            navigator_emulation: Default::default(),
            environment_owners: BTreeMap::new(),
        }
    }
}

impl DevToolsSessionRegistry {
    pub(crate) fn key_for_wire_session_id(&self, session_id: &str) -> Option<DevToolsSessionKey> {
        if self.primary_session_id() == Some(session_id) {
            return Some(DevToolsSessionKey::Primary);
        }
        self.attached(session_id)
            .map(|_| DevToolsSessionKey::Attached(session_id.to_owned()))
    }

    pub(crate) fn primary_session_id(&self) -> Option<&str> {
        self.primary_session_id.as_deref()
    }

    pub(crate) fn attach_primary(&mut self, session_id: String) {
        self.primary_session_id = Some(session_id);
    }

    #[cfg(test)]
    pub(crate) fn detach_primary(&mut self) -> Option<String> {
        self.primary_session_id.take()
    }

    pub(crate) fn primary(&self) -> &DevToolsSessionState {
        self.states
            .get(&DevToolsSessionKey::Primary)
            .expect("DevTools session registry must retain its primary session")
    }

    pub(crate) fn primary_mut(&mut self) -> &mut DevToolsSessionState {
        self.states
            .get_mut(&DevToolsSessionKey::Primary)
            .expect("DevTools session registry must retain its primary session")
    }

    pub(crate) fn session(
        &self,
        session_key: &DevToolsSessionKey,
    ) -> Option<&DevToolsSessionState> {
        self.states.get(session_key)
    }

    pub(crate) fn ensure_session(
        &mut self,
        session_key: &DevToolsSessionKey,
    ) -> &mut DevToolsSessionState {
        match session_key {
            DevToolsSessionKey::Primary => self.primary_mut(),
            DevToolsSessionKey::Attached(session_id) => self.ensure_attached(session_id),
        }
    }

    pub(crate) fn attached(&self, session_id: &str) -> Option<&DevToolsSessionState> {
        self.states
            .get(&DevToolsSessionKey::Attached(session_id.to_owned()))
    }

    pub(crate) fn ensure_attached(&mut self, session_id: &str) -> &mut DevToolsSessionState {
        if !self
            .states
            .contains_key(&DevToolsSessionKey::Attached(session_id.to_owned()))
        {
            self.attached_order.push(session_id.to_owned());
        }
        self.states
            .entry(DevToolsSessionKey::Attached(session_id.to_owned()))
            .or_default()
    }

    pub(crate) fn remove_attached(&mut self, session_id: &str) -> Option<DevToolsSessionState> {
        let key = DevToolsSessionKey::Attached(session_id.to_owned());
        self.environment_owners.remove(&key);
        self.navigator_emulation.remove(&key);
        let removed = self.states.remove(&key);
        if removed.is_some() {
            self.attached_order
                .retain(|attached| attached != session_id);
        }
        removed
    }

    /// Removes one wire session and all domain-handler state it owns.
    ///
    /// The primary handler slot remains allocated for the renderer's implicit
    /// root Inspector session, but its state is replaced atomically. Attached
    /// sessions are removed from both the state map and attachment order.
    pub(crate) fn dispose(
        &mut self,
        session_id: &str,
        session_key: &DevToolsSessionKey,
    ) -> Option<DevToolsSessionState> {
        match session_key {
            DevToolsSessionKey::Primary => {
                if self.primary_session_id() != Some(session_id) {
                    return None;
                }
                self.primary_session_id = None;
                self.environment_owners.remove(session_key);
                self.navigator_emulation.remove(session_key);
                Some(std::mem::take(self.primary_mut()))
            }
            DevToolsSessionKey::Attached(attached_session_id)
                if attached_session_id == session_id =>
            {
                self.remove_attached(session_id)
            }
            DevToolsSessionKey::Attached(_) => None,
        }
    }

    pub(crate) fn attached_len(&self) -> usize {
        self.states.len().saturating_sub(1)
    }

    pub(crate) fn attached_is_empty(&self) -> bool {
        self.attached_len() == 0
    }

    pub(crate) fn attached_entries(&self) -> impl Iterator<Item = (&str, &DevToolsSessionState)> {
        self.states.iter().filter_map(|(key, state)| match key {
            DevToolsSessionKey::Primary => None,
            DevToolsSessionKey::Attached(session_id) => Some((session_id.as_str(), state)),
        })
    }

    pub(crate) fn attached_session_ids(&self) -> impl Iterator<Item = &str> {
        self.attached_entries()
            .map(|(session_id, _state)| session_id)
    }

    pub(crate) fn attached_states(&self) -> impl Iterator<Item = &DevToolsSessionState> {
        self.attached_entries().map(|(_session_id, state)| state)
    }

    pub(crate) fn states(&self) -> impl Iterator<Item = &DevToolsSessionState> {
        self.states.values()
    }

    /// Iterates browser-side domain handlers in attachment order: the implicit
    /// primary session first, then flattened sessions in attach order. Network
    /// header merging and Emulation identity precedence expose this order.
    pub(crate) fn states_in_attachment_order(&self) -> impl Iterator<Item = &DevToolsSessionState> {
        std::iter::once(self.primary()).chain(
            self.attached_order
                .iter()
                .filter_map(|session_id| self.attached(session_id)),
        )
    }

    pub(crate) fn effective_network_policy(&self) -> DevToolsNetworkPolicyAggregate {
        let mut aggregate = DevToolsNetworkPolicyAggregate::default();
        for state in self.states_in_attachment_order() {
            let network = &state.network_session_state;
            if !network.network_enabled {
                continue;
            }
            aggregate.cache_disabled |= network.cache_disabled;
            aggregate.bypass_service_worker |= network.bypass_service_worker;
            for pattern in &network.blocked_url_patterns {
                if !aggregate.blocked_url_patterns.contains(pattern) {
                    aggregate.blocked_url_patterns.push(pattern.clone());
                }
            }
            for (name, value) in &network.extra_headers {
                if let Some(index) = aggregate
                    .extra_headers
                    .iter()
                    .position(|(existing, _)| existing.eq_ignore_ascii_case(name))
                {
                    aggregate.extra_headers[index] = (name.clone(), value.clone());
                } else {
                    aggregate.extra_headers.push((name.clone(), value.clone()));
                }
            }
        }
        aggregate
    }

    pub(crate) fn effective_network_browser_identity_override(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        Self::aggregate_browser_identity_overrides(self.states_in_attachment_order().filter_map(
            |state| {
                state
                    .emulation_session_state
                    .browser_identity_override
                    .as_ref()
            },
        ))
    }

    pub(crate) fn effective_user_agent_override(&self) -> Option<&str> {
        self.states_in_attachment_order()
            .filter_map(|state| {
                state
                    .emulation_session_state
                    .browser_identity_override
                    .as_ref()
                    .and_then(|identity| identity.user_agent.as_deref())
            })
            .last()
    }

    /// Resolves the identity exposed by the live renderer Document.
    ///
    /// Chromium applies the same session attachment precedence to renderer
    /// agents and browser-side navigation handlers. Setter order does not
    /// change the winner on either surface.
    pub(crate) fn effective_renderer_browser_identity_override(
        &self,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        self.effective_network_browser_identity_override()
    }

    fn aggregate_browser_identity_overrides<'a>(
        contributions: impl Iterator<Item = &'a DevToolsBrowserIdentityOverride>,
    ) -> Option<moli_browser_profile::BrowserIdentityProfile> {
        let mut identity_base = None;
        let mut user_agent = None;
        let mut accept_language = None;
        let mut navigator_platform = None;
        for contribution in contributions {
            identity_base = Some(&contribution.base);
            if contribution.user_agent.is_some() {
                user_agent = Some(contribution);
            }
            if contribution.accept_language.is_some() {
                accept_language = Some(contribution);
            }
            if contribution.navigator_platform.is_some() {
                navigator_platform = Some(contribution);
            }
        }
        identity_base.map(|base| {
            moli_browser_profile::BrowserIdentityProfile::from_devtools_override(
                base,
                user_agent
                    .and_then(|contribution| contribution.user_agent.clone())
                    .unwrap_or_default(),
                accept_language.and_then(|contribution| contribution.accept_language.clone()),
                navigator_platform.and_then(|contribution| contribution.navigator_platform.clone()),
                user_agent.and_then(|contribution| contribution.user_agent_metadata.clone()),
            )
        })
    }

    pub(crate) fn set_browser_identity_override(
        &mut self,
        session_key: &DevToolsSessionKey,
        browser_identity_override: Option<DevToolsBrowserIdentityOverride>,
    ) {
        if browser_identity_override.is_some() {
            self.navigator_emulation.session_mut(session_key);
        }
        let state = self.ensure_session(session_key);
        state.emulation_session_state.browser_identity_override = browser_identity_override;
    }

    pub(crate) fn set_locale_override(
        &mut self,
        session_key: &DevToolsSessionKey,
        locale_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.update_environment_owner(session_key, |owner| {
            owner.set_locale(locale_override.as_deref())
        })
    }

    pub(crate) fn set_timezone_override(
        &mut self,
        session_key: &DevToolsSessionKey,
        timezone_override: Option<String>,
    ) -> Result<(), &'static str> {
        self.update_environment_owner(session_key, |owner| {
            owner.set_timezone(timezone_override.as_deref())
        })
    }

    fn update_environment_owner(
        &mut self,
        key: &DevToolsSessionKey,
        update: impl FnOnce(&moli_core::ProcessEnvironmentOwner) -> Result<(), &'static str>,
    ) -> Result<(), &'static str> {
        let owner = self.environment_owners.entry(key.clone()).or_default();
        let result = update(owner);
        // Reconcile on both success and failure. An invalid update must retain
        // an existing claim; a rejected first claim or same-timezone non-owner
        // success must leave neither an owner entry nor a phantom session.
        if owner.has_override() {
            self.ensure_session(key);
        } else {
            self.environment_owners.remove(key);
        }
        result
    }

    #[cfg(test)]
    pub(crate) fn effective_locale_override(&self) -> Option<String> {
        self.environment_owners
            .values()
            .find_map(moli_core::ProcessEnvironmentOwner::locale)
    }

    #[cfg(test)]
    pub(crate) fn effective_timezone_override(&self) -> Option<String> {
        self.environment_owners
            .values()
            .find_map(moli_core::ProcessEnvironmentOwner::timezone)
    }

    pub(crate) fn clear_network_state(&mut self, session_key: &DevToolsSessionKey) {
        if let Some(state) = self.states.get_mut(session_key) {
            state.network_session_state = DevToolsNetworkSessionState::default();
        }
    }

    pub(crate) fn clear_emulation_policy_state(&mut self, session_key: &DevToolsSessionKey) {
        self.environment_owners.remove(session_key);
        if let Some(state) = self.states.get_mut(session_key) {
            let emulation = &mut state.emulation_session_state;
            emulation.browser_identity_override = None;
        }
    }

    pub(crate) fn states_mut(&mut self) -> impl Iterator<Item = &mut DevToolsSessionState> {
        self.states.values_mut()
    }

    pub(crate) fn has_non_default_state(&self) -> bool {
        !self.navigator_emulation.is_empty()
            || self.primary() != &DevToolsSessionState::default()
            || !self.attached_is_empty()
            || self
                .environment_owners
                .values()
                .any(moli_core::ProcessEnvironmentOwner::has_override)
    }

    pub(crate) fn has_pending_inspector_awaits(&self) -> bool {
        self.states()
            .any(DevToolsSessionState::has_pending_inspector_awaits)
    }

    pub(crate) fn pending_inspector_await_count(&self) -> usize {
        self.states()
            .map(DevToolsSessionState::pending_inspector_await_count)
            .sum()
    }

    pub(crate) fn prepare_renderer_call_replacements(
        &mut self,
        primary_session_id: Option<&str>,
        old_attachment_id: moli_page_types::RendererAgentAttachmentId,
        new_attachment_id: moli_page_types::RendererAgentAttachmentId,
    ) -> Result<PreparedRendererCallReplacements, RendererCallIdExhausted> {
        let terminations = self.prepare_renderer_call_terminations(
            primary_session_id,
            old_attachment_id,
            new_attachment_id,
        )?;
        let replays = self.prepare_renderer_call_replays(
            primary_session_id,
            old_attachment_id,
            new_attachment_id,
        )?;
        Ok(PreparedRendererCallReplacements::new(
            new_attachment_id,
            terminations,
            replays,
        ))
    }

    fn prepare_renderer_call_replays(
        &mut self,
        primary_session_id: Option<&str>,
        old_attachment_id: moli_page_types::RendererAgentAttachmentId,
        new_attachment_id: moli_page_types::RendererAgentAttachmentId,
    ) -> Result<Vec<SessionRendererCallReplay>, RendererCallIdExhausted> {
        let mut replays = Vec::new();
        for (key, state) in &mut self.states {
            let (frontend_session_id, renderer_inspector_session_id) = match key {
                DevToolsSessionKey::Primary => (primary_session_id.map(str::to_owned), None),
                DevToolsSessionKey::Attached(session_id) => {
                    (Some(session_id.clone()), Some(session_id.clone()))
                }
            };
            replays.extend(
                state
                    .prepare_renderer_call_replays(old_attachment_id, new_attachment_id)?
                    .into_iter()
                    .map(|replay| SessionRendererCallReplay {
                        frontend_session_id: frontend_session_id.clone(),
                        renderer_inspector_session_id: renderer_inspector_session_id.clone(),
                        replay,
                    }),
            );
        }
        Ok(replays)
    }

    fn prepare_renderer_call_terminations(
        &mut self,
        primary_session_id: Option<&str>,
        old_attachment_id: moli_page_types::RendererAgentAttachmentId,
        terminal_attachment_id: moli_page_types::RendererAgentAttachmentId,
    ) -> Result<Vec<SessionRendererCallTermination>, RendererCallIdExhausted> {
        let mut terminations = Vec::new();
        for (key, state) in &mut self.states {
            let frontend_session_id = match key {
                DevToolsSessionKey::Primary => primary_session_id.map(str::to_owned),
                DevToolsSessionKey::Attached(session_id) => Some(session_id.clone()),
            };
            terminations.extend(
                state
                    .prepare_renderer_call_terminations(old_attachment_id, terminal_attachment_id)?
                    .into_iter()
                    .map(|termination| SessionRendererCallTermination {
                        frontend_session_id: frontend_session_id.clone(),
                        termination,
                    }),
            );
        }
        Ok(terminations)
    }

    pub(crate) fn runtime_bindings_for_renderer(&self) -> Vec<RuntimeBindingDefinition> {
        let mut bindings = Vec::new();
        for (key, state) in &self.states {
            for binding in &state.runtime_bindings {
                let binding = binding.with_devtools_session(key.clone());
                if !bindings.iter().any(|existing| existing == &binding) {
                    bindings.push(binding);
                }
            }
        }
        bindings
    }

    pub(crate) fn runtime_inspector_restore_snapshots(
        &self,
    ) -> Vec<RendererInspectorSessionRestoreSnapshot> {
        self.states
            .iter()
            .filter_map(|(key, state)| {
                let requires_restore = state.runtime_session_state.runtime_frontend_enabled
                    || state.web_mcp_enabled
                    || state.console_output_session_state.console_enabled
                    || !state.runtime_bindings.is_empty()
                    || !state.dom_debugger_event_listener_breakpoints.is_empty()
                    || !state.dom_debugger_xhr_breakpoints.is_empty()
                    || state.inspector_session_state.v8_state.is_some();
                requires_restore.then(|| RendererInspectorSessionRestoreSnapshot {
                    inspector_session_id: key.wire_session_id().map(str::to_owned),
                    v8_attach: V8InspectorSessionAttach::from_optional_state(
                        state.inspector_session_state.v8_state.clone(),
                    ),
                    protocol_configuration: RendererInspectorProtocolConfiguration {
                        web_mcp_enabled: state.web_mcp_enabled,
                        runtime_bindings: state.runtime_bindings.clone(),
                        runtime_frontend_enabled: state
                            .runtime_session_state
                            .runtime_frontend_enabled,
                        console_frontend_enabled: state
                            .console_output_session_state
                            .console_enabled,
                        dom_debugger_event_listener_breakpoints: state
                            .dom_debugger_event_listener_breakpoints
                            .clone(),
                        dom_debugger_xhr_breakpoints: state.dom_debugger_xhr_breakpoints.clone(),
                    },
                })
            })
            .collect()
    }

    pub(crate) fn page_bypass_csp_enabled(&self) -> bool {
        self.states()
            .any(|state| state.page_session_state.page_bypass_csp_enabled)
    }
}

impl Index<DevToolsSessionKey> for DevToolsSessionRegistry {
    type Output = DevToolsSessionState;

    fn index(&self, key: DevToolsSessionKey) -> &Self::Output {
        self.states
            .get(&key)
            .expect("indexed DevTools session must be registered")
    }
}

impl IndexMut<DevToolsSessionKey> for DevToolsSessionRegistry {
    fn index_mut(&mut self, key: DevToolsSessionKey) -> &mut Self::Output {
        self.states
            .get_mut(&key)
            .expect("indexed DevTools session must be registered")
    }
}

#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct DevToolsDomSessionState {
    pub(crate) enabled: bool,
    pub(crate) include_whitespace: bool,
}

#[derive(Debug)]
pub(crate) struct SessionRendererCallReplay {
    frontend_session_id: Option<String>,
    renderer_inspector_session_id: Option<String>,
    replay: PreparedRendererCallReplay,
}

#[derive(Debug)]
pub(crate) struct SessionRendererCallTermination {
    frontend_session_id: Option<String>,
    termination: PreparedRendererCallTermination,
}

#[derive(Debug, Default)]
pub(crate) struct PreparedRendererCallReplacements {
    new_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
    terminations: Vec<SessionRendererCallTermination>,
    replays: Vec<SessionRendererCallReplay>,
}

impl PreparedRendererCallReplacements {
    fn new(
        new_attachment_id: moli_page_types::RendererAgentAttachmentId,
        terminations: Vec<SessionRendererCallTermination>,
        replays: Vec<SessionRendererCallReplay>,
    ) -> Self {
        Self {
            new_attachment_id: Some(new_attachment_id),
            terminations,
            replays,
        }
    }

    pub(crate) fn is_empty(&self) -> bool {
        self.terminations.is_empty() && self.replays.is_empty()
    }

    pub(crate) fn into_parts(
        self,
    ) -> (
        moli_page_types::RendererAgentAttachmentId,
        Vec<SessionRendererCallTermination>,
        Vec<SessionRendererCallReplay>,
    ) {
        (
            self.new_attachment_id
                .expect("prepared renderer replacements must have an attachment"),
            self.terminations,
            self.replays,
        )
    }
}

impl SessionRendererCallTermination {
    pub(crate) fn into_parts(self) -> (Option<String>, PreparedRendererCallTermination) {
        (self.frontend_session_id, self.termination)
    }
}

impl SessionRendererCallReplay {
    pub(crate) fn frontend_session_id(&self) -> Option<&str> {
        self.frontend_session_id.as_deref()
    }

    pub(crate) fn renderer_inspector_session_id(&self) -> Option<&str> {
        self.renderer_inspector_session_id.as_deref()
    }

    pub(crate) fn into_replay(self) -> PreparedRendererCallReplay {
        self.replay
    }
}

#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct DevToolsDomStorageSessionState {
    mutation_subscription: Option<WebStorageMutationSubscription>,
}

#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct DevToolsNetworkSessionState {
    pub(crate) network_enabled: bool,
    pub(crate) cache_disabled: bool,
    pub(crate) bypass_service_worker: bool,
    pub(crate) blocked_url_patterns: Vec<String>,
    pub(crate) extra_headers: moli_fetch::RequestHeaders,
    pub(crate) service_worker_fetch_diagnostic_entries: usize,
}

#[derive(Clone, Debug, PartialEq, Default)]
pub(crate) struct DevToolsEmulationSessionState {
    pub(crate) default_background_color: Option<[u8; 4]>,
    // UA, Accept-Language, and platform are independent handler contributions.
    pub(crate) browser_identity_override: Option<DevToolsBrowserIdentityOverride>,
    pub(crate) network_conditions: Option<super::EmulatedNetworkConditions>,
    pub(crate) geolocation_override: Option<super::EmulatedGeolocationOverrideState>,
    pub(crate) emulated_media: super::EmulatedMediaOverrides,
    pub(crate) emulated_device_metrics: Option<super::EmulatedDeviceMetrics>,
    pub(crate) max_touch_points: u32,
    pub(crate) emit_touch_events_for_mouse: bool,
    pub(crate) focus_emulation_enabled: bool,
    pub(crate) script_execution_disabled: bool,
    pub(crate) scrollbars_hidden: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct DevToolsBrowserIdentityOverride {
    // Keep individual command contributions instead of a flattened profile:
    // Chromium lets different sessions win UA, Accept-Language, and
    // navigator.platform independently in attachment order.
    base: moli_browser_profile::BrowserIdentityProfile,
    user_agent: Option<String>,
    accept_language: Option<String>,
    navigator_platform: Option<String>,
    user_agent_metadata: Option<moli_browser_profile::BrowserUserAgentMetadataOverride>,
}

impl DevToolsBrowserIdentityOverride {
    pub(crate) fn from_command(
        base: &moli_browser_profile::BrowserIdentityProfile,
        user_agent: String,
        accept_language: Option<String>,
        navigator_platform: Option<String>,
        user_agent_metadata: Option<moli_browser_profile::BrowserUserAgentMetadataOverride>,
    ) -> Option<Self> {
        let user_agent = (!user_agent.is_empty()).then_some(user_agent);
        let accept_language = accept_language.filter(|value| !value.is_empty());
        let navigator_platform = navigator_platform.filter(|value| !value.is_empty());
        (user_agent.is_some() || accept_language.is_some() || navigator_platform.is_some()).then(
            || Self {
                base: base.clone(),
                user_agent,
                accept_language,
                navigator_platform,
                user_agent_metadata,
            },
        )
    }

    pub(crate) fn to_browser_identity(&self) -> moli_browser_profile::BrowserIdentityProfile {
        moli_browser_profile::BrowserIdentityProfile::from_devtools_override(
            &self.base,
            self.user_agent.clone().unwrap_or_default(),
            self.accept_language.clone(),
            self.navigator_platform.clone(),
            self.user_agent_metadata.clone(),
        )
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(crate) struct DevToolsNetworkPolicyAggregate {
    pub(crate) cache_disabled: bool,
    pub(crate) bypass_service_worker: bool,
    pub(crate) blocked_url_patterns: Vec<String>,
    pub(crate) extra_headers: moli_fetch::RequestHeaders,
}

#[derive(Clone, Debug, Default, PartialEq)]
pub(crate) struct DevToolsConsoleOutputSessionState {
    pub(crate) console_enabled: bool,
    pub(crate) console_domain_entries: usize,
    pub(crate) log_output_generation: u64,
    pub(crate) log_lifecycle_entries: usize,
    pub(crate) log_network_entries: usize,
    pub(crate) log_violation_thresholds: Vec<DevToolsLogViolationThreshold>,
    pub(crate) runtime_console_entries: usize,
    pub(crate) runtime_exception_entries: usize,
    pub(crate) renderer_console_agent_owns_page_console_api_events: bool,
    pub(crate) renderer_runtime_agent_owns_page_console_api_events: bool,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct DevToolsLogViolationThreshold {
    pub(crate) name: String,
    pub(crate) threshold: f64,
}

impl DevToolsSessionState {
    pub(crate) fn upsert_runtime_binding_definition(
        &mut self,
        name: String,
        execution_context_name: Option<String>,
    ) {
        if !self.runtime_bindings.iter().any(|binding| {
            binding.name == name && binding.execution_context_name == execution_context_name
        }) {
            self.runtime_bindings.push(RuntimeBindingDefinition {
                devtools_session: None,
                name,
                execution_context_name,
            });
        }
    }

    pub(crate) fn remove_runtime_binding_definitions(&mut self, name: &str) {
        self.runtime_bindings.retain(|binding| binding.name != name);
        self.runtime_binding_replay_pending
            .retain(|(binding_name, _)| binding_name != name);
    }

    pub(crate) fn clear_runtime_binding_definitions(&mut self) {
        self.runtime_bindings.clear();
        self.runtime_binding_replay_pending.clear();
    }

    #[cfg(test)]
    pub(crate) fn register_pending_inspector_await(
        &mut self,
        cdp_request_id: u64,
        session_id: Option<&str>,
        object_group: Option<&str>,
    ) {
        self.try_register_pending_inspector_await(cdp_request_id, session_id, object_group)
            .expect("pending Inspector await frontend command id must be unique per session");
    }

    pub(crate) fn try_register_pending_inspector_await(
        &mut self,
        cdp_request_id: u64,
        session_id: Option<&str>,
        object_group: Option<&str>,
    ) -> Result<(), DuplicatePendingRendererCommand> {
        self.pending_inspector_awaits
            .try_insert(cdp_request_id, session_id, object_group)
    }

    pub(crate) fn register_pending_bidi_channel_listener(
        &mut self,
        cdp_request_id: u64,
        session_id: Option<&str>,
        object_group: Option<&str>,
        listener: crate::conn::BidiChannelListenerResidence,
    ) {
        self.pending_inspector_awaits.insert_bidi_channel_listener(
            cdp_request_id,
            session_id,
            object_group,
            listener,
        );
    }

    pub(crate) fn try_register_renderer_call(
        &mut self,
        cdp_request_id: u64,
        dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
        descriptor: RendererCommandDescriptor,
    ) -> Result<PreparedRendererCallDispatch, RegisterRendererCallError> {
        self.pending_inspector_awaits.try_register_renderer_call(
            cdp_request_id,
            dispatched_attachment_id,
            descriptor,
        )
    }

    pub(crate) fn take_renderer_call_for_frontend(
        &mut self,
        cdp_request_id: u64,
    ) -> Option<RendererCommandCorrelation> {
        self.pending_inspector_awaits
            .take_renderer_call_for_frontend(cdp_request_id)
    }

    pub(crate) fn renderer_call_for_frontend(
        &self,
        cdp_request_id: u64,
    ) -> Option<RendererCommandCorrelation> {
        self.pending_inspector_awaits
            .renderer_call_for_frontend(cdp_request_id)
    }

    pub(crate) fn renderer_command_descriptor_for_renderer_if_attachment_matches(
        &self,
        renderer_call_id: moli_page_types::RendererCallId,
        dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
    ) -> Option<RendererCommandDescriptor> {
        self.pending_inspector_awaits
            .renderer_command_descriptor_for_renderer_if_attachment_matches(
                renderer_call_id,
                dispatched_attachment_id,
            )
    }

    pub(crate) fn prepare_renderer_call_replays(
        &mut self,
        old_attachment_id: moli_page_types::RendererAgentAttachmentId,
        new_attachment_id: moli_page_types::RendererAgentAttachmentId,
    ) -> Result<Vec<PreparedRendererCallReplay>, RendererCallIdExhausted> {
        self.pending_inspector_awaits
            .prepare_renderer_call_replays(old_attachment_id, new_attachment_id)
    }

    pub(crate) fn prepare_renderer_call_terminations(
        &mut self,
        old_attachment_id: moli_page_types::RendererAgentAttachmentId,
        terminal_attachment_id: moli_page_types::RendererAgentAttachmentId,
    ) -> Result<Vec<PreparedRendererCallTermination>, RendererCallIdExhausted> {
        self.pending_inspector_awaits
            .prepare_renderer_call_terminations(old_attachment_id, terminal_attachment_id)
    }

    pub(crate) fn terminate_all_renderer_calls(
        &mut self,
        reason: &str,
    ) -> Vec<RendererCommandCorrelation> {
        self.pending_inspector_awaits
            .terminate_all_renderer_calls(reason)
    }

    pub(crate) fn take_renderer_call_for_frontend_if_matches(
        &mut self,
        cdp_request_id: u64,
        renderer_call_id: moli_page_types::RendererCallId,
        dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
    ) -> Option<RendererCommandCorrelation> {
        self.pending_inspector_awaits
            .take_renderer_call_for_frontend_if_matches(
                cdp_request_id,
                renderer_call_id,
                dispatched_attachment_id,
            )
    }

    pub(crate) fn take_frontend_command_for_renderer_if_attachment_matches(
        &mut self,
        renderer_call_id: moli_page_types::RendererCallId,
        dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
    ) -> Option<RendererCommandCorrelation> {
        self.pending_inspector_awaits
            .take_frontend_command_for_renderer_if_attachment_matches(
                renderer_call_id,
                dispatched_attachment_id,
            )
    }

    pub(crate) fn remove_pending_inspector_await(
        &mut self,
        cdp_request_id: u64,
    ) -> Option<PendingInspectorAwait> {
        self.pending_inspector_awaits.remove(cdp_request_id)
    }

    pub(crate) fn has_pending_inspector_awaits(&self) -> bool {
        !self.pending_inspector_awaits.is_empty()
    }

    pub(crate) fn pending_inspector_await_count(&self) -> usize {
        self.pending_inspector_awaits.len()
    }

    pub(crate) fn drain_pending_inspector_awaits(&mut self) -> Vec<(u64, PendingInspectorAwait)> {
        self.pending_inspector_awaits.drain_all()
    }

    pub(crate) fn register_runtime_remote_object_ids<I>(&mut self, object_ids: I)
    where
        I: IntoIterator<Item = String>,
    {
        self.runtime_remote_object_ids.extend(object_ids);
    }

    pub(crate) fn register_runtime_remote_object_ids_with_realm<I>(
        &mut self,
        object_ids: I,
        realm_id: &str,
    ) where
        I: IntoIterator<Item = String>,
    {
        for object_id in object_ids {
            self.runtime_remote_object_ids.insert(object_id.clone());
            self.runtime_remote_object_realms
                .insert(object_id, realm_id.to_owned());
        }
    }

    pub(crate) fn register_runtime_remote_object_alias_with_realm(
        &mut self,
        alias_id: String,
        object_id: String,
        realm_id: &str,
    ) {
        self.runtime_remote_object_ids.insert(object_id.clone());
        self.runtime_remote_object_realms
            .insert(object_id.clone(), realm_id.to_owned());
        self.runtime_remote_object_aliases
            .insert(alias_id.clone(), object_id);
        self.runtime_remote_object_realms
            .insert(alias_id, realm_id.to_owned());
    }

    pub(crate) fn register_runtime_remote_object_ids_with_group<I>(
        &mut self,
        object_ids: I,
        object_group: &str,
    ) where
        I: IntoIterator<Item = String>,
    {
        for object_id in object_ids {
            self.runtime_remote_object_ids.insert(object_id.clone());
            self.runtime_remote_object_groups
                .insert(object_id, object_group.to_owned());
        }
    }

    pub(crate) fn unregister_runtime_remote_object_ids(&mut self, object_ids: &[String]) {
        let object_ids = object_ids
            .iter()
            .map(String::as_str)
            .collect::<HashSet<_>>();
        let alias_ids_to_remove = self
            .runtime_remote_object_aliases
            .iter()
            .filter_map(|(alias_id, object_id)| {
                (object_ids.contains(alias_id.as_str()) || object_ids.contains(object_id.as_str()))
                    .then_some(alias_id.clone())
            })
            .collect::<Vec<_>>();

        for object_id in object_ids {
            self.runtime_remote_object_ids.remove(object_id);
            self.runtime_remote_object_groups.remove(object_id);
            self.runtime_remote_object_realms.remove(object_id);
        }

        for alias_id in alias_ids_to_remove {
            self.runtime_remote_object_aliases.remove(&alias_id);
            self.runtime_remote_object_realms.remove(&alias_id);
        }
    }

    pub(crate) fn unregister_runtime_remote_object_group(&mut self, object_group: &str) {
        let object_ids = self
            .runtime_remote_object_groups
            .iter()
            .filter_map(|(object_id, group)| {
                (group == object_group).then_some(object_id.to_owned())
            })
            .collect::<Vec<_>>();
        self.unregister_runtime_remote_object_ids(&object_ids);
    }

    pub(crate) fn clear_runtime_remote_object_tracking(&mut self) {
        self.runtime_remote_object_ids.clear();
        self.runtime_remote_object_groups.clear();
        self.runtime_remote_object_realms.clear();
        self.runtime_remote_object_aliases.clear();
        self.clear_child_default_context_emission_state();
    }

    pub(crate) fn record_runtime_contexts_reported_to_frontend(&mut self) {
        self.runtime_session_state
            .runtime_contexts_reported_to_frontend = true;
    }

    pub(crate) fn record_runtime_contexts_cleared_for_frontend(&mut self) {
        self.runtime_session_state
            .runtime_contexts_reported_to_frontend = false;
    }

    pub(crate) fn has_emitted_child_default_execution_context_id(
        &self,
        execution_context_id: i64,
    ) -> bool {
        self.emitted_child_default_execution_context_ids
            .contains(&execution_context_id)
    }

    pub(crate) fn mark_child_default_execution_context_id_emitted(
        &mut self,
        execution_context_id: i64,
    ) -> bool {
        self.emitted_child_default_execution_context_ids
            .insert(execution_context_id)
    }

    pub(crate) fn clear_child_default_context_emission_state(&mut self) {
        self.emitted_child_default_execution_context_ids.clear();
    }

    pub(crate) fn clear_runtime_remote_objects_for_realm(&mut self, realm_id: &str) {
        let object_ids = self
            .runtime_remote_object_realms
            .iter()
            .filter_map(|(object_id, realm)| (realm == realm_id).then_some(object_id.clone()))
            .collect::<Vec<_>>();
        self.unregister_runtime_remote_object_ids(&object_ids);
    }

    pub(crate) fn runtime_remote_object_group(&self, object_id: &str) -> Option<&str> {
        self.runtime_remote_object_groups
            .get(object_id)
            .or_else(|| {
                self.runtime_remote_object_aliases
                    .get(object_id)
                    .and_then(|object_id| self.runtime_remote_object_groups.get(object_id))
            })
            .map(String::as_str)
    }

    pub(crate) fn has_runtime_remote_object_id(&self, object_id: &str) -> bool {
        self.runtime_remote_object_ids.contains(object_id)
            || self.runtime_remote_object_aliases.contains_key(object_id)
    }

    pub(crate) fn runtime_remote_object_realm(&self, object_id: &str) -> Option<&str> {
        self.runtime_remote_object_realms
            .get(object_id)
            .or_else(|| {
                self.runtime_remote_object_aliases
                    .get(object_id)
                    .and_then(|object_id| self.runtime_remote_object_realms.get(object_id))
            })
            .map(String::as_str)
    }

    pub(crate) fn runtime_remote_object_alias(&self, object_id: &str) -> Option<&str> {
        self.runtime_remote_object_aliases
            .get(object_id)
            .map(String::as_str)
    }

    pub(crate) fn take_runtime_remote_object_cleanup_plan(&mut self) -> (Vec<String>, Vec<String>) {
        let grouped_object_ids = self
            .runtime_remote_object_groups
            .keys()
            .cloned()
            .collect::<HashSet<_>>();
        let mut object_groups = self
            .runtime_remote_object_groups
            .values()
            .cloned()
            .collect::<BTreeSet<_>>()
            .into_iter()
            .collect::<Vec<_>>();
        let mut ungrouped_object_ids = self
            .runtime_remote_object_ids
            .iter()
            .filter(|object_id| !grouped_object_ids.contains(*object_id))
            .cloned()
            .collect::<Vec<_>>();
        object_groups.sort();
        ungrouped_object_ids.sort();
        self.clear_runtime_remote_object_tracking();
        (object_groups, ungrouped_object_ids)
    }
}

impl DevToolsDomStorageSessionState {
    pub(crate) fn is_enabled(&self) -> bool {
        self.mutation_subscription.is_some()
    }

    pub(crate) fn enable(&mut self, subscription: WebStorageMutationSubscription) {
        if self.mutation_subscription.is_none() {
            self.mutation_subscription = Some(subscription);
        }
    }

    pub(crate) fn disable(&mut self) {
        self.mutation_subscription = None;
    }

    pub(crate) fn mutation_subscription(&self) -> Option<&WebStorageMutationSubscription> {
        self.mutation_subscription.as_ref()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn binding(name: &str) -> RuntimeBindingDefinition {
        RuntimeBindingDefinition {
            devtools_session: None,
            name: name.to_owned(),
            execution_context_name: None,
        }
    }

    fn identity_override(
        user_agent: &str,
        accept_language: Option<&str>,
        navigator_platform: Option<&str>,
    ) -> Option<DevToolsBrowserIdentityOverride> {
        DevToolsBrowserIdentityOverride::from_command(
            &moli_browser_profile::BrowserIdentityProfile::default(),
            user_agent.to_owned(),
            accept_language.map(str::to_owned),
            navigator_platform.map(str::to_owned),
            None,
        )
    }

    fn effective_identity(
        sessions: &DevToolsSessionRegistry,
    ) -> moli_browser_profile::BrowserIdentityProfile {
        sessions
            .effective_network_browser_identity_override()
            .expect("browser identity contribution should be effective")
    }

    fn effective_renderer_identity(
        sessions: &DevToolsSessionRegistry,
    ) -> moli_browser_profile::BrowserIdentityProfile {
        sessions
            .effective_renderer_browser_identity_override()
            .expect("renderer browser identity contribution should be effective")
    }

    #[test]
    fn registry_owns_primary_and_attached_sessions_in_stable_order() {
        let mut sessions = DevToolsSessionRegistry::default();
        sessions.ensure_attached("SID-b");
        sessions.ensure_attached("SID-a");

        assert_eq!(sessions.attached_len(), 2);
        assert_eq!(
            sessions
                .attached_entries()
                .map(|(session_id, _state)| session_id)
                .collect::<Vec<_>>(),
            ["SID-a", "SID-b"]
        );

        sessions.remove_attached("SID-a");
        assert!(sessions.attached("SID-a").is_none());
        assert!(sessions.attached("SID-b").is_some());
        assert_eq!(sessions.primary(), &DevToolsSessionState::default());
    }

    #[test]
    fn network_policy_uses_attachment_order_and_domain_specific_aggregation() {
        let mut sessions = DevToolsSessionRegistry::default();
        let primary = &mut sessions.primary_mut().network_session_state;
        primary.network_enabled = true;
        primary.cache_disabled = true;
        primary.extra_headers = vec![
            ("X-Primary".to_owned(), "primary".to_owned()),
            ("X-Shared".to_owned(), "primary".to_owned()),
        ]
        .into();

        let attached_b = &mut sessions.ensure_attached("SID-b").network_session_state;
        attached_b.network_enabled = true;
        attached_b.bypass_service_worker = true;
        attached_b.extra_headers = vec![
            ("X-B".to_owned(), "b".to_owned()),
            ("x-shared".to_owned(), "b".to_owned()),
        ]
        .into();

        let attached_a = &mut sessions.ensure_attached("SID-a").network_session_state;
        attached_a.network_enabled = false;
        attached_a.cache_disabled = true;
        attached_a.extra_headers = vec![("X-Ignored".to_owned(), "a".to_owned())].into();

        let policy = sessions.effective_network_policy();
        assert!(policy.cache_disabled);
        assert!(policy.bypass_service_worker);
        assert_eq!(
            policy.extra_headers.to_byte_strings(),
            vec![
                ("X-Primary".to_owned(), "primary".to_owned()),
                ("x-shared".to_owned(), "b".to_owned()),
                ("X-B".to_owned(), "b".to_owned()),
            ]
        );

        sessions.remove_attached("SID-b");
        let policy = sessions.effective_network_policy();
        assert!(policy.cache_disabled);
        assert!(!policy.bypass_service_worker);
        assert_eq!(
            policy.extra_headers.to_byte_strings(),
            vec![
                ("X-Primary".to_owned(), "primary".to_owned()),
                ("X-Shared".to_owned(), "primary".to_owned()),
            ]
        );
    }

    #[test]
    fn browser_identity_uses_attachment_order_on_network_and_renderer_surfaces() {
        let mut sessions = DevToolsSessionRegistry::default();
        let primary = DevToolsSessionKey::Primary;
        let later = DevToolsSessionKey::Attached("SID-later".to_owned());
        sessions.ensure_attached("SID-later");
        sessions
            .set_browser_identity_override(&later, identity_override("Moli/Later-1", None, None));
        sessions.set_browser_identity_override(
            &primary,
            identity_override("Moli/Primary-1", None, None),
        );
        assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-1");
        assert_eq!(
            effective_renderer_identity(&sessions).user_agent(),
            "Moli/Later-1",
            "the later-attached session wins even when it set its override first"
        );

        sessions
            .set_browser_identity_override(&later, identity_override("Moli/Later-2", None, None));
        assert_eq!(
            effective_identity(&sessions).user_agent(),
            "Moli/Later-2",
            "the browser-side winner remains the later-attached session"
        );
        assert_eq!(
            effective_renderer_identity(&sessions).user_agent(),
            "Moli/Later-2",
            "updating the later-attached renderer agent preserves its precedence"
        );

        sessions.set_browser_identity_override(
            &primary,
            identity_override("Moli/Primary-2", None, None),
        );
        assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-2");
        assert_eq!(
            effective_renderer_identity(&sessions).user_agent(),
            "Moli/Later-2"
        );

        sessions.set_browser_identity_override(&primary, None);
        assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-2");
        assert_eq!(
            effective_renderer_identity(&sessions).user_agent(),
            "Moli/Later-2"
        );

        sessions.set_browser_identity_override(
            &primary,
            identity_override("Moli/Primary-3", Some("fr-FR"), Some("PrimaryPlatform")),
        );
        assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-2");
        let renderer_identity = effective_renderer_identity(&sessions);
        assert_eq!(renderer_identity.user_agent(), "Moli/Later-2");
        assert_eq!(renderer_identity.accept_language(), "fr-FR");
        assert_eq!(renderer_identity.navigator_platform(), "PrimaryPlatform");

        sessions.remove_attached("SID-later");
        assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Primary-3");
        assert_eq!(
            effective_renderer_identity(&sessions).user_agent(),
            "Moli/Primary-3"
        );
    }

    #[test]
    fn locale_and_timezone_follow_their_distinct_exclusive_claim_rules() {
        let mut sessions = DevToolsSessionRegistry::default();
        let session_a = DevToolsSessionKey::Attached("SID-a".to_owned());
        let session_b = DevToolsSessionKey::Attached("SID-b".to_owned());
        sessions.ensure_attached("SID-a");
        sessions.ensure_attached("SID-b");

        sessions
            .set_locale_override(&session_a, Some("fr-FR".to_owned()))
            .unwrap();
        assert_eq!(
            sessions
                .set_locale_override(&session_b, Some("de-DE".to_owned()))
                .unwrap_err(),
            "Another locale override is already in effect"
        );
        assert_eq!(
            sessions.set_locale_override(&session_b, None).unwrap_err(),
            "Another locale override is already in effect",
            "Chromium treats a non-owner locale clear as a new claim"
        );
        sessions
            .set_locale_override(&session_a, Some("it-IT".to_owned()))
            .unwrap();
        assert_eq!(
            sessions.effective_locale_override().as_deref(),
            Some("it-IT")
        );

        sessions
            .set_timezone_override(&session_a, Some("Europe/Paris".to_owned()))
            .unwrap();
        assert_eq!(
            sessions
                .set_timezone_override(&session_b, Some("America/New_York".to_owned()))
                .unwrap_err(),
            "Timezone override is already in effect"
        );
        sessions
            .set_timezone_override(&session_b, None)
            .expect("Chromium accepts a non-owner timezone clear as a no-op");
        assert_eq!(
            sessions.effective_timezone_override().as_deref(),
            Some("Europe/Paris")
        );

        sessions.remove_attached("SID-a");
        assert_eq!(sessions.effective_locale_override().as_deref(), None);
        assert_eq!(sessions.effective_timezone_override().as_deref(), None);
        sessions
            .set_locale_override(&session_b, Some("de-DE".to_owned()))
            .unwrap();
        sessions
            .set_timezone_override(&session_b, Some("America/New_York".to_owned()))
            .unwrap();
    }

    #[test]
    fn environment_admission_does_not_retain_rejected_or_unowned_sessions() {
        let mut sessions = DevToolsSessionRegistry::default();
        let owner = DevToolsSessionKey::Attached("SID-owner".to_owned());
        let peer = DevToolsSessionKey::Attached("SID-peer".to_owned());
        assert!(
            sessions
                .set_locale_override(&peer, Some("fr\0FR".to_owned()))
                .is_err()
        );
        assert!(
            sessions
                .set_timezone_override(&peer, Some("Mars/Olympus".to_owned()))
                .is_err()
        );
        assert!(sessions.environment_owners.is_empty());
        assert!(sessions.session(&peer).is_none());

        sessions
            .set_locale_override(&owner, Some("fr_FR".to_owned()))
            .unwrap();
        sessions
            .set_timezone_override(&owner, Some("Europe/Paris".to_owned()))
            .unwrap();
        assert!(sessions.set_locale_override(&peer, None).is_err());
        assert!(
            sessions
                .set_timezone_override(&peer, Some("Asia/Shanghai".to_owned()))
                .is_err()
        );
        sessions
            .set_timezone_override(&peer, Some("Europe/Paris".to_owned()))
            .expect("same-timezone success does not grant ownership");
        sessions.set_timezone_override(&peer, None).unwrap();
        assert_eq!(sessions.environment_owners.len(), 1);
        assert!(sessions.environment_owners.contains_key(&owner));
        assert!(sessions.session(&peer).is_none());
        assert_eq!(sessions.attached_len(), 1);
    }

    #[test]
    fn environment_owner_survives_failed_updates_and_partial_clear() {
        let mut sessions = DevToolsSessionRegistry::default();
        let key = DevToolsSessionKey::Attached("SID-owner".to_owned());
        sessions
            .set_locale_override(&key, Some("fr_FR".to_owned()))
            .unwrap();
        sessions
            .set_timezone_override(&key, Some("Europe/Paris".to_owned()))
            .unwrap();
        assert!(
            sessions
                .set_locale_override(&key, Some("fr\0FR".to_owned()))
                .is_err()
        );
        assert!(
            sessions
                .set_timezone_override(&key, Some("Mars/Olympus".to_owned()))
                .is_err()
        );
        assert_eq!(
            sessions.effective_locale_override().as_deref(),
            Some("fr_FR")
        );
        assert_eq!(
            sessions.effective_timezone_override().as_deref(),
            Some("Europe/Paris")
        );

        sessions.set_locale_override(&key, None).unwrap();
        assert_eq!(sessions.effective_locale_override(), None);
        assert_eq!(sessions.environment_owners.len(), 1);
        assert_eq!(
            sessions.effective_timezone_override().as_deref(),
            Some("Europe/Paris")
        );
        sessions.set_timezone_override(&key, None).unwrap();
        assert!(sessions.environment_owners.is_empty());
        assert!(
            sessions.session(&key).is_some(),
            "clearing claims is not detach"
        );
    }

    #[test]
    fn policy_snapshots_cannot_retain_environment_authority_after_registry_drop() {
        let mut sessions = DevToolsSessionRegistry::default();
        sessions.attach_primary("SID-primary".to_owned());
        let key = DevToolsSessionKey::Primary;
        sessions
            .set_locale_override(&key, Some("fr_FR".to_owned()))
            .unwrap();
        sessions
            .set_timezone_override(&key, Some("Europe/Paris".to_owned()))
            .unwrap();
        let snapshot = sessions.primary().clone();
        drop(sessions);

        let replacement = moli_core::ProcessEnvironmentOwner::default();
        replacement.set_locale(Some("de_DE")).unwrap();
        replacement.set_timezone(Some("Asia/Shanghai")).unwrap();
        drop(snapshot);
        assert_eq!(replacement.locale().as_deref(), Some("de_DE"));
        assert_eq!(replacement.timezone().as_deref(), Some("Asia/Shanghai"));
    }

    #[test]
    fn registry_aggregates_renderer_configuration_by_session_identity() {
        let mut sessions = DevToolsSessionRegistry::default();
        sessions
            .primary_mut()
            .runtime_bindings
            .push(binding("primary"));
        sessions
            .ensure_attached("SID-b")
            .runtime_bindings
            .push(binding("attached-b"));
        let attached_a = sessions.ensure_attached("SID-a");
        attached_a.runtime_bindings.push(binding("attached-a"));
        attached_a.runtime_session_state.runtime_frontend_enabled = true;
        attached_a.page_session_state.page_bypass_csp_enabled = true;

        let bindings = sessions.runtime_bindings_for_renderer();
        assert_eq!(
            bindings
                .iter()
                .map(|binding| (binding.name.as_str(), binding.devtools_session.clone()))
                .collect::<Vec<_>>(),
            [
                ("primary", Some(DevToolsSessionKey::Primary)),
                (
                    "attached-a",
                    Some(DevToolsSessionKey::Attached("SID-a".to_owned())),
                ),
                (
                    "attached-b",
                    Some(DevToolsSessionKey::Attached("SID-b".to_owned())),
                ),
            ]
        );
        assert!(sessions.page_bypass_csp_enabled());

        let restores = sessions.runtime_inspector_restore_snapshots();
        assert_eq!(
            restores
                .iter()
                .map(|restore| restore.inspector_session_id.as_deref())
                .collect::<Vec<_>>(),
            [None, Some("SID-a"), Some("SID-b")]
        );

        sessions.remove_attached("SID-a");
        assert!(!sessions.page_bypass_csp_enabled());
    }

    #[test]
    fn registry_pending_await_aggregation_tracks_attached_disposal() {
        let mut sessions = DevToolsSessionRegistry::default();
        sessions
            .primary_mut()
            .register_pending_inspector_await(1, Some("SID-primary"), None);
        sessions
            .ensure_attached("SID-attached")
            .register_pending_inspector_await(2, Some("SID-attached"), Some("group"));

        assert!(sessions.has_pending_inspector_awaits());
        assert_eq!(sessions.pending_inspector_await_count(), 2);
        let disposed = sessions
            .dispose(
                "SID-attached",
                &DevToolsSessionKey::Attached("SID-attached".to_owned()),
            )
            .expect("attached session should be disposed");
        assert_eq!(disposed.pending_inspector_await_count(), 1);
        assert_eq!(sessions.pending_inspector_await_count(), 1);

        assert!(sessions.attached_is_empty());
        assert_eq!(sessions.pending_inspector_await_count(), 1);
        *sessions.primary_mut() = DevToolsSessionState::default();
        assert!(!sessions.has_pending_inspector_awaits());
    }

    #[test]
    fn registry_dispose_is_exactly_once_and_preserves_peer_sessions() {
        let mut sessions = DevToolsSessionRegistry::default();
        sessions.attach_primary("SID-primary".to_owned());
        sessions
            .primary_mut()
            .runtime_bindings
            .push(binding("primary"));
        sessions
            .ensure_attached("SID-attached")
            .runtime_bindings
            .push(binding("attached"));

        let disposed_attached = sessions
            .dispose(
                "SID-attached",
                &DevToolsSessionKey::Attached("SID-attached".to_owned()),
            )
            .expect("attached session should be disposed");
        assert_eq!(
            disposed_attached.runtime_bindings,
            vec![binding("attached")]
        );
        assert!(sessions.attached_is_empty());
        assert_eq!(sessions.primary_session_id(), Some("SID-primary"));
        assert_eq!(
            sessions.primary().runtime_bindings,
            vec![binding("primary")]
        );
        assert!(
            sessions
                .dispose(
                    "SID-attached",
                    &DevToolsSessionKey::Attached("SID-attached".to_owned()),
                )
                .is_none(),
            "a disposed session must not settle twice"
        );

        let disposed_primary = sessions
            .dispose("SID-primary", &DevToolsSessionKey::Primary)
            .expect("primary session should be disposed");
        assert_eq!(disposed_primary.runtime_bindings, vec![binding("primary")]);
        assert_eq!(sessions.primary_session_id(), None);
        assert_eq!(sessions.primary(), &DevToolsSessionState::default());
        assert!(
            sessions
                .dispose("SID-primary", &DevToolsSessionKey::Primary)
                .is_none(),
            "primary disposal must also be exactly once"
        );
    }
}