Skip to content

armgit / moli

Public Imported from GitHub
0

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

40.3 KB
Raw Blame
use crate::automation::DevToolsTargetInfo;
#[cfg(test)]
use crate::conn::BrowserContext;
use crate::conn::CdpConnection;

use super::{
    CdpSessionRoute, PreparedTargetAttach, SessionDisposalPlan, SessionDisposalTarget,
    TargetAttachRollbackPlan, TargetAttachSessionCommit, TargetAutoAttachedSessionDetachPlan,
    TargetClosureCleanupPlan, TargetEventPlan, TargetSessionDetachCleanupPlan,
};

impl CdpConnection {
    /// Commits target-side session declarations built by low-level test
    /// fixtures into the same control-plane registry used by production
    /// attachment transactions.
    ///
    /// Older tests construct `BrowserContext` and worker targets directly,
    /// before either object is owned by a `CdpConnection`. The test harness
    /// calls this once at its fixture boundary. Runtime route lookup remains
    /// strict: it never searches target state when the committed registry has
    /// no entry.
    #[cfg(test)]
    pub(crate) fn commit_declared_session_fixtures_for_test(&mut self) {
        let mut declared = Vec::new();
        for browser_context in self.browser_contexts() {
            let browser_context_id = browser_context.id.clone();
            for target in browser_context.page_targets.iter() {
                let target_id = target.target_id().to_owned();
                if let Some(session_id) = target.devtools_sessions.primary_session_id() {
                    declared.push((
                        session_id.to_owned(),
                        target_id.clone(),
                        CdpSessionRoute::PageTarget {
                            browser_context_id: browser_context_id.clone(),
                            target_id: target_id.clone(),
                            session_key: moli_page_types::DevToolsSessionKey::Primary,
                        },
                    ));
                }
                for session_id in target.devtools_sessions.attached_session_ids() {
                    declared.push((
                        session_id.to_owned(),
                        target_id.clone(),
                        CdpSessionRoute::PageTarget {
                            browser_context_id: browser_context_id.clone(),
                            target_id: target_id.clone(),
                            session_key: moli_page_types::DevToolsSessionKey::Attached(
                                session_id.to_owned(),
                            ),
                        },
                    ));
                }
            }
            for target in browser_context.shared_worker_targets.values() {
                for session_id in target.session_ids() {
                    declared.push((
                        session_id,
                        target.target_id.clone(),
                        CdpSessionRoute::SharedWorkerTarget {
                            browser_context_id: browser_context_id.clone(),
                            target_id: target.target_id.clone(),
                        },
                    ));
                }
            }
            for target in browser_context.dedicated_worker_targets.values() {
                for session_id in target.inner.session_ids() {
                    declared.push((
                        session_id,
                        target.inner.target_id.clone(),
                        CdpSessionRoute::DedicatedWorkerTarget {
                            browser_context_id: browser_context_id.clone(),
                            target_id: target.inner.target_id.clone(),
                        },
                    ));
                }
            }
            for target in browser_context.service_worker_targets.values() {
                for session_id in target.session_ids() {
                    declared.push((
                        session_id,
                        target.target_id.clone(),
                        CdpSessionRoute::ServiceWorkerTarget {
                            browser_context_id: browser_context_id.clone(),
                            target_id: target.target_id.clone(),
                        },
                    ));
                }
            }
        }

        for (session_id, target_id, route) in declared {
            if self
                .target_control
                .attached_session_route(&session_id)
                .is_some()
            {
                continue;
            }
            self.target_control
                .commit_attached_session(session_id, None, &target_id, route, false, false);
        }
    }

    #[cfg(test)]
    pub(crate) fn install_browser_context_fixture_for_test(
        &mut self,
        browser_context: BrowserContext,
    ) {
        self.browser_context = Some(browser_context);
        self.commit_declared_session_fixtures_for_test();
    }

    #[cfg(test)]
    pub(crate) fn push_inactive_browser_context_fixture_for_test(
        &mut self,
        browser_context: BrowserContext,
    ) {
        self.inactive_browser_contexts.push(browser_context);
        self.commit_declared_session_fixtures_for_test();
    }

    pub(crate) async fn clear_devtools_network_session_policy_async(
        &mut self,
        session_id: &str,
    ) -> anyhow::Result<()> {
        let Some(CdpSessionRoute::PageTarget {
            browser_context_id,
            target_id,
            session_key,
        }) = self.session_route(Some(session_id))
        else {
            return Ok(());
        };

        let Some(browser_context) = self.browser_context_by_id_mut(&browser_context_id) else {
            return Ok(());
        };
        browser_context
            .clear_devtools_network_session_policy_async(&target_id, &session_key)
            .await
    }

    pub(crate) async fn clear_devtools_emulation_session_policy_async(
        &mut self,
        session_id: &str,
    ) -> anyhow::Result<()> {
        let Some(CdpSessionRoute::PageTarget {
            browser_context_id,
            target_id,
            session_key,
        }) = self.session_route(Some(session_id))
        else {
            return Ok(());
        };

        let browser_identity_changed = match self.browser_context_by_id_mut(&browser_context_id) {
            Some(browser_context) => {
                browser_context
                    .clear_devtools_emulation_session_policy_async(&target_id, &session_key)
                    .await?
            }
            None => false,
        };
        if !browser_identity_changed {
            return Ok(());
        }

        let Some(pending) = self
            .start_rebuild_resource_runtime_for_session_owner(Some(session_id))
            .map_err(anyhow::Error::msg)?
        else {
            return Ok(());
        };
        let completion = pending.wait().await.map_err(|error| {
            anyhow::anyhow!("failed to restore detached session user agent: {error}")
        })?;
        self.finish_rebuild_resource_runtime_for_session_owner(Some(session_id), completion)
            .map_err(anyhow::Error::msg)
    }

    pub(crate) fn is_browser_session_id(&self, session_id: Option<&str>) -> bool {
        let Some(session_id) = session_id else {
            return false;
        };
        self.target_control.attached_session_route(session_id) == Some(&CdpSessionRoute::Browser)
    }

    #[cfg(test)]
    pub(crate) fn register_browser_session(&mut self, session_id: String) {
        self.target_control.commit_attached_session(
            session_id,
            None,
            "browser",
            CdpSessionRoute::Browser,
            false,
            false,
        );
    }

    pub(crate) fn commit_browser_session_disposal_without_event(
        &mut self,
        plan: &SessionDisposalPlan,
    ) -> anyhow::Result<TargetEventPlan> {
        anyhow::ensure!(
            matches!(plan.target(), SessionDisposalTarget::Browser)
                && self.is_browser_session_id(Some(plan.session_id())),
            "InvalidSessionId"
        );
        Ok(self.rollback_attached_session_without_event(plan.session_id()))
    }

    pub(crate) fn commit_browser_session_disposal_event_plan(
        &mut self,
        plan: &SessionDisposalPlan,
    ) -> anyhow::Result<TargetEventPlan> {
        anyhow::ensure!(
            matches!(plan.target(), SessionDisposalTarget::Browser)
                && self.is_browser_session_id(Some(plan.session_id())),
            "InvalidSessionId"
        );
        let owner_session_id = self
            .target_control
            .attached_session_owner_session_id(plan.session_id())
            .map(str::to_owned);
        let session_id = plan.session_id().to_owned();
        let event_plan = self
            .target_control
            .detach_attached_session_event_plan(
                plan.session_id(),
                None,
                owner_session_id.as_deref(),
            )
            .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
        self.remove_detached_session_control_owner(&session_id);
        Ok(event_plan)
    }

    pub(crate) fn release_root_target_frontend_owner_without_event(&mut self) {
        self.download_behavior
            .set_browser_events_enabled_for_session(None, false);
        self.cancel_tracing_for_session_owner(None);
        self.clear_auto_attach_owner(None);
        self.clear_target_discovery_for_owner(None);
        self.target_control.remove_owner(None);
    }

    pub(crate) fn release_primary_target_session_binding_without_event(
        &mut self,
        session_id: &str,
    ) -> bool {
        let Some(browser_context_id) = self
            .session_route(Some(session_id))
            .and_then(|route| route.browser_context_id().map(str::to_owned))
        else {
            return false;
        };
        let released = self
            .browser_context_by_id_mut(&browser_context_id)
            .is_some_and(|browser_context| {
                browser_context
                    .release_primary_session_binding_preserving_frontend_state(session_id)
            });
        if released {
            self.rollback_attached_session_without_event(session_id);
        }
        released
    }

    #[cfg(test)]
    pub(crate) fn register_auto_attached_session_route_for_test(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        route: CdpSessionRoute,
    ) {
        let target_id = route.target_id().unwrap_or_else(|| {
            panic!("test auto-attached session route must identify a target: {route:?}")
        });
        self.target_control.commit_auto_attached_session_for_target(
            session_id,
            owner_session_id,
            target_id,
            route.clone(),
            false,
        );
    }

    #[cfg(test)]
    pub(crate) fn mark_session_auto_attached_for_test(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
    ) {
        let route = self
            .session_route(Some(&session_id))
            .unwrap_or_else(|| panic!("test session {session_id} must have a committed route"));
        self.register_auto_attached_session_route_for_test(session_id, owner_session_id, route);
    }

    #[cfg(test)]
    pub(crate) fn register_session_route_for_test(
        &mut self,
        session_id: &str,
        route: CdpSessionRoute,
    ) {
        let target_id = route.target_id().unwrap_or("browser").to_owned();
        self.target_control.commit_attached_session(
            session_id.to_owned(),
            None,
            &target_id,
            route,
            false,
            false,
        );
    }

    pub(crate) fn commit_prepared_attach_event_plan(
        &mut self,
        prepared: PreparedTargetAttach,
    ) -> TargetEventPlan {
        self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, true)
    }

    pub(crate) fn commit_prepared_dedicated_worker_attach_event_plan(
        &mut self,
        prepared: PreparedTargetAttach,
    ) -> TargetEventPlan {
        self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, false)
    }

    fn commit_prepared_attach_event_plan_with_attached_state_delta(
        &mut self,
        prepared: PreparedTargetAttach,
        emit_attached_state_delta: bool,
    ) -> TargetEventPlan {
        let (target_id, target_info, sessions) = prepared.into_parts();
        let should_emit_attached_state_delta = emit_attached_state_delta && !sessions.is_empty();
        let attached_state_delta_plan = should_emit_attached_state_delta
            .then(|| self.exact_target_info_changed_event_plan_for_target_delta(&target_id));
        let mut plan = TargetEventPlan::default();
        for session in sessions {
            let (session_id, owner_session_id, route, auto_attached, waiting_for_debugger) =
                session.into_parts();
            if auto_attached {
                self.target_control
                    .ensure_owner(owner_session_id.as_deref());
            }
            plan.extend(self.target_control.commit_attached_session_event(
                session_id,
                owner_session_id.as_deref(),
                &target_id,
                route,
                auto_attached,
                waiting_for_debugger,
                target_info.clone(),
            ));
        }
        if let Some(attached_state_delta_plan) = attached_state_delta_plan {
            plan.extend(attached_state_delta_plan);
        }
        plan
    }

    pub(crate) fn attach_tab_target_session_event_plan(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        tab_target_id: &str,
        is_attached_session: bool,
    ) -> Result<TargetEventPlan, &'static str> {
        let Some(browser_context_id) = self.browser_context_id_for_tab_target_id(tab_target_id)
        else {
            return Err("UnknownTargetId");
        };
        if !self.assign_session_to_tab_target(
            tab_target_id,
            session_id.clone(),
            is_attached_session,
        ) {
            return Err("UnknownTargetId");
        }
        let prepared_session = TargetAttachSessionCommit::direct(
            session_id,
            owner_session_id.map(str::to_owned),
            CdpSessionRoute::TabTarget {
                browser_context_id,
                tab_target_id: tab_target_id.to_owned(),
            },
            false,
        );
        let Some(target_info) = self.tab_target_info(tab_target_id) else {
            self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
            return Err("UnknownTargetId");
        };
        Ok(
            self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
                tab_target_id,
                target_info,
                [prepared_session],
            )),
        )
    }

    pub(crate) fn attach_shared_worker_target_session_event_plan(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        target_id: &str,
    ) -> Result<TargetEventPlan, &'static str> {
        let session_id_for_binding = session_id.clone();
        let (browser_context_id, target_info) = {
            let Some(bc) = self.browser_context.as_mut() else {
                return Err("BrowserContextNotLoaded");
            };
            if !bc.assign_session_to_shared_worker_target(target_id, session_id_for_binding) {
                return Err("UnknownTargetId");
            }
            (bc.id.clone(), bc.devtools_target_info(target_id))
        };
        let prepared_session = TargetAttachSessionCommit::direct(
            session_id,
            owner_session_id.map(str::to_owned),
            CdpSessionRoute::SharedWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            },
            false,
        );
        let Some(target_info) = target_info else {
            self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
            return Err("UnknownTargetId");
        };
        Ok(
            self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
                target_id,
                target_info,
                [prepared_session],
            )),
        )
    }

    pub(crate) fn attach_service_worker_target_session_event_plan(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        target_id: &str,
    ) -> Result<TargetEventPlan, &'static str> {
        let session_id_for_binding = session_id.clone();
        let (browser_context_id, target_info) = {
            let Some(bc) = self.browser_context.as_mut() else {
                return Err("BrowserContextNotLoaded");
            };
            if !bc.assign_session_to_service_worker_target(target_id, session_id_for_binding) {
                return Err("UnknownTargetId");
            }
            (bc.id.clone(), bc.devtools_target_info(target_id))
        };
        let prepared_session = TargetAttachSessionCommit::direct(
            session_id,
            owner_session_id.map(str::to_owned),
            CdpSessionRoute::ServiceWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            },
            false,
        );
        let Some(target_info) = target_info else {
            self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
            return Err("UnknownTargetId");
        };
        Ok(
            self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
                target_id,
                target_info,
                [prepared_session],
            )),
        )
    }

    pub(crate) fn attach_dedicated_worker_target_session_event_plan(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        target_id: &str,
    ) -> Result<TargetEventPlan, &'static str> {
        let session_id_for_binding = session_id.clone();
        let (browser_context_id, target_info) = {
            let Some(bc) = self.browser_context.as_mut() else {
                return Err("BrowserContextNotLoaded");
            };
            if !bc.assign_session_to_dedicated_worker_target(target_id, session_id_for_binding) {
                return Err("UnknownTargetId");
            }
            (bc.id.clone(), bc.devtools_target_info(target_id))
        };
        let prepared_session = TargetAttachSessionCommit::direct(
            session_id,
            owner_session_id.map(str::to_owned),
            CdpSessionRoute::DedicatedWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            },
            false,
        );
        let Some(target_info) = target_info else {
            self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
            return Err("UnknownTargetId");
        };
        Ok(
            self.commit_prepared_dedicated_worker_attach_event_plan(PreparedTargetAttach::new(
                target_id,
                target_info,
                [prepared_session],
            )),
        )
    }

    pub(crate) fn prepare_auto_attached_tab_session_binding(
        &mut self,
        tab_target_id: &str,
        session_id: String,
        owner_session_id: Option<&str>,
    ) -> Option<CdpSessionRoute> {
        let browser_context_id = self.browser_context_id_for_tab_target_id(tab_target_id)?;
        self.assign_session_to_tab_target(tab_target_id, session_id, owner_session_id.is_some())
            .then(|| CdpSessionRoute::TabTarget {
                browser_context_id,
                tab_target_id: tab_target_id.to_owned(),
            })
    }

    pub(crate) fn prepare_auto_attached_page_session_binding(
        &mut self,
        target_id: &str,
        session_id: String,
    ) -> Option<CdpSessionRoute> {
        let browser_context = self.browser_context.as_mut()?;
        let browser_context_id = browser_context.id.clone();
        if !browser_context.assign_auto_attached_session_to_target(target_id, session_id.clone()) {
            return None;
        }
        let session_key = browser_context
            .page_target(target_id)?
            .devtools_sessions
            .key_for_wire_session_id(&session_id)?;
        Some(CdpSessionRoute::PageTarget {
            browser_context_id,
            target_id: target_id.to_owned(),
            session_key,
        })
    }

    pub(crate) fn prepare_auto_attached_page_session_binding_in_browser_context(
        &mut self,
        browser_context_id: &str,
        target_id: &str,
        session_id: String,
    ) -> Option<CdpSessionRoute> {
        let browser_context = self.browser_context_by_id_mut(browser_context_id)?;
        if !browser_context.assign_auto_attached_session_to_target(target_id, session_id.clone()) {
            return None;
        }
        let session_key = browser_context
            .page_target(target_id)?
            .devtools_sessions
            .key_for_wire_session_id(&session_id)?;
        Some(CdpSessionRoute::PageTarget {
            browser_context_id: browser_context_id.to_owned(),
            target_id: target_id.to_owned(),
            session_key,
        })
    }

    pub(crate) fn prepare_auto_attached_shared_worker_session_binding(
        &mut self,
        target_id: &str,
        session_id: String,
    ) -> Option<CdpSessionRoute> {
        let browser_context = self.browser_context.as_mut()?;
        let browser_context_id = browser_context.id.clone();
        browser_context
            .assign_session_to_shared_worker_target(target_id, session_id)
            .then(|| CdpSessionRoute::SharedWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            })
    }

    pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding(
        &mut self,
        target_id: &str,
        session_id: String,
    ) -> Option<CdpSessionRoute> {
        let browser_context = self.browser_context.as_mut()?;
        let browser_context_id = browser_context.id.clone();
        browser_context
            .assign_session_to_dedicated_worker_target(target_id, session_id)
            .then(|| CdpSessionRoute::DedicatedWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            })
    }

    pub(crate) fn prepare_auto_attached_service_worker_session_binding(
        &mut self,
        target_id: &str,
        session_id: String,
    ) -> Option<CdpSessionRoute> {
        let browser_context = self.browser_context.as_mut()?;
        let browser_context_id = browser_context.id.clone();
        browser_context
            .assign_session_to_service_worker_target(target_id, session_id)
            .then(|| CdpSessionRoute::ServiceWorkerTarget {
                browser_context_id,
                target_id: target_id.to_owned(),
            })
    }

    pub(crate) fn prepare_auto_attached_shared_worker_session_binding_info_in_browser_context(
        &mut self,
        browser_context_id: &str,
        target_id: &str,
        session_id: String,
    ) -> Option<DevToolsTargetInfo> {
        let bc = self.browser_context_by_id_mut(browser_context_id)?;
        if !bc.assign_session_to_shared_worker_target(target_id, session_id) {
            return None;
        }
        bc.devtools_target_info(target_id)
    }

    pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding_info_in_browser_context(
        &mut self,
        browser_context_id: &str,
        target_id: &str,
        session_id: String,
    ) -> Option<DevToolsTargetInfo> {
        let bc = self.browser_context_by_id_mut(browser_context_id)?;
        if !bc.assign_session_to_dedicated_worker_target(target_id, session_id) {
            return None;
        }
        bc.devtools_target_info(target_id)
    }

    pub(crate) fn prepare_auto_attached_service_worker_session_binding_info_in_browser_context(
        &mut self,
        browser_context_id: &str,
        target_id: &str,
        session_id: String,
    ) -> Option<DevToolsTargetInfo> {
        let bc = self.browser_context_by_id_mut(browser_context_id)?;
        if !bc.assign_session_to_service_worker_target(target_id, session_id) {
            return None;
        }
        bc.devtools_target_info(target_id)
    }

    pub(crate) fn prepare_auto_attached_service_worker_session_binding_info(
        &mut self,
        target_id: &str,
        session_id: String,
    ) -> Option<DevToolsTargetInfo> {
        let bc = self.browser_context.as_mut()?;
        if !bc.assign_session_to_service_worker_target(target_id, session_id) {
            return None;
        }
        bc.devtools_target_info(target_id)
    }

    pub(crate) fn commit_browser_attached_session_event_plan(
        &mut self,
        session_id: String,
        owner_session_id: Option<&str>,
        target_id: &str,
        target_info: DevToolsTargetInfo,
    ) -> TargetEventPlan {
        self.target_control.commit_attached_session_event(
            session_id,
            owner_session_id,
            target_id,
            CdpSessionRoute::Browser,
            false,
            false,
            target_info,
        )
    }

    pub(crate) fn rollback_attached_session_without_event(
        &mut self,
        session_id: &str,
    ) -> TargetEventPlan {
        let plan = self
            .target_control
            .rollback_attached_session_without_event(session_id);
        for session_id in plan.rolled_back_session_ids() {
            self.remove_detached_session_control_owner(session_id);
        }
        plan
    }

    pub(crate) fn detach_known_session_event_plan(
        &mut self,
        target_id: &str,
        session_id: &str,
        reason: Option<&str>,
        parent_session_id: Option<&str>,
    ) -> TargetEventPlan {
        self.detach_known_session_event_plan_with_attached_state_delta(
            target_id,
            session_id,
            reason,
            parent_session_id,
            true,
        )
    }

    fn detach_known_session_event_plan_with_attached_state_delta(
        &mut self,
        target_id: &str,
        session_id: &str,
        reason: Option<&str>,
        parent_session_id: Option<&str>,
        emit_attached_state_delta: bool,
    ) -> TargetEventPlan {
        let attached_state_delta_plan = emit_attached_state_delta
            .then(|| self.exact_target_info_changed_event_plan_for_target_delta(target_id));
        let mut plan = self.target_control.detach_known_session_event_plan(
            target_id,
            session_id,
            reason,
            parent_session_id,
        );
        let released_debugger_barrier = plan
            .detached_sessions()
            .iter()
            .any(|session| session.target_id() == target_id && session.was_waiting_for_debugger());
        self.remove_detached_session_control_owner(session_id);
        if let Some(attached_state_delta_plan) = attached_state_delta_plan {
            plan.extend(attached_state_delta_plan);
        }
        if released_debugger_barrier && !self.target_has_waiting_for_debugger_session(target_id) {
            crate::domains::target::schedule_initial_document_target_url_navigation_after_debugger_barrier_release_for_target(
                self,
                target_id,
            );
        }
        plan
    }

    pub(crate) async fn dispose_target_closure_sessions_event_plan_async(
        &mut self,
        cleanup_plan: TargetClosureCleanupPlan,
        parent_session_id: Option<&str>,
    ) -> TargetEventPlan {
        let session_ids = cleanup_plan
            .session_ids()
            .map(str::to_owned)
            .collect::<Vec<_>>();
        for session_id in session_ids {
            let Some(route) = self.session_route(Some(&session_id)) else {
                tracing::warn!(
                    session_id,
                    "closed target session no longer has an authoritative route"
                );
                continue;
            };
            let Some(disposal_plan) = SessionDisposalPlan::for_session_route(&session_id, &route)
            else {
                tracing::warn!(
                    session_id,
                    "closed target session does not support target disposal"
                );
                continue;
            };
            crate::domains::target::dispose_closed_session_domains_async(self, &disposal_plan)
                .await;
        }
        self.commit_target_closure_session_detachment_events(cleanup_plan, parent_session_id)
    }

    fn commit_target_closure_session_detachment_events(
        &mut self,
        cleanup_plan: TargetClosureCleanupPlan,
        parent_session_id: Option<&str>,
    ) -> TargetEventPlan {
        let plan = self
            .target_control
            .detach_target_closure_cleanup_event_plan(cleanup_plan, parent_session_id);
        for session in plan.detached_sessions() {
            self.remove_detached_session_control_owner(session.session_id());
        }
        plan
    }

    pub(crate) async fn rollback_prepared_attach_session_without_event_async(
        &mut self,
        prepared: &TargetAttachSessionCommit,
    ) -> TargetEventPlan {
        self.rollback_attached_session_with_cleanup_without_event_async(
            TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
        )
        .await
    }

    pub(crate) fn rollback_prepared_attach_session_sync_without_event(
        &mut self,
        prepared: &TargetAttachSessionCommit,
    ) -> TargetEventPlan {
        self.rollback_attached_session_with_cleanup_without_event_sync(
            TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
        )
    }

    fn rollback_attached_session_with_cleanup_without_event_sync(
        &mut self,
        rollback_plan: TargetAttachRollbackPlan,
    ) -> TargetEventPlan {
        if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
            if matches!(
                cleanup_plan.target(),
                SessionDisposalTarget::PageTarget {
                    session_key: moli_page_types::DevToolsSessionKey::Primary,
                    ..
                }
            ) {
                debug_assert!(
                    false,
                    "primary Page target rollback requires async binding cleanup"
                );
            } else {
                self.rollback_prepared_session_binding_sync(cleanup_plan);
            }
        }
        self.rollback_attached_session_without_event(rollback_plan.session_id())
    }

    /// Removes a prepared binding before any asynchronous domain work has
    /// started. Once a prepared session can own renderer resources, callers
    /// must use the asynchronous SessionDisposalPlan executor instead.
    fn rollback_prepared_session_binding_sync(&mut self, cleanup_plan: &SessionDisposalPlan) {
        match cleanup_plan.target() {
            SessionDisposalTarget::PageTarget {
                target_id,
                session_key: session_key @ moli_page_types::DevToolsSessionKey::Attached(_),
                ..
            } => {
                if let Some(bc) = self.session_disposal_browser_context_mut(cleanup_plan) {
                    let _ = bc.remove_page_session_binding(
                        target_id,
                        cleanup_plan.session_id(),
                        session_key,
                    );
                }
            }
            SessionDisposalTarget::Browser => {}
            SessionDisposalTarget::TabTarget { .. } => {
                self.remove_tab_session(cleanup_plan.session_id());
            }
            SessionDisposalTarget::SharedWorkerTarget { .. } => {
                if let Some(bc) = self.session_disposal_browser_context_mut(cleanup_plan) {
                    let _ = bc.detach_shared_worker_target_session(cleanup_plan.session_id());
                }
            }
            SessionDisposalTarget::DedicatedWorkerTarget { .. } => {
                if let Some(bc) = self.session_disposal_browser_context_mut(cleanup_plan) {
                    let _ = bc.detach_dedicated_worker_target_session(cleanup_plan.session_id());
                }
            }
            SessionDisposalTarget::ServiceWorkerTarget { .. } => {
                if let Some(bc) = self.session_disposal_browser_context_mut(cleanup_plan) {
                    let _ = bc.detach_service_worker_target_session(cleanup_plan.session_id());
                }
            }
            SessionDisposalTarget::PageTarget {
                session_key: moli_page_types::DevToolsSessionKey::Primary,
                ..
            } => {}
        }
    }

    async fn rollback_attached_session_with_cleanup_without_event_async(
        &mut self,
        rollback_plan: TargetAttachRollbackPlan,
    ) -> TargetEventPlan {
        if let Some(cleanup_plan) = rollback_plan.cleanup_plan()
            && let Err(error) =
                crate::domains::target::dispose_uncommitted_session_async(self, cleanup_plan).await
        {
            tracing::warn!(
                session_id = rollback_plan.session_id(),
                %error,
                "failed to clean prepared target binding during attach rollback"
            );
            // Keep both the domain binding and its control-plane route as
            // retry authority. Dropping only the latter would make any
            // renderer-owned state unreachable.
            return TargetEventPlan::default();
        }
        self.rollback_attached_session_without_event(rollback_plan.session_id())
    }

    pub(crate) fn auto_attached_session_detach_plan(
        &self,
        session_id: &str,
    ) -> TargetAutoAttachedSessionDetachPlan {
        let route = self.session_route(Some(session_id)).unwrap_or_else(|| {
            panic!("committed auto-attached session {session_id} must retain its route")
        });
        TargetAutoAttachedSessionDetachPlan::from_session_route(session_id, route)
    }

    pub(crate) fn rollback_auto_attached_session_detach_plan_without_event(
        &mut self,
        detach_plan: &TargetAutoAttachedSessionDetachPlan,
    ) -> TargetEventPlan {
        self.rollback_attached_session_without_event(detach_plan.session_id())
    }

    pub(crate) fn commit_session_disposal(
        &mut self,
        cleanup_plan: &SessionDisposalPlan,
    ) -> anyhow::Result<()> {
        match cleanup_plan.target() {
            SessionDisposalTarget::Browser => anyhow::bail!("InvalidSessionId"),
            SessionDisposalTarget::PageTarget {
                browser_context_id,
                target_id,
                session_key,
            } => {
                let bc = self
                    .browser_context_by_id_mut(browser_context_id)
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                anyhow::ensure!(
                    bc.remove_page_session_binding(
                        target_id,
                        cleanup_plan.session_id(),
                        session_key,
                    ),
                    "InvalidSessionId"
                );
            }
            SessionDisposalTarget::TabTarget { tab_target_id, .. } => {
                let removed_target_id = self
                    .remove_tab_session(cleanup_plan.session_id())
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                anyhow::ensure!(removed_target_id == *tab_target_id, "UnknownTargetId");
            }
            SessionDisposalTarget::SharedWorkerTarget {
                browser_context_id,
                target_id,
            } => {
                let bc = self
                    .browser_context_by_id_mut(browser_context_id)
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                let removed_target_id = bc
                    .detach_shared_worker_target_session(cleanup_plan.session_id())
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                anyhow::ensure!(removed_target_id == *target_id, "UnknownTargetId");
            }
            SessionDisposalTarget::DedicatedWorkerTarget {
                browser_context_id,
                target_id,
            } => {
                let bc = self
                    .browser_context_by_id_mut(browser_context_id)
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                let removed_target_id = bc
                    .detach_dedicated_worker_target_session(cleanup_plan.session_id())
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                anyhow::ensure!(removed_target_id == *target_id, "UnknownTargetId");
            }
            SessionDisposalTarget::ServiceWorkerTarget {
                browser_context_id,
                target_id,
            } => {
                let bc = self
                    .browser_context_by_id_mut(browser_context_id)
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                let removed_target_id = bc
                    .detach_service_worker_target_session(cleanup_plan.session_id())
                    .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
                anyhow::ensure!(removed_target_id == *target_id, "UnknownTargetId");
            }
        }
        Ok(())
    }

    fn session_disposal_browser_context_mut(
        &mut self,
        cleanup_plan: &SessionDisposalPlan,
    ) -> Option<&mut crate::conn::BrowserContext> {
        let browser_context_id = cleanup_plan.browser_context_id()?;
        self.browser_context_by_id_mut(browser_context_id)
    }

    pub(crate) fn commit_target_session_detachment_event_plan(
        &mut self,
        cleanup_plan: TargetSessionDetachCleanupPlan,
    ) -> TargetEventPlan {
        self.commit_target_session_detachment_event_plan_inner(cleanup_plan, true)
    }

    pub(crate) fn commit_target_session_detachment_after_prepared_state_delta_event_plan(
        &mut self,
        cleanup_plan: TargetSessionDetachCleanupPlan,
    ) -> TargetEventPlan {
        self.commit_target_session_detachment_event_plan_inner(cleanup_plan, false)
    }

    fn commit_target_session_detachment_event_plan_inner(
        &mut self,
        cleanup_plan: TargetSessionDetachCleanupPlan,
        emit_attached_state_delta: bool,
    ) -> TargetEventPlan {
        let session_id = cleanup_plan.session_id().to_owned();
        let target_id = cleanup_plan.target_id().to_owned();
        let reason = cleanup_plan.reason().map(str::to_owned);
        let parent_session_id = cleanup_plan
            .parent_session_id()
            .or_else(|| {
                self.target_control
                    .attached_session_owner_session_id(&session_id)
            })
            .map(str::to_owned);
        if emit_attached_state_delta {
            self.detach_known_session_event_plan(
                &target_id,
                &session_id,
                reason.as_deref(),
                parent_session_id.as_deref(),
            )
        } else {
            self.detach_known_session_event_plan_with_attached_state_delta(
                &target_id,
                &session_id,
                reason.as_deref(),
                parent_session_id.as_deref(),
                false,
            )
        }
    }

    fn remove_detached_session_control_owner(&mut self, session_id: &str) {
        self.target_control.remove_owner(Some(session_id));
    }

    pub(crate) fn attached_sessions_for_target(&self, target_id: &str) -> Vec<String> {
        self.target_control.attached_sessions_for_target(target_id)
    }

    pub(crate) fn target_has_waiting_for_debugger_session(&self, target_id: &str) -> bool {
        self.target_control
            .target_has_waiting_for_debugger_session(target_id)
    }

    pub(crate) fn release_waiting_for_debugger_session(
        &mut self,
        session_id: Option<&str>,
    ) -> bool {
        session_id.is_some_and(|session_id| {
            self.target_control
                .release_waiting_for_debugger_session(session_id)
        })
    }

    pub(crate) fn auto_attached_sessions_for_owner(
        &self,
        owner_session_id: Option<&str>,
    ) -> Vec<String> {
        self.target_control
            .auto_attached_sessions_for_owner(owner_session_id)
    }

    pub(crate) fn attached_session_cascade_for_owner(
        &self,
        owner_session_id: Option<&str>,
    ) -> Vec<String> {
        self.target_control
            .attached_session_cascade_for_owner(owner_session_id)
    }

    pub(crate) fn attached_session_cascade_for_root_frontend(&self) -> Vec<String> {
        self.target_control
            .attached_session_cascade_for_root_frontend()
    }

    pub(crate) fn auto_attached_session_cascade_for_owner(
        &self,
        owner_session_id: Option<&str>,
    ) -> Vec<String> {
        self.target_control
            .auto_attached_session_cascade_for_owner(owner_session_id)
    }
}