Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
refactor: bind input cleanup to page attachments
ldm0353bf19d2888
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 49a1f1b37..de9780a62 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -543,7 +543,7 @@ pub(crate) use state::{ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,TargetPageAttachmentId, TargetPageProtocolAttachmentIdentity, TargetPageResidenceIdentity,- TargetPageResidenceObservation, TargetPageResidenceObserver, TargetPageSessionState,+ TargetPageResidenceObservation, TargetPageResidenceToken, TargetPageSessionState,TargetPreparedJavaScriptDialog, TargetPreparedJavaScriptDialogRoute,TargetRootDocumentProtocolAttachmentIdentity, TargetRuntimeSlot,TargetServiceWorkerProtocolAttachmentIdentity, TargetServiceWorkerProtocolAttachmentRetirement,diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex f5406b21d..8617dc5e4 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -3021,24 +3021,20 @@ impl CdpConnection {== Some(expected)}- /// Observes replacement of the exact installed Page that admitted work.- pub(crate) fn register_target_page_residence_observer_for_session(+ /// Captures the lifetime of the concrete Page attachment currently+ /// addressed by `session_id`.+ ///+ /// The returned token is owned by that attachment rather than by a numeric+ /// slot generation. Moving the whole target slot preserves it; replacing+ /// or clearing the installed Page terminates it directly.+ pub(crate) fn capture_target_page_residence_token_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())+ ) -> Option<crate::conn::TargetPageResidenceToken> {+ self.runtime_session_owner_slot_mut(session_id)+ .ok()?+ .page_slot_mut()+ .page_residence_token()}/// Captures the exact protocol attachment currently addressing a Page.diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rsindex e246970a4..2711f21b5 100644--- a/moli-protocol/src/conn/state/mod.rs+++ b/moli-protocol/src/conn/state/mod.rs@@ -12,7 +12,7 @@ mod inspector;mod javascript_dialog;mod navigation;mod navigation_outcome;-mod page_residence_observer;+mod page_residence_token;mod page_resource;mod page_slot;mod parking;@@ -57,9 +57,7 @@ pub(crate) use devtools_session::{pub(crate) use document_lifecycle_observer::{RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,};-pub(crate) use page_residence_observer::{- TargetPageResidenceObservation, TargetPageResidenceObserver,-};+pub(crate) use page_residence_token::{TargetPageResidenceObservation, TargetPageResidenceToken};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.rsdeleted file mode 100644index bb271b4c9..000000000--- a/moli-protocol/src/conn/state/page_residence_observer.rs+++ /dev/null@@ -1,94 +0,0 @@-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_residence_token.rs b/moli-protocol/src/conn/state/page_residence_token.rsnew file mode 100644index 000000000..c00e23252--- /dev/null+++ b/moli-protocol/src/conn/state/page_residence_token.rs@@ -0,0 +1,114 @@+use tokio::sync::watch;++use super::TargetPageAttachmentId;++/// Terminal result of observing one exact installed Page residence.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum TargetPageResidenceObservation {+ Superseded,+ Unavailable,+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+enum TargetPageResidenceState {+ Live(TargetPageAttachmentId),+ Superseded(TargetPageAttachmentId),+}++/// Slot-owned lifetime for one concrete Page attachment.+///+/// Dropping this publisher without first superseding it means the owning slot+/// disappeared unexpectedly. Replacing or clearing the installed Page must+/// explicitly call `supersede`, which resolves every token for that attachment.+#[derive(Debug)]+pub(crate) struct TargetPageResidencePublisher {+ sender: watch::Sender<TargetPageResidenceState>,+}++impl TargetPageResidencePublisher {+ pub(crate) fn new(attachment_id: TargetPageAttachmentId) -> Self {+ let (sender, _receiver) = watch::channel(TargetPageResidenceState::Live(attachment_id));+ Self { sender }+ }++ pub(crate) fn token(&self) -> TargetPageResidenceToken {+ TargetPageResidenceToken {+ receiver: self.sender.subscribe(),+ }+ }++ pub(crate) fn supersede(self) {+ let attachment_id = match *self.sender.borrow() {+ TargetPageResidenceState::Live(attachment_id)+ | TargetPageResidenceState::Superseded(attachment_id) => attachment_id,+ };+ self.sender+ .send_replace(TargetPageResidenceState::Superseded(attachment_id));+ }+}++/// Move-only lifetime token for one concrete installed Page attachment.+///+/// Moving the target's whole Page slot preserves this token. Replacing or+/// clearing that attachment resolves it as `Superseded`; losing the owning slot+/// without an explicit lifecycle transition resolves it as `Unavailable`.+#[derive(Debug)]+pub(crate) struct TargetPageResidenceToken {+ receiver: watch::Receiver<TargetPageResidenceState>,+}++impl TargetPageResidenceToken {+ pub(crate) async fn wait(mut self) -> TargetPageResidenceObservation {+ loop {+ match *self.receiver.borrow_and_update() {+ TargetPageResidenceState::Live(_) => {}+ TargetPageResidenceState::Superseded(_) => {+ return TargetPageResidenceObservation::Superseded;+ }+ }+ if self.receiver.changed().await.is_err() {+ return TargetPageResidenceObservation::Unavailable;+ }+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn attachment_id(raw: u64) -> TargetPageAttachmentId {+ TargetPageAttachmentId::from_raw_for_test(raw)+ }++ #[tokio::test]+ async fn explicit_supersede_resolves_every_attachment_token() {+ let publisher = TargetPageResidencePublisher::new(attachment_id(7));+ let first = publisher.token();+ let second = publisher.token();++ publisher.supersede();++ assert_eq!(+ first.wait().await,+ TargetPageResidenceObservation::Superseded+ );+ assert_eq!(+ second.wait().await,+ TargetPageResidenceObservation::Superseded+ );+ }++ #[tokio::test]+ async fn publisher_loss_reports_unavailable() {+ let publisher = TargetPageResidencePublisher::new(attachment_id(7));+ let token = publisher.token();++ drop(publisher);++ assert_eq!(+ token.wait().await,+ TargetPageResidenceObservation::Unavailable+ );+ }+}diff --git a/moli-protocol/src/conn/state/page_slot.rs b/moli-protocol/src/conn/state/page_slot.rsindex 1bd4cfc60..a99a4214b 100644--- a/moli-protocol/src/conn/state/page_slot.rs+++ b/moli-protocol/src/conn/state/page_slot.rs@@ -14,7 +14,7 @@ use super::document_lifecycle_observer::{RendererDocumentLifecycleObservation, RendererDocumentLifecycleObservationPublisher,RendererDocumentLifecycleObserver,};-use super::page_residence_observer::{TargetPageResidenceObservation, TargetPageResidenceObserver};+use super::page_residence_token::{TargetPageResidencePublisher, TargetPageResidenceToken};use super::{NavigationRequestId, RendererPageResidenceIdentity, TargetPageAttachmentId};#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]@@ -333,7 +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>>,+ page_residence_publisher: Option<TargetPageResidencePublisher>,pending_navigation_request: Option<PendingNavigationRequest>,committed_document_navigation: Option<DocumentNavigationToken>,renderer_document_lifecycle: RendererDocumentLifecycleProtocolState,@@ -484,7 +484,9 @@ impl TargetPageSlot {self.loaded_page_absence_reason = absence_reason;self.page_attachment_id = None;}- std::mem::replace(&mut self.loaded_page, page)+ let previous = std::mem::replace(&mut self.loaded_page, page);+ self.supersede_page_residence();+ previous}pub(crate) fn replace_loaded_page(&mut self, page: Option<Page>) -> Option<Page> {@@ -504,19 +506,18 @@ 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,- );- }+ pub(crate) fn page_residence_token(&mut self) -> Option<TargetPageResidenceToken> {+ let attachment_id = self.page_attachment_id?;let publisher = self- .loaded_page_generation_publisher- .get_or_insert_with(|| watch::channel(self.loaded_page_generation).0);- TargetPageResidenceObserver::new(expected_generation, publisher.subscribe())+ .page_residence_publisher+ .get_or_insert_with(|| TargetPageResidencePublisher::new(attachment_id));+ Some(publisher.token())+ }++ fn supersede_page_residence(&mut self) {+ if let Some(publisher) = self.page_residence_publisher.take() {+ publisher.supersede();+ }}fn advance_loaded_page_generation(&mut self) {@@ -524,7 +525,6 @@ impl TargetPageSlot {RendererDocumentLifecycleObservation::Superseded,);self.loaded_page_generation = self.loaded_page_generation.wrapping_add(1);- self.publish_loaded_page_generation();}#[cfg(test)]@@ -541,19 +541,16 @@ impl TargetPageSlot {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)]pub(crate) fn set_page_attachment_id_for_test(&mut self, raw: u64) -> TargetPageAttachmentId {let attachment_id = TargetPageAttachmentId::from_raw_for_test(raw);+ let attachment_changed = self.page_attachment_id != Some(attachment_id);self.page_attachment_id = Some(attachment_id);+ if attachment_changed {+ self.supersede_page_residence();+ }attachment_id}@@ -1360,6 +1357,42 @@ impl TargetPageSlot {}}+#[cfg(test)]+mod page_residence_tests {+ use std::{+ future::Future,+ task::{Context, Poll, Waker},+ };++ use super::*;+ use crate::conn::TargetPageResidenceObservation;++ #[test]+ fn attachment_token_ignores_generation_and_terminates_on_attachment_replacement() {+ let mut slot = TargetPageSlot::default();+ slot.set_page_attachment_id_for_test(91);+ let token = slot+ .page_residence_token()+ .expect("the installed attachment should expose its lifetime token");++ slot.bump_loaded_page_generation();++ let mut wait = Box::pin(token.wait());+ let mut context = Context::from_waker(Waker::noop());+ assert!(+ matches!(wait.as_mut().poll(&mut context), Poll::Pending),+ "changing only the slot generation must not terminate an attachment token"+ );++ slot.set_page_attachment_id_for_test(92);++ assert!(matches!(+ wait.as_mut().poll(&mut context),+ Poll::Ready(TargetPageResidenceObservation::Superseded)+ ));+ }+}+#[cfg(test)]mod pending_renderer_page_tests {use super::*;diff --git a/moli-protocol/src/domains/input.rs b/moli-protocol/src/domains/input.rsindex 9cb4d5040..baa993ab0 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, TargetPageResidenceObservation, TargetPageResidenceObserver,+ TargetPageResidenceIdentity, TargetPageResidenceObservation, TargetPageResidenceToken,};use crate::devtools_runtime::{DevToolsCommand, DevToolsCommandContext, DevToolsCommandResult,@@ -61,7 +61,7 @@ pub(crate) struct PendingInputCommandDispatch {command_id: Option<u64>,session_id: Option<String>,owner: TargetPageResidenceIdentity,- owner_observer: Option<TargetPageResidenceObserver>,+ page_residence_token: Option<TargetPageResidenceToken>,kind: PendingInputCommandKind,pending: PendingInputOperation,}@@ -149,16 +149,16 @@ enum RendererInputWaitOutcome<T> {async fn wait_for_renderer_input_or_page_replacement<T>(completion: impl std::future::Future<Output = T>,- owner_observer: Option<TargetPageResidenceObserver>,+ page_residence_token: Option<TargetPageResidenceToken>,) -> RendererInputWaitOutcome<T> {- let Some(owner_observer) = owner_observer else {+ let Some(page_residence_token) = page_residence_token else {return RendererInputWaitOutcome::Completed(completion.await);};tokio::pin!(completion);tokio::select! {biased;result = &mut completion => RendererInputWaitOutcome::Completed(result),- observation = owner_observer.wait() => {+ observation = page_residence_token.wait() => {RendererInputWaitOutcome::PageResidence(observation)}}@@ -174,7 +174,7 @@ impl PendingInputCommandDispatch {PendingInputOperation::Page(pending) => {match wait_for_renderer_input_or_page_replacement(pending.wait(),- self.owner_observer,+ self.page_residence_token,).await{@@ -193,7 +193,7 @@ impl PendingInputCommandDispatch {PendingInputOperation::RendererAckHeldForTest => {match wait_for_renderer_input_or_page_replacement(std::future::pending::<std::convert::Infallible>(),- self.owner_observer,+ self.page_residence_token,).await{@@ -223,7 +223,7 @@ impl PendingInputCommandDispatch {// gives lifecycle smoke tests a deterministic outstanding callback;// public CDP intentionally cannot pause that callback while also// scheduling a replacement of the same Page owner.- if !self.kind.uses_renderer_host_ack_cleanup() || self.owner_observer.is_none() {+ if !self.kind.uses_renderer_host_ack_cleanup() || self.page_residence_token.is_none() {return false;}self.pending = PendingInputOperation::RendererAckHeldForTest;@@ -1015,17 +1015,22 @@ fn start_page_input_command(let owner = conn.target_page_residence_identity_for_session(command_session_id).ok_or_else(PendingInputCommandStartError::no_document_loaded)?;+ let page_residence_token = if kind.uses_renderer_host_ack_cleanup() {+ Some(+ conn.capture_target_page_residence_token_for_session(command_session_id)+ .ok_or_else(PendingInputCommandStartError::no_document_loaded)?,+ )+ } else {+ None+ };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,+ page_residence_token,kind,pending: PendingInputOperation::Page(pending),}))diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rsindex 033474ac4..752c3a2fa 100644--- a/moli-protocol/src/domains/input/tests.rs+++ b/moli-protocol/src/domains/input/tests.rs@@ -288,7 +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,+ page_residence_token: None,kind: PendingInputCommandKind::DispatchMouseEvent,pending: PendingInputOperation::Page(pending),}@@ -331,16 +331,19 @@ async fn pending_mouse_event_acknowledges_when_page_is_replaced_before_renderer_.conn.target_page_residence_identity_for_session(None).expect("the original Page should have a residence identity");- let observer = ctx+ let page_residence_token = ctx.conn- .register_target_page_residence_observer_for_session(None, &original_owner);+ .capture_target_page_residence_token_for_session(None)+ .expect("the original Page should expose its attachment lifetime");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 wait = wait_for_renderer_input_or_page_replacement(+ std::future::pending::<()>(),+ Some(page_residence_token),+ );let outcome = tokio::time::timeout(std::time::Duration::from_secs(1), wait).await.expect("Page replacement should settle the pending input wait");@@ -370,13 +373,10 @@ async fn completed_renderer_ack_wins_when_page_replacement_is_already_observablelet 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+ let page_residence_token = ctx.conn- .register_target_page_residence_observer_for_session(None, &original_owner);+ .capture_target_page_residence_token_for_session(None)+ .expect("the original Page should expose its attachment lifetime");ctx.install_navigation_fixture_for_session_owner("data:text/html,<body>replacement-after-ack</body>",None,@@ -385,7 +385,7 @@ async fn completed_renderer_ack_wins_when_page_replacement_is_already_observablelet outcome = wait_for_renderer_input_or_page_replacement(std::future::ready("renderer-ack"),- Some(observer),+ Some(page_residence_token),).await;assert!(matches!(diff --git a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rsindex 149b059cd..e9e95da42 100644--- a/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs+++ b/moli-protocol/src/domains/target/tests/tests_cdp_chromium_imports/p0_input.rs@@ -3,7 +3,11 @@ use super::super::*;use super::support::CdpPageHarness;use crate::conn::CdpCommandTaskStep;use serde_json::json;-use std::time::Duration;+use std::{+ future::Future,+ task::{Context, Poll, Waker},+ time::Duration,+};async fn expect_page_replacement_cleans_up_pending_input_ack(ctx: &mut TestContext,@@ -17,6 +21,12 @@ async fn expect_page_replacement_cleans_up_pending_input_ack(.conn.target_page_residence_identity_for_session(Some(&page.session_id)).expect("the input command should have a Page owner");+ let original_attachment = ctx+ .conn+ .runtime_session_owner_slot(Some(&page.session_id))+ .expect("the input command should route to a Page slot")+ .page_attachment_id()+ .expect("the input command should have a concrete Page attachment");let raw = json!({"id": command_id,"method": method,@@ -37,10 +47,9 @@ async fn expect_page_replacement_cleans_up_pending_input_ack();let mut completion = Box::pin(pending.wait());+ let mut poll_context = Context::from_waker(Waker::noop());assert!(- tokio::time::timeout(Duration::from_millis(25), &mut completion)- .await- .is_err(),+ matches!(completion.as_mut().poll(&mut poll_context), Poll::Pending),"{method} must not reply before either its renderer ACK or Page replacement");@@ -53,7 +62,14 @@ async fn expect_page_replacement_cleans_up_pending_input_ack(.conn.target_page_residence_identity_for_session(Some(&page.session_id)).expect("the replacement should install a Page owner");+ let replacement_attachment = ctx+ .conn+ .runtime_session_owner_slot(Some(&page.session_id))+ .expect("the replacement should route to a Page slot")+ .page_attachment_id()+ .expect("the replacement should have a concrete Page attachment");assert_ne!(original_owner, replacement_owner);+ assert_ne!(original_attachment, replacement_attachment);let completed = tokio::time::timeout(Duration::from_secs(5), &mut completion).await