Skip to content

armgit / moli

Public Imported from GitHub
0

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

68.6 KB
Raw Blame
use std::sync::Arc;

use anyhow::Result;
use url::Url;

use super::dom_protocol_support::DocumentNodeObjectSnapshot;
use super::protocol_support::{
    ChildFrameTreeSnapshot, ScriptExecutionReport, ScriptObservableOutputItem,
    SubresourceNetworkRecord, WebSocketLifecycleEvent, WebSocketNetworkEvent,
};
use super::{CompletedPageCommand, Page, PendingPageCommand};
use crate::renderer::{
    RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
    RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
    RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
    RendererDocumentChildNodeSnapshotEvents, RendererDocumentFrontendNodeIdsResolution,
    RendererDocumentHitTestResult, RendererDocumentNodeAttributesResolution,
    RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
    RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,
    RendererDocumentNodeTextResolution, RendererDocumentQuerySelectorResolution,
    RendererDocumentQuerySelectorWithChildNodeSnapshotEvents, RendererDomAttributeMutation,
    RendererDomAttributeMutationOutcome, RendererDomBidiNodeBindingResolution,
    RendererDomBidiNodeSharedIdResolution, RendererDomEdit, RendererDomEditOutcome,
    RendererDomFocusOutcome, RendererDomFrontendNodeBindingResolution, RendererDomNodeReference,
    RendererDomNodeStackTraceResolution, RendererDomSearchRegistration,
    RendererDomSearchResultsResolution, RendererDomSnapshotCaptureOptions,
    RendererDomSnapshotCapturePayload, RendererLayoutMetrics, RendererPageCommand,
    RendererPageDumpOptions, RendererPageReply, RendererPageState, RendererRuntimeRemoteObject,
    RendererStyleSheetInventoryUpdate, RendererStyleSheetPayload,
};

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

#[derive(Debug)]
pub struct PageObservableOutputUpdate<'a> {
    observable_output_items: &'a [ScriptObservableOutputItem],
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TestingOutcome {
    pub(super) observations: usize,
    pub(super) harness_failures: Vec<String>,
    pub(super) pending_async: usize,
    pub(super) script_failures: Vec<String>,
    pub(super) lifecycle_errors: Vec<String>,
}

pub enum DocumentNodeRuntimeObjectResolution {
    Found(RendererRuntimeRemoteObject),
    MissingContext,
    MissingNode,
}

pub enum DocumentNodeClientRectResolution {
    Found(super::ClientRect),
    FoundNonElement(super::ClientRect),
    NotElement,
}

// ---------------------------------------------------------------------------
// PageObservableOutputUpdate / TestingOutcome impls
// ---------------------------------------------------------------------------

impl<'a> PageObservableOutputUpdate<'a> {
    pub fn append(observable_output_items: &'a [ScriptObservableOutputItem]) -> Self {
        Self {
            observable_output_items,
        }
    }

    pub fn observable_output_items(&self) -> &'a [ScriptObservableOutputItem] {
        self.observable_output_items
    }
}

impl TestingOutcome {
    pub fn observations(&self) -> usize {
        self.observations
    }

    pub fn harness_failures(&self) -> &[String] {
        &self.harness_failures
    }

    pub fn pending_async(&self) -> usize {
        self.pending_async
    }

    pub fn script_failures(&self) -> &[String] {
        &self.script_failures
    }

    pub fn lifecycle_errors(&self) -> &[String] {
        &self.lifecycle_errors
    }

    pub fn passed(&self) -> bool {
        self.observations > 0
            && self.pending_async == 0
            && self.harness_failures.is_empty()
            && self.script_failures.is_empty()
            && self.lifecycle_errors.is_empty()
    }
}

// ---------------------------------------------------------------------------
// Page state accessor methods
// ---------------------------------------------------------------------------

impl Page {
    pub fn requested_url(&self) -> &Url {
        self.page_state.requested_url()
    }

    pub fn page_id(&self) -> u64 {
        self.handle.page_id()
    }

    pub fn renderer_page_id(&self) -> moli_renderer_v8::PageId {
        self.handle.renderer_page_id()
    }

    pub fn renderer_owner_local_host_id(&self) -> moli_renderer_v8::RendererOwnerLocalHostId {
        self.handle.owner_local_host_id()
    }

    pub fn document_isolate_identity_for_diagnostics(&self) -> usize {
        self.page_state.state().document_isolate_identity
    }

    pub fn service_worker_client_id(&self) -> u64 {
        self.page_state.state().service_worker_client_id
    }

    pub fn dedicated_worker_running_worker_isolate_count_for_diagnostics(&self) -> usize {
        self.page_state
            .state()
            .dedicated_worker_running_worker_isolate_count
    }

    pub fn navigation_initiator_url(&self) -> Option<&Url> {
        self.page_state.navigation_initiator_url()
    }

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

    pub fn navigation_redirect_count(&self) -> usize {
        self.page_state.navigation_redirect_count()
    }

    pub fn navigation_redirect_chain(&self) -> &[super::NavigationRedirect] {
        self.page_state.navigation_redirect_chain()
    }

    pub fn final_url(&self) -> &Url {
        self.page_state.final_url()
    }

    pub fn idle_override(&self) -> Option<super::EmulatedIdleOverride> {
        self.idle_override
    }

    pub fn status(&self) -> u16 {
        self.page_state.status()
    }

    pub fn headers(&self) -> &[(String, Vec<u8>)] {
        self.page_state.headers()
    }

    pub fn script_execution(&self) -> &ScriptExecutionReport {
        self.page_state.script_execution()
    }

    /// Refreshes the complete script report on the renderer owner lane.
    ///
    /// Protocol command completion keeps observable/network state current but
    /// intentionally marks an enabled own-globals projection dirty. In a
    /// `test-support` build, call this before reading `fresh_globals()` when a
    /// current diagnostic snapshot is required. Normal builds do not capture
    /// a realm baseline, so this leaves globals `Uncaptured`.
    pub async fn refresh_script_execution_report_async(&mut self) -> Result<()> {
        self.dispatch_unit_page_command_async(
            RendererPageCommand::RefreshFullPageState,
            "refresh script execution report",
        )
        .await
    }

    pub fn subresource_network_records(&self) -> &[SubresourceNetworkRecord] {
        self.page_state
            .script_execution()
            .subresource_network_records()
    }

    pub fn websocket_network_events(&self) -> &[WebSocketNetworkEvent] {
        self.page_state
            .script_execution()
            .websocket_network_events()
    }

    pub fn websocket_lifecycle_events(&self) -> &[WebSocketLifecycleEvent] {
        self.page_state
            .script_execution()
            .websocket_lifecycle_events()
    }

    pub fn network_output_counts(&self) -> (usize, usize) {
        (
            self.subresource_network_records().len(),
            self.websocket_network_events().len(),
        )
    }

    pub fn take_observable_output_update(&mut self) -> PageObservableOutputUpdate<'_> {
        let observable_output_items = self.page_state.script_execution().observable_output_items();
        PageObservableOutputUpdate::append(observable_output_items)
    }

    pub(super) fn replace_page_state(&mut self, page_state: Arc<RendererPageState>) {
        self.page_state.replace(page_state);
    }

    pub fn start_set_inline_style_sheet_text_for_style_sheet_id(
        &self,
        style_sheet_id: &str,
        text: &str,
    ) -> Result<PendingPageCommand> {
        self.start_set_inline_style_sheet_text_for_style_sheet_id_and_inspector_session(
            None,
            style_sheet_id,
            text,
        )
    }

    pub fn start_set_inline_style_sheet_text_for_style_sheet_id_and_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        style_sheet_id: &str,
        text: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::SetInlineStyleSheetTextForStyleSheetId {
                inspector_session_id,
                style_sheet_id: style_sheet_id.to_owned(),
                text: text.to_owned(),
            },
        )
    }

    pub fn finish_set_inline_style_sheet_text(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<bool> {
        Self::decode_bool_page_reply(
            self.finish_page_command(completion),
            "set inline stylesheet text page command",
        )
    }

    pub fn start_style_sheet_payload_for_style_sheet_id(
        &self,
        style_sheet_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_style_sheet_payload_for_style_sheet_id_and_inspector_session(
            None,
            style_sheet_id,
        )
    }

    pub fn start_style_sheet_payload_for_style_sheet_id_and_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        style_sheet_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::StyleSheetPayloadForStyleSheetId {
            inspector_session_id,
            style_sheet_id: style_sheet_id.to_owned(),
        })
    }

    pub fn finish_style_sheet_payload(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererStyleSheetPayload>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "stylesheet payload page command",
            "an optional stylesheet payload",
            RendererPageReply::OptionalStyleSheetPayload(payload) => Ok(payload),
        )
    }

    pub fn start_style_sheet_inventory_for_document(&self) -> Result<PendingPageCommand> {
        self.start_style_sheet_inventory_for_document_and_inspector_session(None)
    }

    pub fn start_style_sheet_inventory_for_document_and_inspector_session(
        &self,
        inspector_session_id: Option<String>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::StyleSheetInventoryForDocument {
            inspector_session_id,
        })
    }

    pub fn finish_style_sheet_inventory_for_document(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererStyleSheetInventoryUpdate> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "stylesheet inventory page command",
            "stylesheet inventory update",
            RendererPageReply::StyleSheetInventory(update) => Ok(update),
        )
    }

    pub fn start_reset_css_agent_session(
        &self,
        inspector_session_id: Option<String>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ResetCssAgentSession {
            inspector_session_id,
        })
    }

    pub fn finish_reset_css_agent_session(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "CSS agent reset page command",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub fn start_computed_style_properties(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ComputedStyleProperties { reference })
    }

    pub fn start_computed_style_properties_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_computed_style_properties(RendererDomNodeReference::BackendNodeId(
            backend_node_id,
        ))
    }

    pub fn start_computed_style_properties_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::computed_style_properties_for_object_id(
                inspector_session_id,
                object_id.to_owned(),
            ),
        )
    }

    pub fn finish_computed_style_properties(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<Vec<(String, String)>>> {
        expect_page_reply!(
            self.finish_page_command(completion),
            "computed style page command",
            "computed style properties",
            RendererPageReply::ComputedStyleProperties(properties) => Ok(properties),
        )
    }

    pub fn document_title(&self) -> String {
        self.page_state.document_title().to_owned()
    }

    pub fn start_node_has_geometry_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::node_has_geometry_for_object_id(
            inspector_session_id,
            object_id.to_owned(),
        ))
    }

    pub fn start_scroll_node_into_view_if_needed_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
        rect: Option<moli_page_types::DomScrollIntoViewRect>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::scroll_object_node_into_view_if_needed(
            inspector_session_id,
            object_id.to_owned(),
            rect,
        ))
    }

    pub fn start_scroll_node_into_view_if_needed(
        &self,
        reference: RendererDomNodeReference,
        rect: Option<moli_page_types::DomScrollIntoViewRect>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ScrollNodeIntoViewIfNeeded { reference, rect })
    }

    pub fn start_scroll_backend_node_into_view_if_needed(
        &self,
        backend_node_id: u32,
        rect: Option<moli_page_types::DomScrollIntoViewRect>,
    ) -> Result<PendingPageCommand> {
        self.start_scroll_node_into_view_if_needed(
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            rect,
        )
    }

    pub fn finish_node_has_geometry_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<bool>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "node has geometry object id page command",
            "an optional bool reply",
            RendererPageReply::OptionalBool(has_geometry) => Ok(has_geometry),
        )
    }

    pub fn start_node_has_geometry_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::NodeHasGeometryForBackendNodeId {
            backend_node_id,
        })
    }

    pub fn finish_node_has_geometry_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<bool>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "node has geometry backend node id page command",
            "an optional bool reply",
            RendererPageReply::OptionalBool(has_geometry) => Ok(has_geometry),
        )
    }

    pub fn finish_scroll_node_into_view_if_needed(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<super::RendererScrollIntoViewResult> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "scroll document node into view page command",
            "a scroll-into-view reply",
            RendererPageReply::ScrollIntoViewResult(result) => Ok(result),
        )
    }

    pub fn start_client_rect_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::client_rect_for_object_id(
            inspector_session_id,
            object_id.to_owned(),
        ))
    }

    pub fn finish_client_rect_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<DocumentNodeClientRectResolution>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "client rect object id page command",
            "an optional document node client rect reply",
            RendererPageReply::OptionalDocumentNodeClientRect(rect) => Ok(rect.map(|rect| match rect {
                RendererDocumentNodeClientRect::Found(rect) => {
                    DocumentNodeClientRectResolution::Found(rect.into())
                }
                RendererDocumentNodeClientRect::FoundNonElement(rect) => {
                    DocumentNodeClientRectResolution::FoundNonElement(rect.into())
                }
                RendererDocumentNodeClientRect::NotElement => {
                    DocumentNodeClientRectResolution::NotElement
                }
            })),
        )
    }

    pub fn start_client_rect_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ClientRectForBackendNodeId { backend_node_id })
    }

    pub fn finish_client_rect_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<DocumentNodeClientRectResolution>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "client rect backend node id page command",
            "an optional document node client rect reply",
            RendererPageReply::OptionalDocumentNodeClientRect(rect) => Ok(rect.map(|rect| match rect {
                RendererDocumentNodeClientRect::Found(rect) => {
                    DocumentNodeClientRectResolution::Found(rect.into())
                }
                RendererDocumentNodeClientRect::FoundNonElement(rect) => {
                    DocumentNodeClientRectResolution::FoundNonElement(rect.into())
                }
                RendererDocumentNodeClientRect::NotElement => {
                    DocumentNodeClientRectResolution::NotElement
                }
            })),
        )
    }

    pub fn start_document_geometry_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::document_geometry_for_object_id(
            inspector_session_id,
            object_id.to_owned(),
        ))
    }

    pub fn finish_document_geometry_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentNodeGeometry>> {
        self.finish_document_geometry(completion, "document geometry object id page command")
    }

    pub fn start_document_geometry_for_node(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentGeometryForNode { reference })
    }

    pub fn start_document_geometry_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_document_geometry_for_node(RendererDomNodeReference::BackendNodeId(
            backend_node_id,
        ))
    }

    pub fn finish_document_geometry_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentNodeGeometry>> {
        self.finish_document_geometry_for_node(completion)
    }

    pub fn finish_document_geometry_for_node(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentNodeGeometry>> {
        self.finish_document_geometry(completion, "document geometry node page command")
    }

    fn finish_document_geometry(
        &mut self,
        completion: CompletedPageCommand,
        operation: &str,
    ) -> Result<Option<RendererDocumentNodeGeometry>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            operation,
            "an optional document node geometry reply",
            RendererPageReply::OptionalDocumentNodeGeometry(geometry) => Ok(geometry),
        )
    }

    pub fn start_document_hit_test(
        &self,
        inspector_session_id: Option<String>,
        x: f64,
        y: f64,
        include_user_agent_shadow_dom: bool,
        ignore_pointer_events_none: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentHitTest {
            inspector_session_id,
            x,
            y,
            include_user_agent_shadow_dom,
            ignore_pointer_events_none,
        })
    }

    pub fn finish_document_hit_test(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentHitTestResult>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document hit-test page command",
            "an optional document hit-test reply",
            RendererPageReply::OptionalDocumentHitTest(hit) => Ok(hit),
        )
    }

    pub fn start_remove_document_node(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::RemoveDocumentNode { reference })
    }

    pub fn start_remove_document_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_remove_document_node(RendererDomNodeReference::BackendNodeId(backend_node_id))
    }

    pub fn finish_remove_document_node(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<bool> {
        self.finish_remove_document_node_reference(completion)
            .map(|removed| removed.unwrap_or(false))
    }

    pub fn finish_remove_document_node_reference(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<bool>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "remove document node page command",
            "an optional bool reply",
            RendererPageReply::OptionalBool(value) => Ok(value),
        )
    }

    pub fn start_mutate_document_node_attribute(
        &self,
        reference: RendererDomNodeReference,
        mutation: RendererDomAttributeMutation,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::MutateDocumentNodeAttribute {
            reference,
            mutation,
        })
    }

    pub fn start_mutate_document_backend_node_attribute(
        &self,
        backend_node_id: u32,
        mutation: RendererDomAttributeMutation,
    ) -> Result<PendingPageCommand> {
        self.start_mutate_document_node_attribute(
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            mutation,
        )
    }

    pub fn finish_mutate_document_node_attribute(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomAttributeMutationOutcome> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "mutate document node attribute page command",
            "a DOM attribute mutation outcome reply",
            RendererPageReply::DomAttributeMutationOutcome(outcome) => Ok(outcome),
        )
    }

    pub fn start_edit_document_node(
        &self,
        inspector_session_id: Option<String>,
        edit: RendererDomEdit,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::EditDocumentNode {
            inspector_session_id,
            edit,
        })
    }

    pub fn finish_edit_document_node(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomEditOutcome> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "edit document node page command",
            "a DOM edit outcome reply",
            RendererPageReply::DomEditOutcome(outcome) => Ok(outcome),
        )
    }

    pub fn start_focus_document_node(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::FocusDocumentNode { reference })
    }

    pub fn start_focus_document_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_focus_document_node(RendererDomNodeReference::BackendNodeId(backend_node_id))
    }

    pub fn finish_focus_document_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomFocusOutcome> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "focus document node page command",
            "a DOM focus outcome reply",
            RendererPageReply::DomFocusOutcome(outcome) => Ok(outcome),
        )
    }

    pub fn start_focus_document_node_for_object_id(
        &self,
        inspector_session_id: Option<String>,
        object_id: String,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::focus_document_node_for_object_id(
            inspector_session_id,
            object_id,
        ))
    }

    pub fn start_autofill_trigger(
        &self,
        request: RendererAutofillTriggerRequest,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::TriggerAutofill(request))
    }

    pub fn finish_autofill_trigger(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererAutofillTriggerOutcome> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "autofill trigger page command",
            "an Autofill trigger outcome reply",
            RendererPageReply::AutofillTriggerOutcome(outcome) => Ok(outcome),
        )
    }

    pub fn start_set_file_input_files_for_backend_node_id(
        &self,
        backend_node_id: u32,
        files: Vec<super::SelectedFile>,
        append: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SetFileInputFilesForBackendNodeId {
            backend_node_id,
            files,
            append,
        })
    }

    pub fn finish_set_file_input_files(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<bool>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set file input files page command",
            "an optional bool reply",
            RendererPageReply::OptionalBool(value) => Ok(value),
        )
    }

    pub fn start_set_file_input_files_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
        files: Vec<super::SelectedFile>,
        append: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::set_file_input_files_for_object_id(
            inspector_session_id,
            object_id.to_owned(),
            files,
            append,
        ))
    }

    pub fn finish_set_file_input_files_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<bool>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set file input files object id page command",
            "an optional bool reply",
            RendererPageReply::OptionalBool(value) => Ok(value),
        )
    }

    pub fn start_document_node_snapshot_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        object_id: &str,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::document_node_snapshot_for_object_id(
            inspector_session_id,
            include_whitespace,
            object_id.to_owned(),
            depth,
            pierce,
        ))
    }

    pub fn finish_document_node_snapshot_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<DocumentNodeObjectSnapshot>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "describe node object id page command",
            "an optional document node object snapshot reply",
            RendererPageReply::OptionalDocumentNodeObjectSnapshot(snapshot) => Ok(*snapshot),
        )
    }

    pub fn start_document_node_exists_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeExistsForBackendNodeId {
            backend_node_id,
        })
    }

    pub fn finish_document_node_exists(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<bool> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(reply, "document node presence page command", "a bool reply", RendererPageReply::Bool(exists) => Ok(exists),)
    }

    pub fn start_document_node_snapshot_for_backend_node_id(
        &self,
        backend_node_id: u32,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeSnapshotForBackendNodeId {
            backend_node_id,
            depth,
            pierce,
        })
    }

    pub fn start_document_node_snapshot_for_node_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        reference: RendererDomNodeReference,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentNodeSnapshotForNodeInInspectorSession {
                inspector_session_id,
                include_whitespace,
                reference,
                depth,
                pierce,
            },
        )
    }

    pub fn start_document_node_snapshot_for_backend_node_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        backend_node_id: u32,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_node_snapshot_for_node_in_inspector_session(
            inspector_session_id,
            include_whitespace,
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            depth,
            pierce,
        )
    }

    pub fn finish_document_node_snapshot_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<DocumentNodeObjectSnapshot>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "backend document node snapshot page command",
            "an optional document node object snapshot reply",
            RendererPageReply::OptionalDocumentNodeObjectSnapshot(snapshot) => Ok(*snapshot),
        )
    }

    pub fn start_document_node_snapshot_for_document(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeSnapshotForDocument {
            inspector_session_id,
            include_whitespace,
            depth,
            pierce,
        })
    }

    pub fn finish_document_node_snapshot_for_document(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<DocumentNodeObjectSnapshot>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document snapshot page command",
            "an optional document node object snapshot reply",
            RendererPageReply::OptionalDocumentNodeObjectSnapshot(snapshot) => Ok(*snapshot),
        )
    }

    pub fn start_discard_dom_agent_frontend_bindings(
        &self,
        inspector_session_id: Option<String>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DiscardDomAgentFrontendBindings {
            inspector_session_id,
        })
    }

    pub fn finish_discard_dom_agent_frontend_bindings(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "discard DOM agent frontend bindings page command",
            "a unit reply",
            RendererPageReply::Unit => Ok(()),
        )
    }

    pub fn start_dom_snapshot_capture(
        &self,
        top_frame_id: String,
        options: RendererDomSnapshotCaptureOptions,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DomSnapshotCapture {
            top_frame_id,
            options,
        })
    }

    pub fn finish_dom_snapshot_capture(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDomSnapshotCapturePayload>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "DOMSnapshot capture page command",
            "an optional DOMSnapshot capture payload",
            RendererPageReply::OptionalDomSnapshotCapturePayload(payload) => Ok(payload),
        )
    }

    pub fn start_document_child_node_snapshot_events_for_node(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        reference: RendererDomNodeReference,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentChildNodeSnapshotEventsForNode {
                inspector_session_id,
                include_whitespace,
                reference,
                depth,
                pierce,
            },
        )
    }

    pub fn start_document_child_node_snapshot_events_for_backend_node_id(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        backend_node_id: u32,
        depth: i32,
        pierce: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_child_node_snapshot_events_for_node(
            inspector_session_id,
            include_whitespace,
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            depth,
            pierce,
        )
    }

    pub fn finish_document_child_node_snapshot_events(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentChildNodeSnapshotEvents>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document child node snapshot events page command",
            "optional document child node snapshot events",
            RendererPageReply::OptionalDocumentChildNodeSnapshotEvents(events) => Ok(events),
        )
    }

    pub fn start_document_query_selector_for_document(
        &self,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_query_selector_for_document_in_inspector_session(
            None, false, selector, multiple,
        )
    }

    pub fn start_document_query_selector_for_document_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentQuerySelectorForDocument {
            inspector_session_id,
            include_whitespace,
            selector,
            multiple,
        })
    }

    pub fn start_document_query_selector_for_backend_node_id(
        &self,
        root_backend_node_id: u32,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_query_selector_for_backend_node_id_in_inspector_session(
            None,
            false,
            root_backend_node_id,
            selector,
            multiple,
        )
    }

    pub fn start_document_query_selector_for_node_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        root: RendererDomNodeReference,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentQuerySelectorForNode {
            inspector_session_id,
            include_whitespace,
            root,
            selector,
            multiple,
        })
    }

    pub fn start_document_query_selector_for_backend_node_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        root_backend_node_id: u32,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_query_selector_for_node_in_inspector_session(
            inspector_session_id,
            include_whitespace,
            RendererDomNodeReference::BackendNodeId(root_backend_node_id),
            selector,
            multiple,
        )
    }

    pub fn start_child_frame_document_query_selector_for_node(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        frame_id: String,
        root: RendererDomNodeReference,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentQuerySelectorForChildFrameNode {
                inspector_session_id,
                include_whitespace,
                frame_id,
                root,
                selector,
                multiple,
            },
        )
    }

    pub fn start_child_frame_document_query_selector_for_backend_node_id(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        frame_id: String,
        root_backend_node_id: u32,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_child_frame_document_query_selector_for_node(
            inspector_session_id,
            include_whitespace,
            frame_id,
            RendererDomNodeReference::BackendNodeId(root_backend_node_id),
            selector,
            multiple,
        )
    }

    pub fn finish_document_query_selector(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentQuerySelectorResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document query selector page command",
            "a document query selector resolution",
            RendererPageReply::DocumentQuerySelectorResolution(resolution) => Ok(resolution),
        )
    }

    pub fn start_document_query_selector_with_child_node_snapshot_events_for_node(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        root: RendererDomNodeReference,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentQuerySelectorWithChildNodeSnapshotEventsForNode {
                inspector_session_id,
                include_whitespace,
                root,
                selector,
                multiple,
            },
        )
    }

    pub fn start_document_query_selector_with_child_node_snapshot_events_for_backend_node_id(
        &self,
        inspector_session_id: Option<String>,
        include_whitespace: bool,
        root_backend_node_id: u32,
        selector: String,
        multiple: bool,
    ) -> Result<PendingPageCommand> {
        self.start_document_query_selector_with_child_node_snapshot_events_for_node(
            inspector_session_id,
            include_whitespace,
            RendererDomNodeReference::BackendNodeId(root_backend_node_id),
            selector,
            multiple,
        )
    }

    pub fn finish_document_query_selector_with_child_node_snapshot_events(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentQuerySelectorWithChildNodeSnapshotEvents> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document query selector with child node snapshot events page command",
            "a document query selector with child node snapshot events reply",
            RendererPageReply::DocumentQuerySelectorWithChildNodeSnapshotEvents(result) => Ok(result),
        )
    }

    pub fn start_document_perform_search(
        &self,
        inspector_session_id: Option<String>,
        query: String,
        include_user_agent_shadow_dom: bool,
        include_whitespace: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentPerformSearch {
            inspector_session_id,
            query,
            include_user_agent_shadow_dom,
            include_whitespace,
        })
    }

    pub fn finish_document_perform_search(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomSearchRegistration> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document perform search page command",
            "a document search registration reply",
            RendererPageReply::DocumentPerformSearch(result) => Ok(result),
        )
    }

    pub fn start_document_search_results(
        &self,
        inspector_session_id: Option<String>,
        search_id: String,
        from_index: usize,
        to_index: usize,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentGetSearchResults {
            inspector_session_id,
            search_id,
            from_index,
            to_index,
        })
    }

    pub fn finish_document_search_results(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomSearchResultsResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document search results page command",
            "a document search results resolution",
            RendererPageReply::DocumentSearchResults(result) => Ok(result),
        )
    }

    pub fn start_discard_document_search_results(
        &self,
        inspector_session_id: Option<String>,
        search_id: String,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentDiscardSearchResults {
            inspector_session_id,
            search_id,
        })
    }

    pub fn finish_discard_document_search_results(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document discard search results page command",
            "a document search results discarded reply",
            RendererPageReply::DocumentSearchResultsDiscarded => Ok(()),
        )
    }

    pub fn start_set_document_node_stack_traces_enabled(
        &self,
        inspector_session_id: Option<String>,
        enabled: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentSetNodeStackTracesEnabled {
            inspector_session_id,
            enabled,
        })
    }

    pub fn finish_set_document_node_stack_traces_enabled(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "set document node stack traces enabled page command",
            "a document node stack traces enabled reply",
            RendererPageReply::DocumentNodeStackTracesEnabled => Ok(()),
        )
    }

    pub fn start_document_node_stack_trace(
        &self,
        inspector_session_id: Option<String>,
        frontend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeStackTrace {
            inspector_session_id,
            frontend_node_id,
        })
    }

    pub fn finish_document_node_stack_trace(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomNodeStackTraceResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document node stack trace page command",
            "a document node stack trace resolution",
            RendererPageReply::DocumentNodeStackTrace(result) => Ok(result),
        )
    }

    pub fn start_document_frontend_node_binding(
        &self,
        inspector_session_id: Option<String>,
        frontend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentFrontendNodeBinding {
            inspector_session_id,
            frontend_node_id,
        })
    }

    pub fn finish_document_frontend_node_binding(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomFrontendNodeBindingResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document frontend node binding page command",
            "a document frontend node binding resolution",
            RendererPageReply::DocumentFrontendNodeBinding(result) => Ok(result),
        )
    }

    pub fn start_register_document_bidi_node_binding(
        &self,
        inspector_session_id: Option<String>,
        shared_id: String,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::RegisterDocumentBidiNodeBinding {
            inspector_session_id,
            shared_id,
            backend_node_id,
        })
    }

    pub fn finish_register_document_bidi_node_binding(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<()> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document BiDi node binding registration page command",
            "a document BiDi node binding registered reply",
            RendererPageReply::DocumentBidiNodeBindingRegistered => Ok(()),
        )
    }

    pub fn start_document_bidi_node_binding(
        &self,
        inspector_session_id: Option<String>,
        shared_id: String,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentBidiNodeBinding {
            inspector_session_id,
            shared_id,
        })
    }

    pub fn finish_document_bidi_node_binding(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomBidiNodeBindingResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document BiDi node binding page command",
            "a document BiDi node binding resolution",
            RendererPageReply::DocumentBidiNodeBinding(result) => Ok(result),
        )
    }

    pub fn start_document_bidi_node_shared_id_for_backend_node_id(
        &self,
        inspector_session_id: Option<String>,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentBidiNodeSharedIdForBackendNodeId {
                inspector_session_id,
                backend_node_id,
            },
        )
    }

    pub fn finish_document_bidi_node_shared_id_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDomBidiNodeSharedIdResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document BiDi node shared id page command",
            "a document BiDi node shared id resolution",
            RendererPageReply::DocumentBidiNodeSharedId(result) => Ok(result),
        )
    }

    /// Resolve the native reference and read attributes in one renderer turn.
    pub fn start_document_node_attributes(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeAttributes { reference })
    }

    pub fn start_document_node_attributes_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_document_node_attributes(RendererDomNodeReference::BackendNodeId(
            backend_node_id,
        ))
    }

    pub fn finish_document_node_attributes(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentNodeAttributesResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document node attributes page command",
            "a document node attributes resolution",
            RendererPageReply::DocumentNodeAttributesResolution(resolution) => Ok(resolution),
        )
    }

    pub fn start_document_node_text(
        &self,
        reference: RendererDomNodeReference,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeText { reference })
    }

    pub fn start_document_node_text_for_backend_node_id(
        &self,
        backend_node_id: u32,
    ) -> Result<PendingPageCommand> {
        self.start_document_node_text(RendererDomNodeReference::BackendNodeId(backend_node_id))
    }

    pub fn finish_document_node_text(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentNodeTextResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document node text page command",
            "a document node text resolution",
            RendererPageReply::DocumentNodeTextResolution(resolution) => Ok(resolution),
        )
    }

    pub fn start_document_node_property(
        &self,
        reference: RendererDomNodeReference,
        name: &str,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentNodeProperty {
            reference,
            name: name.to_owned(),
        })
    }

    pub fn start_document_node_property_for_backend_node_id(
        &self,
        backend_node_id: u32,
        name: &str,
    ) -> Result<PendingPageCommand> {
        self.start_document_node_property(
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            name,
        )
    }

    pub fn finish_document_node_property(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentNodePropertyResolution> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "document node property page command",
            "a document node property resolution",
            RendererPageReply::DocumentNodePropertyResolution(resolution) => Ok(resolution),
        )
    }

    pub fn start_outer_html_for_document(
        &self,
        include_shadow_dom: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::OuterHtmlForDocument { include_shadow_dom })
    }

    pub fn finish_outer_html_for_document(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<String> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "outerHTML document page command",
            "a string reply",
            RendererPageReply::OptionalString(Some(outer_html)) => Ok(outer_html),
        )
    }

    pub fn start_outer_html_for_object_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: &str,
        include_shadow_dom: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::outer_html_for_object_id(
            inspector_session_id,
            object_id.to_owned(),
            include_shadow_dom,
        ))
    }

    pub fn finish_outer_html_for_object_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<String>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "outerHTML object id page command",
            "an optional string reply",
            RendererPageReply::OptionalString(outer_html) => Ok(outer_html),
        )
    }

    pub fn start_outer_html_for_node(
        &self,
        reference: RendererDomNodeReference,
        include_shadow_dom: bool,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::OuterHtmlForNode {
            reference,
            include_shadow_dom,
        })
    }

    pub fn start_outer_html_for_backend_node_id(
        &self,
        backend_node_id: u32,
        include_shadow_dom: bool,
    ) -> Result<PendingPageCommand> {
        self.start_outer_html_for_node(
            RendererDomNodeReference::BackendNodeId(backend_node_id),
            include_shadow_dom,
        )
    }

    pub fn finish_outer_html_for_node(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<String>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "outerHTML node page command",
            "an optional string reply",
            RendererPageReply::OptionalString(outer_html) => Ok(outer_html),
        )
    }

    pub fn finish_outer_html_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<String>> {
        self.finish_outer_html_for_node(completion)
    }

    pub fn start_serialize_html(&self) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::SerializeDocument)
    }

    /// Publishes current layout for subsequent geometry reads without painting.
    ///
    /// This is an explicit refresh, used by CLI `fetch --layout --eval` after
    /// readiness. Ordinary script evaluation and geometry reads do not call it.
    /// When real layout is disabled, this is a no-op.
    pub async fn publish_layout_async(&mut self) -> Result<()> {
        self.dispatch_unit_page_command_async(RendererPageCommand::PublishLayout, "publish layout")
            .await
    }

    pub fn start_layout_metrics(&self) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::LayoutMetrics)
    }

    pub fn finish_layout_metrics(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererLayoutMetrics> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "layout metrics page command",
            "a layout metrics reply",
            RendererPageReply::LayoutMetrics(metrics) => Ok(metrics),
        )
    }

    pub fn start_print_to_pdf(
        &self,
        request: super::RendererPrintToPdfRequest,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::PrintToPdf(request))
    }

    pub fn finish_print_to_pdf(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<super::RendererPrintToPdfReply> {
        anyhow::ensure!(
            completion.renderer_agent_attachment_id() == self.renderer_agent_attachment_id(),
            "print to PDF completed for a stale renderer attachment"
        );
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "print to PDF page command",
            "a print to PDF reply",
            RendererPageReply::PrintToPdf(result) => Ok(result),
        )
    }

    pub fn start_capture_screenshot(&self) -> Result<PendingPageCommand> {
        self.start_capture_screenshot_with_request(RendererCaptureScreenshotRequest::viewport_png())
    }

    pub fn start_capture_screenshot_with_request(
        &self,
        request: RendererCaptureScreenshotRequest,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::CaptureScreenshot(request))
    }

    pub fn finish_capture_screenshot(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererCaptureScreenshotReply> {
        anyhow::ensure!(
            completion.renderer_agent_attachment_id() == self.renderer_agent_attachment_id(),
            "capture screenshot completed for a stale renderer attachment"
        );
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "capture screenshot page command",
            "a capture screenshot reply",
            RendererPageReply::CaptureScreenshot(result) => Ok(result),
        )
    }

    pub fn start_capture_screencast_frame(
        &self,
        request: RendererCaptureScreencastFrameRequest,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::CaptureScreencastFrame(request))
    }

    pub fn finish_capture_screencast_frame(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererCaptureScreencastFrameReply> {
        anyhow::ensure!(
            completion.renderer_agent_attachment_id() == self.renderer_agent_attachment_id(),
            "capture screencast frame completed for a stale renderer attachment"
        );
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "capture screencast frame page command",
            "a capture screencast frame reply",
            RendererPageReply::CaptureScreencastFrame(result) => Ok(result),
        )
    }

    pub fn start_render_page_dump(
        &self,
        options: RendererPageDumpOptions,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::RenderPageDump { options })
    }

    pub fn finish_render_page_dump(&mut self, completion: CompletedPageCommand) -> Result<String> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "render page dump page command",
            "a string reply",
            RendererPageReply::OptionalString(Some(rendered)) => Ok(rendered),
        )
    }

    pub async fn render_page_dump_async(
        &mut self,
        options: RendererPageDumpOptions,
    ) -> Result<String> {
        let pending = self.start_render_page_dump(options)?;
        let completion = pending.wait().await?;
        self.finish_render_page_dump(completion)
    }

    pub fn finish_serialize_html(&mut self, completion: CompletedPageCommand) -> Result<String> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "serialize HTML page command",
            "a serialized document reply",
            RendererPageReply::SerializedDocument { html, .. } => Ok(html),
        )
    }

    pub async fn serialize_html_async(&self) -> Result<String> {
        let pending = self.start_serialize_html()?;
        let completion = pending.wait().await?;
        let (completion, _renderer_output_predecessor) =
            completion.into_output().into_completion_and_predecessor();
        let (reply, _, _) = completion.into_parts();
        expect_page_reply!(
            reply,
            "serialize HTML page command",
            "a serialized document reply",
            RendererPageReply::SerializedDocument { html, .. } => Ok(html),
        )
    }

    pub fn start_resolve_runtime_object_for_backend_node_id_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        backend_node_id: u32,
        execution_context_id: Option<i64>,
        object_group: Option<&str>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::resolve_runtime_object_for_backend_node_id(
                inspector_session_id,
                backend_node_id,
                execution_context_id,
                object_group.map(str::to_owned),
            ),
        )
    }

    pub fn finish_resolve_runtime_object_for_backend_node_id(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<DocumentNodeRuntimeObjectResolution> {
        self.finish_runtime_remote_object_resolution(
            completion,
            "resolve backend node runtime object page command",
        )
    }

    pub fn start_resolve_blob_object_in_inspector_session(
        &self,
        inspector_session_id: Option<String>,
        object_id: String,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::resolve_blob_object(
            inspector_session_id,
            object_id,
        ))
    }

    pub fn finish_resolve_blob_object(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<String> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "resolve Blob object page command",
            "a Blob UUID reply",
            RendererPageReply::BlobUuid(uuid) => Ok(uuid),
        )
    }

    pub fn start_blob_bytes_for_uuid(&self, uuid: String) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::BlobBytesForUuid { uuid })
    }

    pub fn finish_blob_bytes_for_uuid(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<Arc<[u8]>>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "read Blob backing page command",
            "optional Blob bytes",
            RendererPageReply::OptionalBlobBytes(bytes) => Ok(bytes),
        )
    }

    fn finish_runtime_remote_object_resolution(
        &mut self,
        completion: CompletedPageCommand,
        command_name: &'static str,
    ) -> Result<DocumentNodeRuntimeObjectResolution> {
        let reply = self.finish_page_command(completion);
        let resolution = expect_page_reply!(
            reply,
            command_name,
            "a runtime remote object resolution reply",
            RendererPageReply::RuntimeRemoteObjectResolution(resolution) => Ok(resolution),
        )?;
        match resolution {
            crate::renderer::RendererRuntimeRemoteObjectResolution::Found(remote_object) => {
                Ok(DocumentNodeRuntimeObjectResolution::Found(remote_object))
            }
            crate::renderer::RendererRuntimeRemoteObjectResolution::MissingContext => {
                Ok(DocumentNodeRuntimeObjectResolution::MissingContext)
            }
            crate::renderer::RendererRuntimeRemoteObjectResolution::MissingNode => {
                Ok(DocumentNodeRuntimeObjectResolution::MissingNode)
            }
        }
    }

    pub fn start_document_frontend_node_ids_for_backend_node_ids(
        &self,
        inspector_session_id: Option<String>,
        backend_node_ids: Vec<u32>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(
            RendererPageCommand::DocumentFrontendNodeIdsForBackendNodeIds {
                inspector_session_id,
                backend_node_ids,
            },
        )
    }

    pub fn finish_document_frontend_node_ids_for_backend_node_ids(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<RendererDocumentFrontendNodeIdsResolution> {
        expect_page_reply!(
            self.finish_page_command(completion),
            "document frontend node ids for backend node ids page command",
            "frontend node ids resolution reply",
            RendererPageReply::DocumentFrontendNodeIds(resolution) => Ok(resolution),
        )
    }

    pub async fn child_frame_tree_snapshot_async(&mut self) -> Result<Vec<ChildFrameTreeSnapshot>> {
        let pending = self.start_child_frame_tree_snapshot()?;
        let completion = pending.wait().await?;
        self.finish_child_frame_tree_snapshot(completion)
    }

    pub async fn document_storage_key_snapshot_async(&mut self) -> Result<String> {
        let pending = self.start_document_storage_key_snapshot()?;
        self.finish_document_storage_key_snapshot(pending.wait().await?)
    }

    pub fn start_document_storage_key_snapshot(&self) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::DocumentStorageKeySnapshot)
    }

    pub fn finish_document_storage_key_snapshot(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<String> {
        expect_page_reply!(
            self.finish_page_command(completion),
            "document storage key snapshot page command",
            "a document storage key reply",
            RendererPageReply::DocumentStorageKey(storage_key) => Ok(storage_key),
        )
    }

    pub fn start_child_frame_tree_snapshot(&self) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ChildFrameTreeSnapshot)
    }

    /// Admit a frontend terminal, distinct from an internal renderer query.
    /// The returned guard must live with the adapter continuation until the
    /// producer has settled; dropping it earlier cancels the publication.
    pub fn start_cdp_call(
        &self,
        command_id: u64,
        frontend_session_id: Option<&str>,
        operation: crate::RendererNativeOperation,
    ) -> Result<(
        PendingPageCommand,
        crate::RendererNativeCommandResponseGuard,
    )> {
        let attachment = self.renderer_agent_attachment_id.ok_or_else(|| {
            anyhow::anyhow!("native frontend command requires a renderer attachment")
        })?;
        let (command, guard) = crate::RendererCdpCall::new(
            moli_page_types::FrontendCommandId::new(command_id),
            moli_page_types::DevToolsSessionKey::from_wire_session_id(frontend_session_id),
            attachment,
            operation,
        );
        Ok((
            self.start_page_command(RendererPageCommand::Native(command))?,
            guard,
        ))
    }

    pub fn finish_child_frame_tree_snapshot(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Vec<ChildFrameTreeSnapshot>> {
        let reply = self.finish_page_command(completion);
        expect_page_reply!(
            reply,
            "child frame tree snapshot page command",
            "child frame tree snapshots",
            RendererPageReply::ChildFrameTreeSnapshots(snapshots) => Ok(snapshots),
        )
    }

    pub async fn child_frame_owner_node_reference_async(
        &mut self,
        frame_id: &str,
        inspector_session_id: Option<String>,
    ) -> Result<Option<RendererDocumentNodeReference>> {
        let pending =
            self.start_child_frame_owner_node_reference(frame_id, inspector_session_id)?;
        let completion = pending.wait().await?;
        self.finish_document_node_reference(completion)
    }

    pub fn start_child_frame_owner_node_reference(
        &self,
        frame_id: &str,
        inspector_session_id: Option<String>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ChildFrameOwnerNodeReference {
            inspector_session_id,
            frame_id: frame_id.to_owned(),
        })
    }

    pub async fn child_frame_document_root_node_reference_async(
        &mut self,
        frame_id: &str,
        inspector_session_id: Option<String>,
    ) -> Result<Option<RendererDocumentNodeReference>> {
        let pending =
            self.start_child_frame_document_root_node_reference(frame_id, inspector_session_id)?;
        let completion = pending.wait().await?;
        self.finish_document_node_reference(completion)
    }

    pub fn start_child_frame_document_root_node_reference(
        &self,
        frame_id: &str,
        inspector_session_id: Option<String>,
    ) -> Result<PendingPageCommand> {
        self.start_page_command(RendererPageCommand::ChildFrameDocumentRootNodeReference {
            inspector_session_id,
            frame_id: frame_id.to_owned(),
        })
    }

    pub fn finish_document_node_reference(
        &mut self,
        completion: CompletedPageCommand,
    ) -> Result<Option<RendererDocumentNodeReference>> {
        expect_page_reply!(
            self.finish_page_command(completion),
            "document node reference page command",
            "an optional document node reference reply",
            RendererPageReply::OptionalDocumentNodeReference(reference) => Ok(reference),
        )
    }
}