Skip to content

armgit / moli

Public Imported from GitHub
0

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

93.7 KB
Raw Blame
use crate::{
    network::{ResourceRequestClient, SharedWebStorageStore},
    page::{
        CompletedPageCommand, DocumentStartScript, EmulatedMediaOverrides, NavigationResponse,
        Page, PendingPageCommand, PermissionOverrideRegistration,
        RendererInspectorSessionRestoreSnapshot, RendererMainDocumentCommit,
        RendererPageCreationArtifacts, RendererPageCreationDiagnostics,
        RendererPendingDownloadActivation, RuntimeBindingRegistration,
        RuntimeIsolatedWorldDefinition, SubresourceAuthCredentials, SubresourceResourceType,
        ViewportSurface,
    },
    renderer::ExternalRawDocumentBodyStream,
    renderer::JsRuntime,
    renderer::PageVmInitStage,
};
use anyhow::{Context, Result, anyhow};
use moli_cookie_jar::{SharedBrowserCookieStore, new_shared_browser_cookie_store};
use moli_fetch::{
    BrowserNavigationRequestKind, FetchCancelHandle, FetchConfig, NetworkFetchResult, Request,
    StreamingRawResponse, ensure_http_status_success,
};
use moli_page_types::{LayoutConfiguration, LayoutPolicy, OptionalResourceFetchMask};
use moli_renderer_v8::{
    RendererBrowserContextRuntime, RendererBrowserContextRuntimeOwner,
    RendererBrowserContextRuntimeOwnerAccess, RendererReservedServiceWorkerClient,
    RendererServiceWorkerMainResourceFetch, RendererWebStorageHandles, SharedStorageBucketStore,
    WeakIndexedDbManager,
    network::{
        BrowserResourceRuntime, BrowserResourceRuntimeOwner, PageNetworkPolicy,
        navigation::{DocumentFetchContextSeed, NavigationResourceLoader},
    },
};
use std::rc::Rc;
use std::sync::Arc;
use url::Url;

#[derive(Debug, Clone)]
struct DocumentPageLoadOptions {
    pub resource_source: CommittedDocumentResourceSource,
    pub root_frame_id: Option<String>,
    pub main_document_commit: Option<RendererMainDocumentCommit>,
    pub requested_url: Url,
    pub final_url: Url,
    pub navigation_initiator_url: Option<Url>,
    pub redirected: bool,
    pub redirect_count: usize,
    pub response_status: u16,
    pub response_headers: Vec<(String, Vec<u8>)>,
    pub response_body: String,
    pub document_start_scripts: Vec<DocumentStartScript>,
    pub runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
    pub runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
    pub extra_http_headers: moli_fetch::RequestHeaders,
    pub script_execution_disabled: bool,
    pub bypass_content_security_policy: bool,
    pub emulated_media: EmulatedMediaOverrides,
    pub viewport_surface: Option<ViewportSurface>,
    pub network_offline: bool,
    pub blocked_url_patterns: Vec<String>,
    pub fetch_subresource_interception_enabled: bool,
    pub fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
}

/// Explicit resource authority source for a newly committed top-level Document.
///
/// A real network navigation must carry the seed minted by its
/// `NavigationResourceLoader`. Synthetic Documents deliberately use the
/// NavigationEngine's current browser runtime and Page policy. Keeping these
/// cases distinct prevents a missing navigation seed from silently falling
/// back to ambient state.
#[derive(Debug, Clone)]
pub enum CommittedDocumentResourceSource {
    Navigation(Box<DocumentFetchContextSeed>),
    Synthetic,
}

fn streaming_raw_response_from_navigation_response(
    response: NavigationResponse,
) -> Result<StreamingRawResponse> {
    let head = response.head();
    let body = response.clone_body_bytes();
    let (body_tx, body_rx) = tokio::sync::mpsc::unbounded_channel();
    if !body.is_empty() {
        body_tx
            .send(body)
            .map_err(|_| anyhow!("failed to enqueue service worker main resource body"))?;
    }
    drop(body_tx);
    let (completion_tx, completion_rx) = tokio::sync::oneshot::channel();
    let _ = completion_tx.send(Ok(()));
    Ok(StreamingRawResponse::new_with_head(
        head,
        body_rx,
        FetchCancelHandle::new(),
        completion_rx,
    ))
}

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

impl NavigationResourceStorageHandles {
    pub fn new(
        cookie_store: SharedBrowserCookieStore,
        web_storage_store: SharedWebStorageStore,
        session_storage_store: SharedWebStorageStore,
    ) -> Self {
        Self {
            cookie_store,
            web_storage_store,
            session_storage_store,
        }
    }

    fn into_cookie_store(self) -> SharedBrowserCookieStore {
        self.cookie_store
    }

    fn into_page_parts(self) -> (SharedBrowserCookieStore, RendererWebStorageHandles) {
        (
            self.cookie_store,
            RendererWebStorageHandles::new(self.web_storage_store, self.session_storage_store),
        )
    }
}

#[derive(Clone)]
pub struct NavigationPageStorageHandles {
    resource_storage: NavigationResourceStorageHandles,
    indexed_db_manager: Option<WeakIndexedDbManager>,
    storage_bucket_store: Option<SharedStorageBucketStore>,
}

pub struct NavigationStreamingRawResponse {
    pub fetch_result: NetworkFetchResult<StreamingRawResponse>,
    pub reserved_service_worker_client: Option<RendererReservedServiceWorkerClient>,
    pub document_fetch_context_seed: DocumentFetchContextSeed,
}

impl NavigationPageStorageHandles {
    pub fn new(
        cookie_store: SharedBrowserCookieStore,
        web_storage_store: SharedWebStorageStore,
        session_storage_store: SharedWebStorageStore,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
    ) -> Self {
        Self {
            resource_storage: NavigationResourceStorageHandles::new(
                cookie_store,
                web_storage_store,
                session_storage_store,
            ),
            indexed_db_manager,
            storage_bucket_store,
        }
    }

    fn into_parts(
        self,
    ) -> (
        SharedBrowserCookieStore,
        RendererWebStorageHandles,
        Option<WeakIndexedDbManager>,
        Option<SharedStorageBucketStore>,
    ) {
        let (cookie_store, web_storage) = self.resource_storage.into_page_parts();
        (
            cookie_store,
            web_storage,
            self.indexed_db_manager,
            self.storage_bucket_store,
        )
    }
}

pub struct BuiltDocumentPage {
    pub page: Page,
    pub page_creation_diagnostics: RendererPageCreationDiagnostics,
    pub page_creation_artifacts: RendererPageCreationArtifacts,
    pub pending_download: Option<RendererPendingDownloadActivation>,
}

/// Commit metadata for a Document installed in the caller's existing Page.
/// The owning Page handle stays with that caller throughout the operation.
pub struct CommittedDocumentPageReplacement {
    pub page_creation_diagnostics: RendererPageCreationDiagnostics,
    pub page_creation_artifacts: RendererPageCreationArtifacts,
    pub pending_download: Option<RendererPendingDownloadActivation>,
}

/// A renderer document whose isolate and DevTools agent are reserved, but
/// whose parser and execution contexts have not started.
pub struct PreparedDocumentPage {
    prepared: moli_renderer_v8::PreparedRendererDocument,
}

#[derive(Debug, Clone)]
pub struct PreparedDocumentPageCommitConfiguration {
    pub web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,
    pub document_start_scripts: Vec<DocumentStartScript>,
    pub runtime_bindings: Vec<RuntimeBindingRegistration>,
    pub runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
    pub runtime_isolated_worlds: Vec<RuntimeIsolatedWorldDefinition>,
    pub permission_overrides: Vec<PermissionOverrideRegistration>,
    pub extra_http_headers: moli_fetch::RequestHeaders,
    pub document_settings: moli_page_types::DocumentSettings,
    pub browser_resource_runtime: BrowserResourceRuntime,
    pub navigator_identity: moli_browser_profile::BrowserIdentityProfile,
    pub network_offline: bool,
    pub bypass_service_worker: bool,
    pub cache_disabled: bool,
    pub blocked_url_patterns: Vec<String>,
    pub fetch_subresource_interception: (bool, Option<SubresourceResourceType>),
}

impl std::fmt::Debug for PreparedDocumentPage {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("PreparedDocumentPage")
            .field(
                "renderer_devtools_agent_token",
                &self.prepared.renderer_devtools_agent_token(),
            )
            .finish_non_exhaustive()
    }
}

/// Typed authority to start one exact prepared renderer document.
#[derive(Debug)]
pub struct PreparedDocumentPageCommitPermit {
    permit: moli_renderer_v8::RendererDocumentCommitPermit,
}

impl PreparedDocumentPage {
    pub fn renderer_owner_local_host_id(&self) -> moli_renderer_v8::RendererOwnerLocalHostId {
        self.prepared.token().local_host_id()
    }

    pub fn renderer_page_id(&self) -> moli_renderer_v8::PageId {
        self.prepared.token().page_id()
    }

    pub fn renderer_devtools_agent_token(&self) -> crate::page::RendererDevToolsAgentToken {
        self.prepared.renderer_devtools_agent_token()
    }

    pub async fn update_commit_configuration(
        &self,
        configuration: PreparedDocumentPageCommitConfiguration,
    ) -> Result<()> {
        self.prepared
            .update_commit_configuration(
                moli_renderer_v8::RendererPreparedDocumentCommitConfiguration {
                    web_mcp_invocation: configuration.web_mcp_invocation,
                    document_start_scripts: configuration.document_start_scripts,
                    runtime_bindings: configuration.runtime_bindings,
                    runtime_inspector_session_restore_snapshots: configuration
                        .runtime_inspector_session_restore_snapshots,
                    runtime_isolated_worlds: configuration.runtime_isolated_worlds,
                    permission_overrides: configuration.permission_overrides,
                    extra_http_headers: configuration.extra_http_headers,
                    document_settings: configuration.document_settings,
                    browser_resource_runtime: configuration.browser_resource_runtime,
                    navigator_identity: configuration.navigator_identity,
                    network_offline: configuration.network_offline,
                    bypass_service_worker: configuration.bypass_service_worker,
                    cache_disabled: configuration.cache_disabled,
                    blocked_url_patterns: configuration.blocked_url_patterns,
                    fetch_subresource_interception_enabled: configuration
                        .fetch_subresource_interception
                        .0,
                    fetch_subresource_interception_resource_type: configuration
                        .fetch_subresource_interception
                        .1,
                },
            )
            .await
    }

    pub fn issue_commit_permit(&self) -> PreparedDocumentPageCommitPermit {
        PreparedDocumentPageCommitPermit {
            permit: self.prepared.issue_commit_permit(),
        }
    }

    pub async fn commit(
        self,
        permit: PreparedDocumentPageCommitPermit,
    ) -> Result<BuiltDocumentPage> {
        let (
            handle,
            page_state,
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        ) = self
            .prepared
            .commit(permit.permit)
            .await
            .context("failed to commit prepared streaming raw page")?;
        Ok(BuiltDocumentPage {
            page: Page::from_attached_handle(handle, page_state),
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        })
    }

    pub async fn cancel(self) -> Result<()> {
        self.prepared.cancel().await
    }

    pub async fn commit_page_replacement(
        self,
        permit: PreparedDocumentPageCommitPermit,
        page: &mut Page,
    ) -> std::result::Result<
        CommittedDocumentPageReplacement,
        moli_renderer_v8::RendererPageReplacementError,
    > {
        use moli_renderer_v8::RendererPageReplacementError;
        if self.renderer_owner_local_host_id() != page.renderer_owner_local_host_id()
            || self.renderer_page_id() != page.renderer_page_id()
        {
            return Err(RendererPageReplacementError::document_preserved(anyhow!(
                "prepared Document belongs to a different live Page"
            )));
        }
        let mut replacement = self.prepared.commit_page_replacement(permit.permit).await?;
        let pending_download = replacement.take_pending_download();
        let (page_creation_diagnostics, page_creation_artifacts) = page
            .adopt_renderer_document_replacement(replacement)
            .map_err(RendererPageReplacementError::document_unavailable)?;
        Ok(CommittedDocumentPageReplacement {
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        })
    }
}

/// Handle to an in-flight document page build started via
/// [`NavigationEngine::start_build_html_page_from_response`]. The renderer
/// thread is concurrently performing the V8 + parse work; the caller awaits
/// [`Self::await_ready`] when the resulting page is needed.
pub struct PendingBuiltDocumentPage {
    pending: moli_renderer_v8::PendingHtmlPage,
}

impl PendingBuiltDocumentPage {
    pub async fn await_ready(self) -> Result<BuiltDocumentPage> {
        let (
            handle,
            page_state,
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        ) = self
            .pending
            .await_ready()
            .await
            .context("failed to build html page")?;
        let page = Page::from_attached_handle(handle, page_state);
        Ok(BuiltDocumentPage {
            page,
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        })
    }
}

/// Configuration copied into each Page-owned or standalone NavigationEngine.
#[derive(Debug, Clone)]
pub struct NavigationRuntimeConfig {
    fetch_config: FetchConfig,
    optional_resource_fetch_mask: OptionalResourceFetchMask,
    subframe_loading_enabled: bool,
    layout_configuration: LayoutConfiguration,
    debugger_enabled: bool,
}

impl NavigationRuntimeConfig {
    pub fn new(
        fetch_config: FetchConfig,
        optional_resource_fetch_mask: OptionalResourceFetchMask,
        subframe_loading_enabled: bool,
        layout_policy: LayoutPolicy,
    ) -> Self {
        Self::new_with_layout_configuration(
            fetch_config,
            optional_resource_fetch_mask,
            subframe_loading_enabled,
            LayoutConfiguration {
                policy: layout_policy,
                ..LayoutConfiguration::default()
            },
        )
    }

    pub fn new_with_layout_configuration(
        fetch_config: FetchConfig,
        optional_resource_fetch_mask: OptionalResourceFetchMask,
        subframe_loading_enabled: bool,
        layout_configuration: LayoutConfiguration,
    ) -> Self {
        Self {
            fetch_config,
            optional_resource_fetch_mask,
            subframe_loading_enabled,
            layout_configuration,
            debugger_enabled: false,
        }
    }

    pub fn fetch_config(&self) -> &FetchConfig {
        &self.fetch_config
    }

    pub fn fetch_config_mut(&mut self) -> &mut FetchConfig {
        &mut self.fetch_config
    }

    pub fn optional_resource_fetch_mask(&self) -> OptionalResourceFetchMask {
        self.optional_resource_fetch_mask
    }

    pub fn subframe_loading_enabled(&self) -> bool {
        self.subframe_loading_enabled
    }

    pub fn layout_policy(&self) -> LayoutPolicy {
        self.layout_configuration.policy
    }

    pub fn scrollbars_hidden(&self) -> bool {
        self.layout_configuration.scrollbars_hidden
    }

    pub fn with_scrollbars_hidden(mut self, hidden: bool) -> Self {
        self.layout_configuration.scrollbars_hidden = hidden;
        self
    }

    pub fn layout_configuration(&self) -> LayoutConfiguration {
        self.layout_configuration
    }

    pub fn debugger_enabled(&self) -> bool {
        self.debugger_enabled
    }

    pub fn with_debugger_enabled(mut self, enabled: bool) -> Self {
        self.debugger_enabled = enabled;
        self
    }
}

impl Default for NavigationRuntimeConfig {
    fn default() -> Self {
        Self::new(
            FetchConfig::default(),
            OptionalResourceFetchMask::NONE,
            true,
            LayoutPolicy::default(),
        )
    }
}

impl From<&crate::config::BrowserConfig> for NavigationRuntimeConfig {
    fn from(config: &crate::config::BrowserConfig) -> Self {
        Self::new_with_layout_configuration(
            config.fetch().clone(),
            config.optional_resource_fetch_mask(),
            config.subframe_loading_enabled(),
            config.layout_configuration(),
        )
        .with_debugger_enabled(config.debugger_enabled())
    }
}

#[derive(Debug, Clone)]
pub struct NavigationEngine {
    fetch_config: FetchConfig,
    page_network_policy: PageNetworkPolicy,
    layout_configuration: LayoutConfiguration,
    debugger_enabled: bool,
    emulated_scrollbars_hidden: bool,
    js_runtime: JsRuntime,
    resource_runtime: Option<BrowserResourceRuntime>,
    browser_context_access: RendererBrowserContextRuntimeOwnerAccess,
    document_activity: moli_page_types::DocumentActivity,
    // Standalone engines share this last-drop owner. BrowserContext engines
    // leave it empty and borrow only the context's weak, bound access.
    standalone_lifetime_owner: Option<Rc<NavigationEngineLifetimeOwner>>,
}

#[derive(Debug)]
struct NavigationEngineLifetimeOwner {
    js_runtime: Option<JsRuntime>,
    browser_context_owner: RendererBrowserContextRuntimeOwner,
}

impl Drop for NavigationEngineLifetimeOwner {
    fn drop(&mut self) {
        if let Some(js_runtime) = self.js_runtime.take() {
            js_runtime.terminate_resource_producers_for_owner_shutdown();
            drop(js_runtime);
        }
        self.browser_context_owner.shutdown_and_join();
    }
}

impl Default for NavigationEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl NavigationEngine {
    /// Reserves a renderer Page identity before the corresponding creation
    /// command is enqueued.
    ///
    /// A protocol owner can bind this identity to its pending target before
    /// parser or author-script output becomes publishable.
    pub fn reserve_page_for_creation(&self) -> moli_renderer_v8::RendererPageReservationToken {
        self.js_runtime.reserve_page_for_creation()
    }

    pub fn new() -> Self {
        Self::new_with_runtime_config(NavigationRuntimeConfig::default())
    }

    pub fn new_with_fetch_config(fetch_config: FetchConfig) -> Self {
        Self::new_with_runtime_config(NavigationRuntimeConfig::new(
            fetch_config,
            OptionalResourceFetchMask::NONE,
            true,
            LayoutPolicy::default(),
        ))
    }

    pub fn new_with_fetch_config_and_image_fetch_enabled(
        fetch_config: FetchConfig,
        image_fetch_enabled: bool,
    ) -> Self {
        let mask = if image_fetch_enabled {
            OptionalResourceFetchMask::IMAGE
        } else {
            OptionalResourceFetchMask::NONE
        };
        Self::new_with_fetch_config_and_resource_loading(fetch_config, mask, true)
    }

    pub fn new_with_fetch_config_and_resource_loading(
        fetch_config: FetchConfig,
        optional_resource_fetch_mask: OptionalResourceFetchMask,
        subframe_loading_enabled: bool,
    ) -> Self {
        Self::new_with_runtime_config(NavigationRuntimeConfig::new(
            fetch_config,
            optional_resource_fetch_mask,
            subframe_loading_enabled,
            LayoutPolicy::default(),
        ))
    }

    pub fn new_with_runtime_config(config: NavigationRuntimeConfig) -> Self {
        let resource_runtime = BrowserResourceRuntimeOwner::new(
            config.fetch_config(),
            new_shared_browser_cookie_store(),
        );
        let browser_context_owner =
            RendererBrowserContextRuntime::new_owned_with_service_worker_resource_store_and_browser_resource_runtime(
                moli_renderer_v8::new_shared_service_worker_resource_store(),
                resource_runtime,
                config.debugger_enabled(),
            );
        let browser_context_access = browser_context_owner.owner_access();
        Self::new_with_runtime_config_and_browser_context_access_inner(
            config,
            browser_context_access,
            Some(browser_context_owner),
            None,
        )
        .expect("standalone browser context owner must remain live during construction")
    }

    pub fn new_with_fetch_config_and_browser_context_access(
        fetch_config: FetchConfig,
        browser_context_access: RendererBrowserContextRuntimeOwnerAccess,
        optional_resource_fetch_mask: OptionalResourceFetchMask,
        subframe_loading_enabled: bool,
    ) -> Result<Self> {
        Self::new_with_runtime_config_and_browser_context_access(
            NavigationRuntimeConfig::new(
                fetch_config,
                optional_resource_fetch_mask,
                subframe_loading_enabled,
                LayoutPolicy::default(),
            ),
            browser_context_access,
        )
    }

    pub fn new_with_runtime_config_and_browser_context_access(
        config: NavigationRuntimeConfig,
        browser_context_access: RendererBrowserContextRuntimeOwnerAccess,
    ) -> Result<Self> {
        Self::new_with_runtime_config_and_browser_context_access_inner(
            config,
            browser_context_access,
            None,
            None,
        )
    }

    pub fn new_for_pending_auxiliary_page(
        config: NavigationRuntimeConfig,
        browser_context_access: RendererBrowserContextRuntimeOwnerAccess,
        page: &moli_renderer_v8::RendererPendingAuxiliaryPage,
    ) -> Result<Self> {
        Self::new_with_runtime_config_and_browser_context_access_inner(
            config,
            browser_context_access,
            None,
            Some(page.renderer_runtime()),
        )
    }

    fn new_with_runtime_config_and_browser_context_access_inner(
        config: NavigationRuntimeConfig,
        browser_context_access: RendererBrowserContextRuntimeOwnerAccess,
        standalone_browser_context_owner: Option<RendererBrowserContextRuntimeOwner>,
        existing_runtime: Option<JsRuntime>,
    ) -> Result<Self> {
        let NavigationRuntimeConfig {
            fetch_config,
            optional_resource_fetch_mask,
            subframe_loading_enabled,
            layout_configuration,
            debugger_enabled,
        } = config;
        let resource_runtime = browser_context_access
            .current_browser_resource_runtime()
            .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
        let js_runtime = match existing_runtime {
            Some(runtime) => {
                anyhow::ensure!(
                    runtime
                        .browser_context_runtime()
                        .shares_state_with(&browser_context_access.runtime()),
                    "auxiliary Page cannot be adopted into a different browser context"
                );
                runtime
            }
            None => {
                JsRuntime::initialize_with_browser_context_owner_access(&browser_context_access)?
            }
        };
        js_runtime
            .renderer_owner_handle()
            .configure_layout_configuration(layout_configuration)?;
        let standalone_lifetime_owner = standalone_browser_context_owner.map(|owner| {
            Rc::new(NavigationEngineLifetimeOwner {
                js_runtime: Some(js_runtime.clone()),
                browser_context_owner: owner,
            })
        });
        Ok(Self {
            fetch_config,
            page_network_policy: PageNetworkPolicy::new(
                optional_resource_fetch_mask,
                subframe_loading_enabled,
                false,
            ),
            layout_configuration,
            debugger_enabled,
            emulated_scrollbars_hidden: false,
            js_runtime,
            resource_runtime: Some(resource_runtime),
            browser_context_access,
            document_activity: Default::default(),
            standalone_lifetime_owner,
        })
    }

    pub fn new_with_fetch_config_and_shared_renderer_owner(
        fetch_config: FetchConfig,
        renderer_owner_source: &Self,
        optional_resource_fetch_mask: OptionalResourceFetchMask,
        subframe_loading_enabled: bool,
    ) -> Result<Self> {
        Self::new_with_runtime_config_and_shared_renderer_owner(
            NavigationRuntimeConfig::new_with_layout_configuration(
                fetch_config,
                optional_resource_fetch_mask,
                subframe_loading_enabled,
                renderer_owner_source.layout_configuration,
            )
            .with_debugger_enabled(renderer_owner_source.debugger_enabled),
            renderer_owner_source,
        )
    }

    pub fn new_with_runtime_config_and_shared_renderer_owner(
        config: NavigationRuntimeConfig,
        renderer_owner_source: &Self,
    ) -> Result<Self> {
        let NavigationRuntimeConfig {
            fetch_config,
            optional_resource_fetch_mask,
            subframe_loading_enabled,
            layout_configuration,
            debugger_enabled,
        } = config;
        renderer_owner_source
            .js_runtime
            .renderer_owner_handle()
            .configure_layout_configuration(layout_configuration)?;
        let resource_runtime = renderer_owner_source
            .browser_context_access
            .current_browser_resource_runtime()
            .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
        Ok(Self {
            fetch_config,
            page_network_policy: PageNetworkPolicy::new(
                optional_resource_fetch_mask,
                subframe_loading_enabled,
                false,
            ),
            layout_configuration,
            debugger_enabled,
            emulated_scrollbars_hidden: false,
            js_runtime: renderer_owner_source.js_runtime.clone(),
            resource_runtime: Some(resource_runtime),
            browser_context_access: renderer_owner_source.browser_context_access.clone(),
            document_activity: Default::default(),
            standalone_lifetime_owner: renderer_owner_source.standalone_lifetime_owner.clone(),
        })
    }

    pub fn new_with_page_vm_document_isolate_for_diagnostics() -> Self {
        Self::new()
    }

    pub fn browser_context_runtime(&self) -> RendererBrowserContextRuntime {
        self.js_runtime.browser_context_runtime()
    }

    pub fn browser_context_owner_access(&self) -> RendererBrowserContextRuntimeOwnerAccess {
        self.browser_context_access.clone()
    }

    pub fn terminate_renderer_producers_for_owner_shutdown(&self) {
        self.js_runtime
            .terminate_resource_producers_for_owner_shutdown();
    }

    pub fn set_document_activity(&mut self, activity: moli_page_types::DocumentActivity) {
        self.document_activity = activity;
    }

    /// Seeds target-local scrollbar emulation before the next Document starts.
    pub fn set_emulated_scrollbars_hidden(&mut self, hidden: bool) {
        self.emulated_scrollbars_hidden = hidden;
    }

    pub fn document_isolate_accounting_for_diagnostics(
        &self,
    ) -> crate::page::RendererDocumentIsolateAccountingDiagnostics {
        self.js_runtime
            .document_isolate_accounting_for_diagnostics()
    }

    pub fn document_isolate_model_for_diagnostics(&self) -> &'static str {
        self.js_runtime.document_isolate_model_for_diagnostics()
    }

    pub fn renderer_owner_id_for_diagnostics(&self) -> u64 {
        self.js_runtime.renderer_owner_id_for_diagnostics()
    }

    pub fn shares_renderer_owner_with(&self, other: &Self) -> bool {
        self.js_runtime
            .shares_renderer_owner_with(&other.js_runtime)
    }

    pub fn set_renderer_output_transport_sender(
        &self,
        sender: crate::RendererOutputTransportSender,
    ) {
        self.js_runtime.set_renderer_output_transport_sender(sender);
    }

    pub fn fetch_config(&self) -> &FetchConfig {
        &self.fetch_config
    }

    pub fn runtime_config(&self) -> NavigationRuntimeConfig {
        NavigationRuntimeConfig::new_with_layout_configuration(
            self.fetch_config.clone(),
            self.optional_resource_fetch_mask(),
            self.subframe_loading_enabled(),
            self.layout_configuration,
        )
        .with_debugger_enabled(self.debugger_enabled)
    }

    pub fn debugger_enabled(&self) -> bool {
        self.debugger_enabled
    }

    pub fn layout_policy(&self) -> LayoutPolicy {
        self.layout_configuration.policy
    }

    pub fn image_fetch_enabled(&self) -> bool {
        self.page_network_policy
            .optional_resource_fetch_mask()
            .contains(OptionalResourceFetchMask::IMAGE)
    }

    pub fn optional_resource_fetch_mask(&self) -> OptionalResourceFetchMask {
        self.page_network_policy.optional_resource_fetch_mask()
    }

    pub fn subframe_loading_enabled(&self) -> bool {
        self.page_network_policy.subframe_loading_enabled()
    }

    pub fn set_bypass_service_worker(&mut self, bypass: bool) {
        self.page_network_policy.set_bypass_service_worker(bypass);
    }

    pub fn set_cache_disabled(&mut self, disabled: bool) {
        self.page_network_policy.set_cache_disabled(disabled);
    }

    pub fn set_extra_http_headers(&mut self, headers: &moli_fetch::RequestHeaders) {
        self.page_network_policy.set_extra_http_headers(headers);
    }

    pub fn set_network_offline(&mut self, offline: bool) {
        self.page_network_policy.set_network_offline(offline);
    }

    pub fn set_blocked_url_patterns(&mut self, patterns: &[String]) {
        self.page_network_policy.set_blocked_url_patterns(patterns);
    }

    fn ensure_resource_runtime(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<BrowserResourceRuntime> {
        let current_runtime = self
            .browser_context_access
            .current_browser_resource_runtime()
            .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
        if self
            .resource_runtime
            .as_ref()
            .is_none_or(|cached| !cached.shares_state_with(&current_runtime))
        {
            // An ambient NavigationEngine cache is not a Document lease. Once
            // another wrapper replaces the context binding, its next request
            // must converge on that current runtime instead of reviving a
            // retired backend merely because the cookie-store Arc matches.
            self.resource_runtime = Some(current_runtime);
        }
        let should_rebuild = self.resource_runtime.as_ref().is_none_or(|runtime| {
            !Arc::ptr_eq(&runtime.cookie_store(), &cookie_store)
                || !runtime.matches_fetch_config(&self.fetch_config)
        });
        if should_rebuild {
            let registration = BrowserResourceRuntimeOwner::new(&self.fetch_config, cookie_store);
            let resource_runtime = self
                .browser_context_access
                .replace_owned(registration)
                .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
            self.resource_runtime = Some(resource_runtime);
            self.browser_context_access.reap_retired_resource_runtimes();
        }
        Ok(self
            .resource_runtime
            .as_ref()
            .expect("resource runtime must exist after ensure")
            .clone())
    }

    fn ensure_resource_request_client(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<ResourceRequestClient> {
        Ok(
            ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy(
                self.ensure_resource_runtime(cookie_store)?,
                self.page_network_policy.clone(),
            ),
        )
    }

    fn resource_request_client_for_committed_document(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        expected_final_url: &Url,
        source: CommittedDocumentResourceSource,
    ) -> Result<ResourceRequestClient> {
        let CommittedDocumentResourceSource::Navigation(seed) = source else {
            let expected_runtime = self.ensure_resource_runtime(cookie_store)?;
            return Ok(
                ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy(
                    expected_runtime,
                    self.page_network_policy.clone(),
                ),
            );
        };
        if seed.final_url() != expected_final_url {
            anyhow::bail!(
                "navigation commit seed final URL `{}` does not match committed Document `{expected_final_url}`",
                seed.final_url(),
            );
        }
        let committed_runtime = seed.browser_resource_runtime();
        if self
            .browser_context_access
            .validate_registered(&committed_runtime)
            .is_err()
            || !Arc::ptr_eq(&committed_runtime.cookie_store(), &cookie_store)
            || !committed_runtime.matches_fetch_config(&self.fetch_config)
        {
            anyhow::bail!(
                "navigation commit seed does not belong to the NavigationEngine browser resource runtime"
            );
        }
        // Another target sharing this BrowserContext may replace the ambient
        // transport binding while this request is in flight. The immutable
        // navigation seed remains the exact authority for the committed
        // Document as long as its runtime is still registered under this
        // owner and matches the target's captured policy.
        self.resource_runtime = Some(committed_runtime.clone());
        Ok(
            ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy(
                committed_runtime,
                seed.page_network_policy(),
            ),
        )
    }

    pub fn resource_request_client(&self) -> Option<ResourceRequestClient> {
        self.resource_runtime.as_ref().map(|runtime| {
            ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy(
                runtime.clone(),
                self.page_network_policy.clone(),
            )
        })
    }

    /// Adopts only the browser-level transport/cache runtime. The target keeps
    /// its own Page network policy.
    pub fn adopt_registered_resource_runtime(
        &mut self,
        resource_runtime: BrowserResourceRuntime,
    ) -> Result<()> {
        self.browser_context_access
            .adopt_registered(resource_runtime.clone())
            .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
        self.resource_runtime = Some(resource_runtime);
        self.browser_context_access.reap_retired_resource_runtimes();
        Ok(())
    }

    fn ensure_resource_runtime_ready(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<()> {
        self.ensure_resource_runtime(cookie_store).map(|_| ())
    }

    pub fn ensure_resource_runtime_ready_for_navigation_storage(
        &mut self,
        storage: NavigationResourceStorageHandles,
    ) -> Result<()> {
        self.ensure_resource_runtime_ready(storage.cookie_store)
    }

    fn ensure_resource_request_client_clone(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<ResourceRequestClient> {
        self.ensure_resource_request_client(cookie_store)
    }

    fn rebuild_resource_request_client(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<ResourceRequestClient> {
        // Rebuild is an explicit transport/config replacement, not an
        // `ensure` cache miss. The cookie-store identity may be unchanged when
        // CDP updates only user agent, proxy, TLS, or another FetchConfig
        // field, so consulting the current binding here would incorrectly
        // preserve the old backend.
        let resource_runtime = self
            .browser_context_access
            .replace_owned(BrowserResourceRuntimeOwner::new(
                &self.fetch_config,
                cookie_store,
            ))
            .map_err(|error| anyhow!("browser context resource owner unavailable: {error}"))?;
        self.resource_runtime = Some(resource_runtime.clone());
        self.browser_context_access.reap_retired_resource_runtimes();
        Ok(
            ResourceRequestClient::from_browser_resource_runtime_with_page_network_policy(
                resource_runtime,
                self.page_network_policy.clone(),
            ),
        )
    }

    pub fn rebuild_resource_request_client_for_navigation_storage(
        &mut self,
        storage: NavigationResourceStorageHandles,
    ) -> Result<ResourceRequestClient> {
        self.rebuild_resource_request_client(storage.cookie_store)
    }

    fn ensure_cookie_store(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
    ) -> Result<SharedBrowserCookieStore> {
        Ok(self.ensure_resource_runtime(cookie_store)?.cookie_store())
    }

    fn navigation_resource_loader(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        requested_url: Url,
        cancel_handle: FetchCancelHandle,
    ) -> Result<NavigationResourceLoader> {
        Ok(NavigationResourceLoader::new_with_cancel_handle(
            self.ensure_resource_request_client(cookie_store)?,
            requested_url,
            moli_renderer_v8::network::RendererResourceTaskRunner::from_current_tokio()?,
            cancel_handle,
        ))
    }

    pub fn ensure_cookie_store_for_navigation_storage(
        &mut self,
        storage: NavigationResourceStorageHandles,
    ) -> Result<SharedBrowserCookieStore> {
        self.ensure_cookie_store(storage.cookie_store)
    }

    async fn fetch_navigation_response_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        initiator_url: Option<&Url>,
        browser_navigation_kind: BrowserNavigationRequestKind,
        infer_referrer_from_initiator: bool,
        request_metadata: Option<moli_fetch::SubresourceRequestMetadata>,
        request_origin: Option<moli_url::WebOrigin>,
        method: &str,
        raw_url: &str,
        body: Option<bytes::Bytes>,
        request_headers: moli_fetch::RequestHeaders,
        auth: Option<SubresourceAuthCredentials>,
    ) -> Result<NetworkFetchResult<NavigationResponse>> {
        let mut request = Request::new_browser_bytes(
            method,
            raw_url,
            body,
            request_headers,
            request_origin.unwrap_or_else(|| {
                initiator_url.map_or(moli_url::WebOrigin::Opaque, moli_url::WebOrigin::from_url)
            }),
        )
        .map(|request| {
            let request = request.with_top_level_navigation_cookie_context();
            let mut request = request.with_browser_navigation_kind(browser_navigation_kind);
            if !infer_referrer_from_initiator {
                request = request.without_inferred_referrer();
            }
            if let Some(metadata) = request_metadata {
                request = request.with_subresource_request_metadata(metadata);
            }
            if let Some(initiator_url) = initiator_url {
                request.with_initiator_url(initiator_url)
            } else {
                request
            }
        })
        .context("failed to build request")?;
        request.set_auth(auth.map(Into::into));
        let navigation_loader = self.navigation_resource_loader(
            cookie_store,
            request.url.clone(),
            FetchCancelHandle::new(),
        )?;
        navigation_loader
            .fetch_with_network_metadata(request)
            .await
            .map(|result| result.map_response(NavigationResponse::from))
    }

    pub async fn fetch_navigation_response_with_storage_async(
        &mut self,
        storage: NavigationResourceStorageHandles,
        initiator_url: Option<&Url>,
        browser_navigation_kind: BrowserNavigationRequestKind,
        infer_referrer_from_initiator: bool,
        request_metadata: Option<moli_fetch::SubresourceRequestMetadata>,
        request_origin: Option<moli_url::WebOrigin>,
        method: &str,
        raw_url: &str,
        body: Option<String>,
        request_headers: moli_fetch::RequestHeaders,
        auth: Option<SubresourceAuthCredentials>,
    ) -> Result<NetworkFetchResult<NavigationResponse>> {
        let cookie_store = storage.into_cookie_store();
        self.fetch_navigation_response_async(
            cookie_store,
            initiator_url,
            browser_navigation_kind,
            infer_referrer_from_initiator,
            request_metadata,
            request_origin,
            method,
            raw_url,
            body.map(bytes::Bytes::from),
            request_headers,
            auth,
        )
        .await
    }

    async fn fetch_navigation_streaming_raw_response_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        initiator_url: Option<&Url>,
        browser_navigation_kind: BrowserNavigationRequestKind,
        infer_referrer_from_initiator: bool,
        request_metadata: Option<moli_fetch::SubresourceRequestMetadata>,
        request_origin: Option<moli_url::WebOrigin>,
        method: &str,
        raw_url: &str,
        body: Option<bytes::Bytes>,
        request_headers: moli_fetch::RequestHeaders,
        auth: Option<SubresourceAuthCredentials>,
        cancel_handle: FetchCancelHandle,
    ) -> Result<NavigationStreamingRawResponse> {
        let mut request = Request::new_browser_bytes(
            method,
            raw_url,
            body,
            request_headers,
            request_origin.unwrap_or_else(|| {
                initiator_url.map_or(moli_url::WebOrigin::Opaque, moli_url::WebOrigin::from_url)
            }),
        )
        .map(|request| {
            let request = request.with_top_level_navigation_cookie_context();
            let mut request = request.with_browser_navigation_kind(browser_navigation_kind);
            if !infer_referrer_from_initiator {
                request = request.without_inferred_referrer();
            }
            if let Some(metadata) = request_metadata {
                request = request.with_subresource_request_metadata(metadata);
            }
            if let Some(initiator_url) = initiator_url {
                request.with_initiator_url(initiator_url)
            } else {
                request
            }
        })
        .context("failed to build request")?;
        request.set_auth(auth.map(Into::into));
        let navigation_loader =
            self.navigation_resource_loader(cookie_store, request.url.clone(), cancel_handle)?;
        let service_worker_fetch = self
            .browser_context_runtime()
            .fetch_service_worker_main_resource_for_navigation(&request, &navigation_loader)
            .await?;
        let RendererServiceWorkerMainResourceFetch {
            reserved_client,
            response,
        } = service_worker_fetch;
        if let Some(response) = response {
            navigation_loader.note_service_worker_response_ready()?;
            let final_url = response.final_url.clone();
            return Ok(NavigationStreamingRawResponse {
                fetch_result: NetworkFetchResult::without_request_observation(
                    streaming_raw_response_from_navigation_response(response)?,
                ),
                reserved_service_worker_client: reserved_client,
                document_fetch_context_seed: navigation_loader.commit(final_url)?,
            });
        }
        let fetch_result = navigation_loader
            .fetch_raw_stream_with_network_metadata(request)
            .await?;
        let final_url = fetch_result.response().final_url.clone();
        Ok(NavigationStreamingRawResponse {
            fetch_result,
            reserved_service_worker_client: reserved_client,
            document_fetch_context_seed: navigation_loader.commit(final_url)?,
        })
    }

    pub async fn fetch_navigation_streaming_raw_response_with_storage_async(
        &mut self,
        storage: NavigationResourceStorageHandles,
        initiator_url: Option<&Url>,
        browser_navigation_kind: BrowserNavigationRequestKind,
        infer_referrer_from_initiator: bool,
        request_metadata: Option<moli_fetch::SubresourceRequestMetadata>,
        request_origin: Option<moli_url::WebOrigin>,
        method: &str,
        raw_url: &str,
        body: Option<String>,
        request_headers: moli_fetch::RequestHeaders,
        auth: Option<SubresourceAuthCredentials>,
    ) -> Result<NavigationStreamingRawResponse> {
        let cookie_store = storage.into_cookie_store();
        self.fetch_navigation_streaming_raw_response_async(
            cookie_store,
            initiator_url,
            browser_navigation_kind,
            infer_referrer_from_initiator,
            request_metadata,
            request_origin,
            method,
            raw_url,
            body.map(bytes::Bytes::from),
            request_headers,
            auth,
            FetchCancelHandle::new(),
        )
        .await
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn fetch_navigation_streaming_raw_response_bytes_with_storage_async(
        &mut self,
        storage: NavigationResourceStorageHandles,
        initiator_url: Option<&Url>,
        browser_navigation_kind: BrowserNavigationRequestKind,
        infer_referrer_from_initiator: bool,
        request_metadata: Option<moli_fetch::SubresourceRequestMetadata>,
        request_origin: Option<moli_url::WebOrigin>,
        method: &str,
        raw_url: &str,
        body: Option<bytes::Bytes>,
        request_headers: moli_fetch::RequestHeaders,
        auth: Option<SubresourceAuthCredentials>,
        cancel_handle: FetchCancelHandle,
    ) -> Result<NavigationStreamingRawResponse> {
        let cookie_store = storage.into_cookie_store();
        self.fetch_navigation_streaming_raw_response_async(
            cookie_store,
            initiator_url,
            browser_navigation_kind,
            infer_referrer_from_initiator,
            request_metadata,
            request_origin,
            method,
            raw_url,
            body,
            request_headers,
            auth,
            cancel_handle,
        )
        .await
    }

    pub fn ensure_navigation_response_status(
        &self,
        raw_url: &str,
        status: u16,
        allow_auth_challenge: bool,
    ) -> Result<()> {
        ensure_http_status_success(raw_url, status, allow_auth_challenge)
            .map_err(|error| anyhow!(error.to_string()))
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn build_inline_html_document_page_best_effort_with_inspector_session_restores_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        web_storage: RendererWebStorageHandles,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
        document_url: Url,
        navigation_initiator_url: Option<Url>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<BuiltDocumentPage> {
        let built = self
            .build_html_page_from_response_options_async(
                cookie_store,
                web_storage,
                indexed_db_manager,
                storage_bucket_store,
                DocumentPageLoadOptions {
                    resource_source: CommittedDocumentResourceSource::Synthetic,
                    root_frame_id,
                    main_document_commit,
                    requested_url: document_url.clone(),
                    final_url: document_url,
                    navigation_initiator_url,
                    redirected: false,
                    redirect_count: 0,
                    response_status: 200,
                    response_headers: Vec::new(),
                    response_body,
                    document_start_scripts,
                    runtime_bindings,
                    runtime_inspector_session_restore_snapshots,
                    extra_http_headers,
                    script_execution_disabled,
                    bypass_content_security_policy: false,
                    emulated_media,
                    viewport_surface,
                    network_offline,
                    blocked_url_patterns,
                    fetch_subresource_interception_enabled,
                    fetch_subresource_interception_resource_type,
                },
            )
            .await?;
        if built.pending_download.is_some() {
            return Err(anyhow!(
                "document page creation produced a pending download side-effect for a caller that expects a pure page"
            ));
        }
        Ok(built)
    }

    pub async fn build_inline_html_document_page_with_storage_best_effort_async(
        &mut self,
        storage: NavigationPageStorageHandles,
        document_url: Url,
        navigation_initiator_url: Option<Url>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
    ) -> Result<BuiltDocumentPage> {
        self.build_inline_html_document_page_with_storage_and_inspector_session_restores_best_effort_async(
            storage,
            document_url,
            navigation_initiator_url,
            response_body,
            document_start_scripts,
            runtime_bindings,
            Vec::new(),
            extra_http_headers,
            script_execution_disabled,
            emulated_media,
            viewport_surface,
            network_offline,
            blocked_url_patterns,
            fetch_subresource_interception_enabled,
            fetch_subresource_interception_resource_type,
            None,
            None,
        )
        .await
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn build_inline_html_document_page_with_storage_and_inspector_session_restores_best_effort_async(
        &mut self,
        storage: NavigationPageStorageHandles,
        document_url: Url,
        navigation_initiator_url: Option<Url>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<BuiltDocumentPage> {
        let (cookie_store, web_storage, indexed_db_manager, storage_bucket_store) =
            storage.into_parts();
        self.build_inline_html_document_page_best_effort_with_inspector_session_restores_async(
            cookie_store,
            web_storage,
            indexed_db_manager,
            storage_bucket_store,
            document_url,
            navigation_initiator_url,
            response_body,
            document_start_scripts,
            runtime_bindings,
            runtime_inspector_session_restore_snapshots,
            extra_http_headers,
            script_execution_disabled,
            emulated_media,
            viewport_surface,
            network_offline,
            blocked_url_patterns,
            fetch_subresource_interception_enabled,
            fetch_subresource_interception_resource_type,
            root_frame_id,
            main_document_commit,
        )
        .await
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn build_html_page_from_response_with_inspector_session_restores_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        web_storage: RendererWebStorageHandles,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<BuiltDocumentPage> {
        self.build_html_page_from_response_options_async(
            cookie_store,
            web_storage,
            indexed_db_manager,
            storage_bucket_store,
            DocumentPageLoadOptions {
                resource_source: CommittedDocumentResourceSource::Synthetic,
                root_frame_id,
                main_document_commit,
                requested_url,
                final_url,
                navigation_initiator_url,
                redirected,
                redirect_count,
                response_status,
                response_headers,
                response_body,
                document_start_scripts,
                runtime_bindings,
                runtime_inspector_session_restore_snapshots,
                extra_http_headers,
                script_execution_disabled,
                bypass_content_security_policy,
                emulated_media,
                viewport_surface,
                network_offline,
                blocked_url_patterns,
                fetch_subresource_interception_enabled,
                fetch_subresource_interception_resource_type,
            },
        )
        .await
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn build_html_page_from_response_with_storage_and_inspector_session_restores_async(
        &mut self,
        storage: NavigationPageStorageHandles,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<BuiltDocumentPage> {
        let (cookie_store, web_storage, indexed_db_manager, storage_bucket_store) =
            storage.into_parts();
        self.build_html_page_from_response_with_inspector_session_restores_async(
            cookie_store,
            web_storage,
            indexed_db_manager,
            storage_bucket_store,
            requested_url,
            final_url,
            navigation_initiator_url,
            redirected,
            redirect_count,
            response_status,
            response_headers,
            response_body,
            document_start_scripts,
            runtime_bindings,
            runtime_inspector_session_restore_snapshots,
            extra_http_headers,
            script_execution_disabled,
            bypass_content_security_policy,
            emulated_media,
            viewport_surface,
            network_offline,
            blocked_url_patterns,
            fetch_subresource_interception_enabled,
            fetch_subresource_interception_resource_type,
            root_frame_id,
            main_document_commit,
        )
        .await
    }

    /// Fire-and-defer variant of
    /// [`Self::build_html_page_from_response_with_inspector_session_restores_async`].
    ///
    /// Performs the synchronous loader setup and enqueues the renderer command,
    /// returning a [`PendingBuiltDocumentPage`] without awaiting the renderer
    /// reply. Use this to overlap renderer-side V8/parse work with subsequent
    /// conn-side bookkeeping.
    #[allow(clippy::too_many_arguments)]
    fn start_build_html_page_from_response(
        &mut self,
        page_reservation: moli_renderer_v8::RendererPageReservationToken,
        cookie_store: SharedBrowserCookieStore,
        web_storage: RendererWebStorageHandles,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        top_level_storage_key: Option<moli_storage_key::MoliStorageKey>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<PendingBuiltDocumentPage> {
        let loader = self.ensure_resource_request_client(cookie_store)?;
        loader.set_extra_http_headers(&extra_http_headers);
        loader.set_network_offline(network_offline);
        loader.set_blocked_url_patterns(&blocked_url_patterns);
        let pending = self.js_runtime.start_create_html_page_from_response(
            page_reservation,
            requested_url,
            final_url,
            navigation_initiator_url,
            redirected,
            redirect_count,
            response_status,
            response_headers,
            &loader,
            web_storage,
            response_body,
            top_level_storage_key,
            moli_renderer_v8::RendererTopLevelNavigationDispatch::DelegateToBrowser,
            moli_renderer_v8::RendererDocumentOptions {
                indexed_db_manager,
                storage_bucket_store,
                document_start_scripts,
                runtime_bindings,
                extra_http_headers,
                document_settings: moli_page_types::DocumentSettings {
                    script_execution_disabled,
                    debugger_enabled: self.debugger_enabled,
                    scrollbars_hidden: self.emulated_scrollbars_hidden,
                    bypass_content_security_policy,
                    emulated_media,
                    viewport_surface,
                    document_activity: self.document_activity,
                    ..Default::default()
                },
                network_offline,
                blocked_url_patterns,
                fetch_subresource_interception_enabled,
                fetch_subresource_interception_resource_type,
                runtime_inspector_session_restore_snapshots,
                root_frame_id,
                main_document_commit,
            },
        )?;
        Ok(PendingBuiltDocumentPage { pending })
    }

    #[allow(clippy::too_many_arguments)]
    pub fn start_build_html_page_from_response_with_storage_and_inspector_session_restores(
        &mut self,
        page_reservation: moli_renderer_v8::RendererPageReservationToken,
        storage: NavigationPageStorageHandles,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        response_body: String,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        root_frame_id: Option<String>,
        top_level_storage_key: Option<moli_storage_key::MoliStorageKey>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<PendingBuiltDocumentPage> {
        let (cookie_store, web_storage, indexed_db_manager, storage_bucket_store) =
            storage.into_parts();
        self.start_build_html_page_from_response(
            page_reservation,
            cookie_store,
            web_storage,
            indexed_db_manager,
            storage_bucket_store,
            requested_url,
            final_url,
            navigation_initiator_url,
            redirected,
            redirect_count,
            response_status,
            response_headers,
            response_body,
            document_start_scripts,
            runtime_bindings,
            runtime_inspector_session_restore_snapshots,
            extra_http_headers,
            script_execution_disabled,
            bypass_content_security_policy,
            emulated_media,
            viewport_surface,
            network_offline,
            blocked_url_patterns,
            fetch_subresource_interception_enabled,
            fetch_subresource_interception_resource_type,
            root_frame_id,
            top_level_storage_key,
            main_document_commit,
        )
    }

    #[allow(clippy::too_many_arguments)]
    async fn prepare_streaming_raw_page_from_external_body_async(
        &mut self,
        page_reservation: impl Into<moli_renderer_v8::RendererDocumentPreparationTarget>,
        cookie_store: SharedBrowserCookieStore,
        web_storage: RendererWebStorageHandles,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        raw_body: ExternalRawDocumentBodyStream,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        stage: PageVmInitStage,
        reply_boundary: moli_renderer_v8::RendererReplyBoundary,
        root_frame_id: Option<String>,
        resource_source: CommittedDocumentResourceSource,
        reserved_service_worker_client: Option<RendererReservedServiceWorkerClient>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<PreparedDocumentPage> {
        let loader = self.resource_request_client_for_committed_document(
            cookie_store,
            &final_url,
            resource_source,
        )?;
        loader.set_extra_http_headers(&extra_http_headers);
        loader.set_network_offline(network_offline);
        loader.set_blocked_url_patterns(&blocked_url_patterns);
        let prepared = self
            .js_runtime
            .prepare_streaming_raw_document_from_external_body(
                page_reservation,
                requested_url,
                final_url,
                navigation_initiator_url,
                redirected,
                redirect_count,
                Vec::new(),
                response_status,
                response_headers,
                &loader,
                web_storage,
                raw_body,
                false,
                stage,
                reply_boundary,
                moli_renderer_v8::RendererTopLevelNavigationDispatch::DelegateToBrowser,
                moli_renderer_v8::RendererNavigationReplyPolicy::ReturnWithPendingNavigation,
                reserved_service_worker_client,
                None,
                moli_renderer_v8::RendererDocumentOptions {
                    indexed_db_manager,
                    storage_bucket_store,
                    document_start_scripts,
                    runtime_bindings,
                    extra_http_headers,
                    document_settings: moli_page_types::DocumentSettings {
                        script_execution_disabled,
                        debugger_enabled: self.debugger_enabled,
                        scrollbars_hidden: self.emulated_scrollbars_hidden,
                        bypass_content_security_policy,
                        emulated_media,
                        viewport_surface,
                        document_activity: self.document_activity,
                        ..Default::default()
                    },
                    network_offline,
                    blocked_url_patterns,
                    fetch_subresource_interception_enabled,
                    fetch_subresource_interception_resource_type,
                    runtime_inspector_session_restore_snapshots,
                    root_frame_id,
                    main_document_commit,
                },
            )
            .await
            .context("failed to prepare streaming raw page")?;
        Ok(PreparedDocumentPage { prepared })
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn prepare_streaming_raw_page_from_external_body_with_storage_and_inspector_session_restores_async(
        &mut self,
        page_reservation: impl Into<moli_renderer_v8::RendererDocumentPreparationTarget>,
        storage: NavigationPageStorageHandles,
        requested_url: Url,
        final_url: Url,
        navigation_initiator_url: Option<Url>,
        redirected: bool,
        redirect_count: usize,
        response_status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
        raw_body: ExternalRawDocumentBodyStream,
        document_start_scripts: Vec<DocumentStartScript>,
        runtime_bindings: Vec<crate::page::RuntimeBindingRegistration>,
        runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,
        extra_http_headers: moli_fetch::RequestHeaders,
        script_execution_disabled: bool,
        bypass_content_security_policy: bool,
        emulated_media: EmulatedMediaOverrides,
        viewport_surface: Option<ViewportSurface>,
        network_offline: bool,
        blocked_url_patterns: Vec<String>,
        fetch_subresource_interception_enabled: bool,
        fetch_subresource_interception_resource_type: Option<SubresourceResourceType>,
        stage: PageVmInitStage,
        reply_boundary: moli_renderer_v8::RendererReplyBoundary,
        root_frame_id: Option<String>,
        resource_source: CommittedDocumentResourceSource,
        reserved_service_worker_client: Option<RendererReservedServiceWorkerClient>,
        main_document_commit: Option<RendererMainDocumentCommit>,
    ) -> Result<PreparedDocumentPage> {
        let (cookie_store, web_storage, indexed_db_manager, storage_bucket_store) =
            storage.into_parts();
        self.prepare_streaming_raw_page_from_external_body_async(
            page_reservation,
            cookie_store,
            web_storage,
            indexed_db_manager,
            storage_bucket_store,
            requested_url,
            final_url,
            navigation_initiator_url,
            redirected,
            redirect_count,
            response_status,
            response_headers,
            raw_body,
            document_start_scripts,
            runtime_bindings,
            runtime_inspector_session_restore_snapshots,
            extra_http_headers,
            script_execution_disabled,
            bypass_content_security_policy,
            emulated_media,
            viewport_surface,
            network_offline,
            blocked_url_patterns,
            fetch_subresource_interception_enabled,
            fetch_subresource_interception_resource_type,
            stage,
            reply_boundary,
            root_frame_id,
            resource_source,
            reserved_service_worker_client,
            main_document_commit,
        )
        .await
    }

    async fn build_html_page_from_response_options_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        web_storage: RendererWebStorageHandles,
        indexed_db_manager: Option<WeakIndexedDbManager>,
        storage_bucket_store: Option<SharedStorageBucketStore>,
        options: DocumentPageLoadOptions,
    ) -> Result<BuiltDocumentPage> {
        let loader = self.resource_request_client_for_committed_document(
            cookie_store,
            &options.final_url,
            options.resource_source.clone(),
        )?;
        loader.set_extra_http_headers(&options.extra_http_headers);
        loader.set_network_offline(options.network_offline);
        loader.set_blocked_url_patterns(&options.blocked_url_patterns);
        let (
            handle,
            page_state,
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        ) = self
            .js_runtime
            .create_html_page_from_response(
                options.requested_url.clone(),
                options.final_url,
                options.navigation_initiator_url,
                options.redirected,
                options.redirect_count,
                options.response_status,
                options.response_headers,
                &loader,
                web_storage,
                options.response_body,
                moli_renderer_v8::RendererDocumentOptions {
                    indexed_db_manager,
                    storage_bucket_store,
                    document_start_scripts: options.document_start_scripts,
                    runtime_bindings: options.runtime_bindings,
                    extra_http_headers: options.extra_http_headers,
                    document_settings: moli_page_types::DocumentSettings {
                        script_execution_disabled: options.script_execution_disabled,
                        debugger_enabled: self.debugger_enabled,
                        scrollbars_hidden: self.emulated_scrollbars_hidden,
                        bypass_content_security_policy: options.bypass_content_security_policy,
                        emulated_media: options.emulated_media,
                        viewport_surface: options.viewport_surface,
                        document_activity: self.document_activity,
                        ..Default::default()
                    },
                    network_offline: options.network_offline,
                    blocked_url_patterns: options.blocked_url_patterns,
                    fetch_subresource_interception_enabled: options
                        .fetch_subresource_interception_enabled,
                    fetch_subresource_interception_resource_type: options
                        .fetch_subresource_interception_resource_type,
                    runtime_inspector_session_restore_snapshots: options
                        .runtime_inspector_session_restore_snapshots,
                    root_frame_id: options.root_frame_id,
                    main_document_commit: options.main_document_commit,
                },
            )
            .await
            .context("failed to build html page")?;
        let page = Page::from_attached_handle(handle, page_state);
        Ok(BuiltDocumentPage {
            page,
            page_creation_diagnostics,
            page_creation_artifacts,
            pending_download,
        })
    }

    fn start_page_child_frame_lifecycle_work_best_effort(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        page: &Page,
        timeout: std::time::Duration,
    ) -> Result<PendingPageCommand> {
        let loader = self.ensure_resource_request_client_clone(cookie_store)?;
        page.start_complete_child_frame_lifecycle_work_best_effort(&loader, timeout)
    }

    pub fn start_page_child_frame_lifecycle_work_with_storage_best_effort(
        &mut self,
        storage: NavigationResourceStorageHandles,
        page: &Page,
        timeout: std::time::Duration,
    ) -> Result<PendingPageCommand> {
        self.start_page_child_frame_lifecycle_work_best_effort(
            storage.into_cookie_store(),
            page,
            timeout,
        )
    }

    pub fn complete_page_child_frame_lifecycle_work_best_effort(
        &mut self,
        page: &mut Page,
        completion: CompletedPageCommand,
    ) -> Result<(bool, moli_renderer_v8::RendererCommandTurnOutput)> {
        page.finish_complete_child_frame_lifecycle_work_best_effort_command_turn(completion)
    }

    pub async fn reset_resource_runtime_async(&mut self, loaded_page: Option<&mut Page>) {
        self.resource_runtime = None;
        self.browser_context_access.reap_retired_resource_runtimes();
        if let Some(page) = loaded_page {
            let _ = page.retire_document_resource_authorities_async().await;
            self.browser_context_access.reap_retired_resource_runtimes();
        }
    }

    pub fn reset_resource_runtime_without_loaded_page(&mut self) {
        self.resource_runtime = None;
        self.browser_context_access.reap_retired_resource_runtimes();
    }

    async fn rebuild_resource_runtime_for_page_async(
        &mut self,
        cookie_store: SharedBrowserCookieStore,
        loaded_page: Option<&mut Page>,
    ) -> Result<()> {
        let resource_runtime = self
            .rebuild_resource_request_client(cookie_store)?
            .browser_resource_runtime();
        if let Some(page) = loaded_page {
            let replacement = page
                .replace_browser_resource_runtime_async(&resource_runtime)
                .await;
            // The Page drops its old document authority at the completion
            // boundary. Reap after either terminal outcome; a still-live old
            // authority simply keeps its owner registered.
            self.browser_context_access.reap_retired_resource_runtimes();
            replacement?;
        }
        Ok(())
    }

    pub async fn rebuild_resource_runtime_for_page_with_storage_async(
        &mut self,
        storage: NavigationResourceStorageHandles,
        loaded_page: Option<&mut Page>,
    ) -> Result<()> {
        self.rebuild_resource_runtime_for_page_async(storage.into_cookie_store(), loaded_page)
            .await
    }

    pub fn set_tls_verify_host(&mut self, enabled: bool) {
        self.fetch_config.set_tls_verify_host(enabled);
    }

    pub fn tls_verify_host(&self) -> bool {
        self.fetch_config.tls_verify_host()
    }

    pub fn set_user_agent_override(&mut self, user_agent: impl Into<String>) {
        self.fetch_config.set_user_agent(user_agent);
    }

    pub fn set_browser_identity_override(
        &mut self,
        browser_identity: moli_browser_profile::BrowserIdentityProfile,
    ) {
        self.fetch_config.set_browser_identity(browser_identity);
    }

    pub fn set_http_proxy_override(&mut self, proxy: Option<String>) {
        self.fetch_config.set_http_proxy(proxy);
    }

    pub fn set_http_no_proxy_override(&mut self, no_proxy: Option<String>) {
        self.fetch_config.set_http_no_proxy(no_proxy);
    }
}

#[cfg(test)]
mod tests {
    use super::{CommittedDocumentResourceSource, NavigationEngine, NavigationRuntimeConfig};
    use crate::{
        LayoutPolicy, OptionalResourceFetchMask,
        network::ResourceRequestClient,
        runtime::{Browser, BrowserConfig, RendererBrowserContextRuntime},
    };
    use moli_cookie_jar::new_shared_browser_cookie_store;
    use moli_fetch::FetchConfig;
    use url::Url;

    static_assertions::assert_not_impl_any!(Browser: Send, Sync);
    static_assertions::assert_not_impl_any!(NavigationEngine: Send, Sync);
    static_assertions::assert_not_impl_any!(
        moli_renderer_v8::RendererBrowserContextRuntimeOwnerAccess: Send,
        Sync
    );

    #[test]
    fn navigation_engine_can_share_browser_context_runtime() {
        let browser_context_owner = RendererBrowserContextRuntime::new();
        let browser_context_runtime = browser_context_owner.handle();
        let engine = NavigationEngine::new_with_fetch_config_and_browser_context_access(
            FetchConfig::default(),
            browser_context_owner.owner_access(),
            OptionalResourceFetchMask::NONE,
            true,
        )
        .expect("browser context owner should remain live");

        assert!(
            engine
                .browser_context_runtime()
                .shares_state_with(&browser_context_runtime)
        );
    }

    #[test]
    fn navigation_engine_default_runtime_isolated() {
        let left = NavigationEngine::new();
        let right = NavigationEngine::new();

        assert!(
            !left
                .browser_context_runtime()
                .shares_state_with(&right.browser_context_runtime())
        );
    }

    #[test]
    fn navigation_engine_preserves_the_complete_optional_resource_mask() {
        let mask = OptionalResourceFetchMask::FONT
            | OptionalResourceFetchMask::VIDEO
            | OptionalResourceFetchMask::TEXT_TRACK;
        let engine = NavigationEngine::new_with_fetch_config_and_resource_loading(
            FetchConfig::default(),
            mask,
            true,
        );

        assert_eq!(engine.optional_resource_fetch_mask(), mask);
        assert!(!engine.image_fetch_enabled());
    }

    #[test]
    fn navigation_runtime_config_preserves_mock_layout_policy_at_renderer_owner() {
        let config = NavigationRuntimeConfig::new(
            FetchConfig::default(),
            OptionalResourceFetchMask::FONT,
            false,
            LayoutPolicy::Mock,
        );
        let engine = NavigationEngine::new_with_runtime_config(config);

        assert_eq!(engine.layout_policy(), LayoutPolicy::Mock);
        assert_eq!(engine.runtime_config().layout_policy(), LayoutPolicy::Mock);
        assert_eq!(
            engine.js_runtime.renderer_owner_handle().layout_policy(),
            LayoutPolicy::Mock
        );
        assert_eq!(
            engine.optional_resource_fetch_mask(),
            OptionalResourceFetchMask::FONT
        );
        assert!(!engine.subframe_loading_enabled());
    }

    #[test]
    fn shared_renderer_owner_rejects_a_conflicting_layout_policy() {
        let source = NavigationEngine::new_with_runtime_config(NavigationRuntimeConfig::new(
            FetchConfig::default(),
            OptionalResourceFetchMask::NONE,
            true,
            LayoutPolicy::Mock,
        ));

        let error = NavigationEngine::new_with_runtime_config_and_shared_renderer_owner(
            NavigationRuntimeConfig::new(
                FetchConfig::default(),
                OptionalResourceFetchMask::NONE,
                true,
                LayoutPolicy::OnDemand,
            ),
            &source,
        )
        .expect_err("a renderer owner must not mix browser layout policies");

        assert!(error.to_string().contains("layout policy is configured"));
        assert_eq!(source.layout_policy(), LayoutPolicy::Mock);
    }

    #[test]
    fn browser_configures_layout_policy_before_any_page_creation() {
        let browser = Browser::new(BrowserConfig::default().with_layout_policy(LayoutPolicy::Mock))
            .expect("browser should initialize with mock layout");

        assert_eq!(
            browser.js_runtime.renderer_owner_handle().layout_policy(),
            LayoutPolicy::Mock
        );
    }

    #[test]
    fn hidden_scrollbars_follow_browser_and_shared_navigation_configuration() {
        let browser_config = BrowserConfig::default()
            .with_layout_policy(LayoutPolicy::OnDemand)
            .with_scrollbars_hidden(true);
        let browser = Browser::new(browser_config.clone()).expect("hidden scrollbar browser");
        assert!(
            browser
                .js_runtime
                .renderer_owner_handle()
                .scrollbars_hidden()
        );

        let source = NavigationEngine::new_with_runtime_config((&browser_config).into());
        assert!(source.runtime_config().scrollbars_hidden());
        assert!(
            source
                .js_runtime
                .renderer_owner_handle()
                .scrollbars_hidden()
        );
        let shared = NavigationEngine::new_with_fetch_config_and_shared_renderer_owner(
            FetchConfig::default(),
            &source,
            OptionalResourceFetchMask::NONE,
            true,
        )
        .expect("matching owner configuration");
        assert!(shared.runtime_config().scrollbars_hidden());
        assert!(shared.shares_renderer_owner_with(&source));

        let conflicting = source.runtime_config().with_scrollbars_hidden(false);
        assert!(
            NavigationEngine::new_with_runtime_config_and_shared_renderer_owner(
                conflicting,
                &source
            )
            .is_err()
        );
        assert!(
            source
                .js_runtime
                .renderer_owner_handle()
                .scrollbars_hidden()
        );
    }

    #[test]
    fn hidden_scrollbars_require_real_layout_for_rust_callers() {
        assert!(Browser::new(BrowserConfig::default().with_scrollbars_hidden(true)).is_err());
    }

    #[test]
    fn adopting_shared_backend_does_not_share_page_network_policy() {
        let left = NavigationEngine::new();
        let right = NavigationEngine::new_with_fetch_config_and_shared_renderer_owner(
            FetchConfig::default(),
            &left,
            OptionalResourceFetchMask::NONE,
            true,
        )
        .expect("standalone shared owner should remain live");
        let left_loader = left.resource_request_client().expect("left request client");
        let right_loader = right
            .resource_request_client()
            .expect("right request client");

        assert!(left_loader.shares_resource_runtime_with(&right_loader));
        assert!(!left_loader.shares_page_network_policy_with(&right_loader));
        assert!(!left_loader.shares_memory_cache_partition_with(&right_loader));

        left_loader.set_network_offline(true);
        assert!(
            !right_loader
                .page_network_policy()
                .snapshot()
                .network_offline()
        );
    }

    #[test]
    fn navigation_engine_clone_keeps_the_standalone_owner_live_after_source_drop() {
        let engine = NavigationEngine::new();
        let expected_runtime_id = engine
            .resource_request_client()
            .expect("standalone engine should start with a resource runtime")
            .resource_runtime_diagnostics()
            .runtime_id;
        let clone = engine.clone();

        drop(engine);

        assert_eq!(
            clone
                .resource_request_client()
                .expect("clone must retain the shared standalone lifetime owner")
                .resource_runtime_diagnostics()
                .runtime_id,
            expected_runtime_id
        );
    }

    #[test]
    fn stale_navigation_engine_cache_converges_on_context_current_resource_runtime() {
        let mut replacing_engine = NavigationEngine::new();
        let mut stale_engine = replacing_engine.clone();
        let old_runtime = stale_engine
            .resource_request_client()
            .expect("stale wrapper should cache the initial runtime");
        let replacement_cookie_store = new_shared_browser_cookie_store();

        let replacement = replacing_engine
            .rebuild_resource_request_client(replacement_cookie_store.clone())
            .expect("peer wrapper should replace the context runtime");
        assert!(
            !old_runtime.shares_resource_runtime_with(&replacement),
            "the peer rebuild must install a new runtime"
        );

        let converged = stale_engine
            .ensure_resource_request_client(replacement_cookie_store)
            .expect("stale wrapper should consult the context binding");
        assert!(
            converged.shares_resource_runtime_with(&replacement),
            "an ambient engine cache must not revive the retired runtime"
        );
    }

    #[test]
    fn explicit_config_rebuild_replaces_runtime_with_unchanged_cookie_store() {
        let mut engine = NavigationEngine::new();
        let old_client = engine
            .resource_request_client()
            .expect("engine should start with a runtime");
        let cookie_store = old_client.browser_resource_runtime().cookie_store();
        engine.set_user_agent_override("Moli/Rebuilt-Config");

        let replacement = engine
            .rebuild_resource_request_client(cookie_store)
            .expect("config rebuild should replace the runtime");

        assert!(!old_client.shares_resource_runtime_with(&replacement));
        assert_eq!(
            replacement.browser_identity().user_agent(),
            "Moli/Rebuilt-Config"
        );
    }

    #[test]
    fn engine_with_different_fetch_config_replaces_context_current_runtime() {
        let base_engine = NavigationEngine::new();
        let mut override_engine = base_engine.clone();
        let mut default_engine = base_engine.clone();
        let cookie_store = base_engine
            .resource_request_client()
            .expect("base engine should start with a runtime")
            .browser_resource_runtime()
            .cookie_store();
        override_engine.set_user_agent_override("Moli/Target-Override");
        let override_client = override_engine
            .rebuild_resource_request_client(cookie_store.clone())
            .expect("override target should install its config");

        let restored = default_engine
            .ensure_resource_request_client(cookie_store)
            .expect("default target should reject another target's current backend");

        assert!(!restored.shares_resource_runtime_with(&override_client));
        assert_eq!(
            restored.browser_identity().user_agent(),
            FetchConfig::DEFAULT_USER_AGENT
        );
    }

    #[test]
    fn synthetic_document_source_uses_the_engine_runtime_and_page_policy() {
        let mut engine = NavigationEngine::new();
        let cookie_store = new_shared_browser_cookie_store();
        let final_url = Url::parse("about:blank").expect("synthetic Document URL");

        let client = engine
            .resource_request_client_for_committed_document(
                cookie_store,
                &final_url,
                CommittedDocumentResourceSource::Synthetic,
            )
            .expect("synthetic Document client");
        let engine_client = engine
            .resource_request_client()
            .expect("engine resource request client");

        assert!(client.shares_resource_runtime_with(&engine_client));
        assert!(client.shares_page_network_policy_with(&engine_client));
    }

    #[tokio::test(flavor = "current_thread")]
    async fn navigation_document_source_rejects_a_foreign_browser_runtime() {
        let cookie_store = new_shared_browser_cookie_store();
        let start_url = Url::parse("https://example.test/start").expect("navigation start URL");
        let final_url = Url::parse("https://example.test/final").expect("navigation final URL");
        let foreign_client_owner = ResourceRequestClient::new_with_cookie_store(
            &FetchConfig::default(),
            cookie_store.clone(),
        )
        .expect("foreign request client");
        let foreign_client = foreign_client_owner.handle();
        let navigation = moli_renderer_v8::network::navigation::NavigationResourceLoader::new(
            foreign_client,
            start_url,
            moli_renderer_v8::network::RendererResourceTaskRunner::from_current_tokio()
                .expect("test must own a Tokio runtime"),
        );
        navigation
            .note_service_worker_response_ready()
            .expect("navigation response ready");
        let seed = navigation
            .commit(final_url.clone())
            .expect("navigation seed");
        let mut engine = NavigationEngine::new();

        let error = engine
            .resource_request_client_for_committed_document(
                cookie_store,
                &final_url,
                CommittedDocumentResourceSource::Navigation(Box::new(seed)),
            )
            .expect_err("foreign browser runtime must not commit");

        assert!(
            error
                .to_string()
                .contains("does not belong to the NavigationEngine browser resource runtime")
        );
    }

    #[tokio::test(flavor = "current_thread")]
    async fn navigation_commit_keeps_its_registered_runtime_after_peer_target_replacement() {
        let mut target_a = NavigationEngine::new();
        let mut target_b = target_a.clone();
        let cookie_store = target_a
            .resource_request_client()
            .expect("target A initial request client")
            .browser_resource_runtime()
            .cookie_store();
        target_a.set_user_agent_override("Moli/Target-A");
        let target_a_client = target_a
            .rebuild_resource_request_client(cookie_store.clone())
            .expect("target A runtime");
        let start_url = Url::parse("https://example.test/start").expect("navigation start URL");
        let final_url = Url::parse("https://example.test/final").expect("navigation final URL");
        let navigation = moli_renderer_v8::network::navigation::NavigationResourceLoader::new(
            target_a_client.clone(),
            start_url,
            moli_renderer_v8::network::RendererResourceTaskRunner::from_current_tokio()
                .expect("test must own a Tokio runtime"),
        );
        navigation
            .note_service_worker_response_ready()
            .expect("target A navigation response ready");
        let seed = navigation
            .commit(final_url.clone())
            .expect("target A navigation seed");

        target_b.set_user_agent_override("Moli/Target-B");
        let target_b_client = target_b
            .rebuild_resource_request_client(cookie_store.clone())
            .expect("target B must replace the ambient BrowserContext runtime");
        assert!(!target_a_client.shares_resource_runtime_with(&target_b_client));

        let committed_client = target_a
            .resource_request_client_for_committed_document(
                cookie_store,
                &final_url,
                CommittedDocumentResourceSource::Navigation(Box::new(seed)),
            )
            .expect("target A must commit with the runtime that fetched its response");

        assert!(committed_client.shares_resource_runtime_with(&target_a_client));
        assert_eq!(
            committed_client.browser_identity().user_agent(),
            "Moli/Target-A"
        );
    }
}