Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix: acknowledge pending input on page replacement
ldm0a9aa7a321603
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 7c98aa6f3..49a1f1b37 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -543,7 +543,8 @@ pub(crate) use state::{ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,TargetPageAttachmentId, TargetPageProtocolAttachmentIdentity, TargetPageResidenceIdentity,- TargetPageSessionState, TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,+ TargetPageResidenceObservation, TargetPageResidenceObserver, TargetPageSessionState,+ TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,TargetRootDocumentProtocolAttachmentIdentity, TargetRuntimeSlot,TargetServiceWorkerProtocolAttachmentIdentity, TargetServiceWorkerProtocolAttachmentRetirement,TargetServiceWorkerRunIdentity, TargetServiceWorkerRunRetirement,diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex b8b91b2a0..f5406b21d 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -3021,6 +3021,26 @@ impl CdpConnection {== Some(expected)}+ /// Observes replacement of the exact installed Page that admitted work.+ pub(crate) fn register_target_page_residence_observer_for_session(+ &mut self,+ session_id: Option<&str>,+ expected: &TargetPageResidenceIdentity,+ ) -> crate::conn::TargetPageResidenceObserver {+ if !self.target_page_residence_identity_is_current_for_session(session_id, expected) {+ return crate::conn::TargetPageResidenceObserver::resolved(+ crate::conn::TargetPageResidenceObservation::Superseded,+ );+ }+ let Ok(slot) = self.runtime_session_owner_slot_mut(session_id) else {+ return crate::conn::TargetPageResidenceObserver::resolved(+ crate::conn::TargetPageResidenceObservation::Unavailable,+ );+ };+ slot.page_slot_mut()+ .register_page_residence_observer(expected.loaded_page_generation())+ }+/// Captures the exact protocol attachment currently addressing a Page.pub(crate) fn target_page_protocol_attachment_identity_for_session(&self,diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rsindex cbb71bb26..e246970a4 100644--- a/moli-protocol/src/conn/state/mod.rs+++ b/moli-protocol/src/conn/state/mod.rs@@ -12,6 +12,7 @@ mod inspector;mod javascript_dialog;mod navigation;mod navigation_outcome;+mod page_residence_observer;mod page_resource;mod page_slot;mod parking;@@ -56,6 +57,9 @@ pub(crate) use devtools_session::{pub(crate) use document_lifecycle_observer::{RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,};+pub(crate) use page_residence_observer::{+ TargetPageResidenceObservation, TargetPageResidenceObserver,+};pub use bounds::BrowserWindowBounds;diff --git a/moli-protocol/src/conn/state/page_residence_observer.rs b/moli-protocol/src/conn/state/page_residence_observer.rsnew file mode 100644index 000000000..bb271b4c9--- /dev/null+++ b/moli-protocol/src/conn/state/page_residence_observer.rs@@ -0,0 +1,94 @@+use tokio::sync::watch;++/// Terminal result of observing one exact installed Page residence.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum TargetPageResidenceObservation {+ Superseded,+ Unavailable,+}++/// Move-only notification that an installed Page generation was replaced.+///+/// The observer is tied directly to the target's Page slot. Moving that slot+/// between active and background storage preserves the observation; advancing+/// its installed Page generation publishes `Superseded`. Losing the slot+/// entirely closes the channel and produces `Unavailable`.+#[derive(Debug)]+pub(crate) struct TargetPageResidenceObserver {+ state: TargetPageResidenceObserverState,+}++#[derive(Debug)]+enum TargetPageResidenceObserverState {+ Watching {+ expected_generation: u64,+ receiver: watch::Receiver<u64>,+ },+ Resolved(TargetPageResidenceObservation),+}++impl TargetPageResidenceObserver {+ pub(crate) fn new(expected_generation: u64, receiver: watch::Receiver<u64>) -> Self {+ Self {+ state: TargetPageResidenceObserverState::Watching {+ expected_generation,+ receiver,+ },+ }+ }++ pub(crate) fn resolved(observation: TargetPageResidenceObservation) -> Self {+ Self {+ state: TargetPageResidenceObserverState::Resolved(observation),+ }+ }++ pub(crate) async fn wait(self) -> TargetPageResidenceObservation {+ let (expected_generation, mut receiver) = match self.state {+ TargetPageResidenceObserverState::Watching {+ expected_generation,+ receiver,+ } => (expected_generation, receiver),+ TargetPageResidenceObserverState::Resolved(observation) => return observation,+ };+ loop {+ if *receiver.borrow_and_update() != expected_generation {+ return TargetPageResidenceObservation::Superseded;+ }+ if receiver.changed().await.is_err() {+ return TargetPageResidenceObservation::Unavailable;+ }+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[tokio::test]+ async fn generation_change_publishes_superseded() {+ let (publisher, receiver) = watch::channel(7);+ let observer = TargetPageResidenceObserver::new(7, receiver);++ publisher.send_replace(8);++ assert_eq!(+ observer.wait().await,+ TargetPageResidenceObservation::Superseded+ );+ }++ #[tokio::test]+ async fn publisher_loss_reports_unavailable() {+ let (publisher, receiver) = watch::channel(7);+ let observer = TargetPageResidenceObserver::new(7, receiver);++ drop(publisher);++ assert_eq!(+ observer.wait().await,+ TargetPageResidenceObservation::Unavailable+ );+ }+}diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rsindex bd9c8cd7e..1bd4cfc60 100644--- a/moli-protocol/src/conn/state/page_slot.rs+++ b/moli-protocol/src/conn/state/page_slot.rs@@ -14,6 +14,7 @@ use super::document_lifecycle_observer::{RendererDocumentLifecycleObservation, RendererDocumentLifecycleObservationPublisher,RendererDocumentLifecycleObserver,};+use super::page_residence_observer::{TargetPageResidenceObservation, TargetPageResidenceObserver};use super::{NavigationRequestId, RendererPageResidenceIdentity, TargetPageAttachmentId};#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]@@ -332,6 +333,7 @@ pub(crate) struct TargetPageSlot {loaded_page_absence_reason: TargetPageAbsenceReason,page_attachment_id: Option<TargetPageAttachmentId>,loaded_page_generation: u64,+ loaded_page_generation_publisher: Option<watch::Sender<u64>>,pending_navigation_request: Option<PendingNavigationRequest>,committed_document_navigation: Option<DocumentNavigationToken>,renderer_document_lifecycle: RendererDocumentLifecycleProtocolState,@@ -502,11 +504,27 @@ impl TargetPageSlot {self.loaded_page_generation}+ pub(crate) fn register_page_residence_observer(+ &mut self,+ expected_generation: u64,+ ) -> TargetPageResidenceObserver {+ if self.loaded_page_generation != expected_generation {+ return TargetPageResidenceObserver::resolved(+ TargetPageResidenceObservation::Superseded,+ );+ }+ let publisher = self+ .loaded_page_generation_publisher+ .get_or_insert_with(|| watch::channel(self.loaded_page_generation).0);+ TargetPageResidenceObserver::new(expected_generation, publisher.subscribe())+ }+fn advance_loaded_page_generation(&mut self) {self.finish_renderer_document_lifecycle_observers(RendererDocumentLifecycleObservation::Superseded,);self.loaded_page_generation = self.loaded_page_generation.wrapping_add(1);+ self.publish_loaded_page_generation();}#[cfg(test)]@@ -516,12 +534,20 @@ impl TargetPageSlot {#[cfg(test)]pub(crate) fn set_loaded_page_generation(&mut self, generation: u64) {- if self.loaded_page_generation != generation {- self.finish_renderer_document_lifecycle_observers(- RendererDocumentLifecycleObservation::Superseded,- );+ if self.loaded_page_generation == generation {+ return;}+ self.finish_renderer_document_lifecycle_observers(+ RendererDocumentLifecycleObservation::Superseded,+ );self.loaded_page_generation = generation;+ self.publish_loaded_page_generation();+ }++ fn publish_loaded_page_generation(&self) {+ if let Some(publisher) = self.loaded_page_generation_publisher.as_ref() {+ publisher.send_replace(self.loaded_page_generation);+ }}#[cfg(test)]diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rsindex c5dd0ae1b..bbf591c66 100644--- a/moli-protocol/src/domains/input.rs+++ b/moli-protocol/src/domains/input.rs@@ -1,6 +1,6 @@use crate::conn::{BackgroundProtocolEvent, CdpConnection, Cmd, CommandDispatchContext,- TargetPageResidenceIdentity,+ TargetPageResidenceIdentity, TargetPageResidenceObservation, TargetPageResidenceObserver,};use crate::devtools_runtime::{DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult,@@ -61,6 +61,7 @@ pub(crate) struct PendingInputCommandDispatch {command_id: Option<u64>,session_id: Option<String>,owner: TargetPageResidenceIdentity,+ owner_observer: Option<TargetPageResidenceObserver>,kind: PendingInputCommandKind,pending: PendingInputOperation,}@@ -135,6 +136,30 @@ enum PendingInputOperation {enum CompletedInputOperation {Page(Box<Result<CompletedPageCommand, String>>),+ PageResidenceSuperseded,+ PageResidenceUnavailable,+}++enum RendererInputWaitOutcome<T> {+ Completed(T),+ PageResidence(TargetPageResidenceObservation),+}++async fn wait_for_renderer_input_or_page_replacement<T>(+ completion: impl std::future::Future<Output = T>,+ owner_observer: Option<TargetPageResidenceObserver>,+) -> RendererInputWaitOutcome<T> {+ let Some(owner_observer) = owner_observer else {+ return RendererInputWaitOutcome::Completed(completion.await);+ };+ tokio::pin!(completion);+ tokio::select! {+ biased;+ result = &mut completion => RendererInputWaitOutcome::Completed(result),+ observation = owner_observer.wait() => {+ RendererInputWaitOutcome::PageResidence(observation)+ }+ }}impl PendingInputCommandDispatch {@@ -143,16 +168,32 @@ impl PendingInputCommandDispatch {}pub(crate) async fn wait(self) -> CompletedInputCommandDispatch {+ let completed = match self.pending {+ PendingInputOperation::Page(pending) => {+ match wait_for_renderer_input_or_page_replacement(+ pending.wait(),+ self.owner_observer,+ )+ .await+ {+ RendererInputWaitOutcome::Completed(result) => CompletedInputOperation::Page(+ Box::new(result.map_err(|error| error.to_string())),+ ),+ RendererInputWaitOutcome::PageResidence(+ TargetPageResidenceObservation::Superseded,+ ) => CompletedInputOperation::PageResidenceSuperseded,+ RendererInputWaitOutcome::PageResidence(+ TargetPageResidenceObservation::Unavailable,+ ) => CompletedInputOperation::PageResidenceUnavailable,+ }+ }+ };CompletedInputCommandDispatch {command_id: self.command_id,session_id: self.session_id,owner: self.owner,kind: self.kind,- completed: match self.pending {- PendingInputOperation::Page(pending) => CompletedInputOperation::Page(Box::new(- pending.wait().await.map_err(|error| error.to_string()),- )),- },+ completed,}}}@@ -167,6 +208,15 @@ impl CompletedInputCommandDispatch {}}+impl PendingInputCommandKind {+ fn uses_renderer_host_ack_cleanup(&self) -> bool {+ // Chromium's InputInjector owns replacement cleanup for the mouse and+ // key callback queues. Touch, drag, and IME commands have separate+ // completion protocols and must keep waiting for those terminals.+ matches!(self, Self::DispatchMouseEvent | Self::DispatchKeyEvent)+ }+}+impl PendingInputCommandStartError {fn invalid_params() -> Self {Self {@@ -534,21 +584,13 @@ fn start_pending_input_command(InputAction::InsertText => {let text = key::parse_insert_text(cmd).map_err(|_| PendingInputCommandStartError::invalid_params())?;- let owner = conn- .target_page_residence_identity_for_session(cmd.session_id)- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;- let page = loaded_page_mut(conn, cmd.session_id)- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;- Ok(Some(PendingInputCommandDispatch {- command_id: cmd.id,- session_id: cmd.session_id.map(str::to_owned),- owner,- kind: PendingInputCommandKind::InsertText,- pending: PendingInputOperation::Page(- page.start_insert_text_into_active_control(&text)- .map_err(PendingInputCommandStartError::renderer_error)?,- ),- }))+ start_page_input_command(+ conn,+ cmd.id,+ cmd.session_id,+ PendingInputCommandKind::InsertText,+ |page| page.start_insert_text_into_active_control(&text),+ )}InputAction::CancelDragging| InputAction::SetIgnoreInputEvents@@ -911,17 +953,12 @@ fn start_devtools_dispatch_key_event_command(command_session_id: Option<&str>,command: DevToolsDispatchKeyEventCommand,) -> Result<Option<PendingInputCommandDispatch>, PendingInputCommandStartError> {- let owner = conn- .target_page_residence_identity_for_session(command_session_id)- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;- let page = loaded_page_mut(conn, command_session_id)- .ok_or_else(PendingInputCommandStartError::no_document_loaded)?;- Ok(Some(PendingInputCommandDispatch {+ start_page_input_command(+ conn,command_id,- session_id: command_session_id.map(str::to_owned),- owner,- kind: PendingInputCommandKind::DispatchKeyEvent,- pending: PendingInputOperation::Page(+ command_session_id,+ PendingInputCommandKind::DispatchKeyEvent,+ |page| {page.start_dispatch_key_event_with_outcome(key::devtools_key_event_dom_event_name(command.event_type),&command.key,@@ -931,9 +968,8 @@ fn start_devtools_dispatch_key_event_command(command.auto_repeat,command.should_insert_text,)- .map_err(PendingInputCommandStartError::renderer_error)?,- ),- }))+ },+ )}fn start_page_input_command(@@ -949,10 +985,14 @@ fn start_page_input_command(let page = loaded_page_mut(conn, command_session_id).ok_or_else(PendingInputCommandStartError::no_document_loaded)?;let pending = start(page).map_err(PendingInputCommandStartError::renderer_error)?;+ let owner_observer = kind.uses_renderer_host_ack_cleanup().then(|| {+ conn.register_target_page_residence_observer_for_session(command_session_id, &owner)+ });Ok(Some(PendingInputCommandDispatch {command_id,session_id: command_session_id.map(str::to_owned),owner,+ owner_observer,kind,pending: PendingInputOperation::Page(pending),}))@@ -1231,7 +1271,27 @@ async fn complete_pending_input_command() -> CompletedInputCommandResult {let session_id = completed.session_id.as_deref();let owner = completed.owner;- let completed_operation = completed.completed;+ let completed_operation = match completed.completed {+ CompletedInputOperation::Page(completed) => completed,+ CompletedInputOperation::PageResidenceSuperseded => {+ // Match InputInjector::Cleanup(): replacement of the widget/Page+ // retires an outstanding mouse/key ACK as protocol success even+ // when the old renderer never publishes its normal completion.+ return CompletedInputCommandResult {+ result: Ok(DevToolsCommandResult::Empty),+ protocol_events: Vec::new(),+ };+ }+ CompletedInputOperation::PageResidenceUnavailable => {+ return CompletedInputCommandResult {+ result: Err(DevToolsError::new(+ DevToolsErrorKind::Internal,+ "input command Page residence became unavailable",+ )),+ protocol_events: Vec::new(),+ };+ }+ };let mut side_effects = InputCommandSideEffects::default();let result = match completed.kind {@@ -1402,13 +1462,11 @@ pub(crate) async fn complete_pending_input_command_output_plan(}fn completed_page_command_result(- completed: CompletedInputOperation,+ completed: Box<Result<CompletedPageCommand, String>>,) -> Result<CompletedPageCommand, DevToolsError> {- match completed {- CompletedInputOperation::Page(result) => match *result {- Ok(completion) => Ok(completion),- Err(error) => Err(DevToolsError::new(DevToolsErrorKind::Internal, error)),- },+ match *completed {+ Ok(completion) => Ok(completion),+ Err(error) => Err(DevToolsError::new(DevToolsErrorKind::Internal, error)),}}diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rsindex 12b77be79..689f72347 100644--- a/moli-protocol/src/domains/input/tests.rs+++ b/moli-protocol/src/domains/input/tests.rs@@ -288,6 +288,7 @@ async fn completed_mouse_event_does_not_restore_replaced_page_state() {command_id: Some(104),session_id: None,owner: original_owner.clone(),+ owner_observer: None,kind: PendingInputCommandKind::DispatchMouseEvent,pending: PendingInputOperation::Page(pending),}@@ -321,6 +322,49 @@ async fn completed_mouse_event_does_not_restore_replaced_page_state() {);}+#[tokio::test(flavor = "multi_thread")]+async fn pending_mouse_event_acknowledges_when_page_is_replaced_before_renderer_completion() {+ let mut ctx = TestContext::new();+ with_loaded_document(&mut ctx, "<body>origin</body>").await;++ let original_owner = ctx+ .conn+ .target_page_residence_identity_for_session(None)+ .expect("the original Page should have a residence identity");+ let observer = ctx+ .conn+ .register_target_page_residence_observer_for_session(None, &original_owner);++ let replacement_url = "data:text/html,<body>replacement-before-completion</body>";+ ctx.install_navigation_fixture_for_session_owner(replacement_url, None)+ .await;++ let wait =+ wait_for_renderer_input_or_page_replacement(std::future::pending::<()>(), Some(observer));+ let outcome = tokio::time::timeout(std::time::Duration::from_secs(1), wait)+ .await+ .expect("Page replacement should settle the pending input wait");+ assert!(matches!(+ outcome,+ RendererInputWaitOutcome::PageResidence(TargetPageResidenceObservation::Superseded)+ ));++ let completed = complete_pending_input_command(+ &mut ctx.conn,+ CompletedInputCommandDispatch {+ command_id: Some(105),+ session_id: None,+ owner: original_owner,+ kind: PendingInputCommandKind::DispatchMouseEvent,+ completed: CompletedInputOperation::PageResidenceSuperseded,+ },+ &mut CommandDispatchContext::default(),+ )+ .await;+ assert!(matches!(completed.result, Ok(DevToolsCommandResult::Empty)));+ assert!(completed.protocol_events.is_empty());+}+#[tokio::test(flavor = "multi_thread")]async fn coordinate_mouse_event_without_document_still_reports_no_document_loaded() {let mut ctx = TestContext::new();