Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
perf(layout): stream point hit candidates before ordering results
ldm029b5a36d5fe1
diff --git a/moli-layout/src/layout_tree/hit_test.rs b/moli-layout/src/layout_tree/hit_test.rsindex 4918612b9..4aa9a256d 100644--- a/moli-layout/src/layout_tree/hit_test.rs+++ b/moli-layout/src/layout_tree/hit_test.rs@@ -1,4 +1,4 @@-//! Temporary hit-test candidates and caret projections derived per query.+//! Streaming hit-test candidates and caret projections derived per query.use std::{collections::HashSet, fmt::Debug, hash::Hash};@@ -27,7 +27,7 @@ impl<N: Copy> LayoutPaintedSurfaceHit<N> {}}-/// One front-to-back hit-test candidate.+/// One hit-test candidate in fragment storage order.#[derive(Clone, Debug, PartialEq)]struct LayoutHitTestEntry<N> {source: N,@@ -91,9 +91,18 @@ whereviewport_point: LayoutPoint,ignore_pointer_events_none: bool,) -> Option<LayoutHit<N>> {- self.hit_test_entries().into_iter().find_map(|entry| {- self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)- })+ let mut foremost: Option<LayoutHit<N>> = None;+ for entry in self.hit_test_entries() {+ if foremost.is_some_and(|hit| hit.paint_order >= Some(entry.paint_order)) {+ continue;+ }+ if let Some(hit) =+ self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)+ {+ foremost = Some(hit);+ }+ }+ foremost}pub fn hit_test_all(@@ -101,17 +110,15 @@ whereviewport_point: LayoutPoint,ignore_pointer_events_none: bool,) -> Vec<LayoutHit<N>> {+ let mut hits = self+ .hit_test_entries()+ .filter_map(|entry| {+ self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)+ })+ .collect::<Vec<_>>();+ hits.sort_by_key(|hit| std::cmp::Reverse(hit.paint_order));let mut seen = HashSet::new();- let mut hits = Vec::new();- for entry in self.hit_test_entries() {- let Some(hit) = self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)- else {- continue;- };- if seen.insert(hit.source) {- hits.push(hit);- }- }+ hits.retain(|hit| seen.insert(hit.source));hits}@@ -126,7 +133,6 @@ where) -> Vec<LayoutPaintedSurfaceHit<N>> {let mut hits = self.hit_test_entries()- .into_iter().filter_map(|entry| {self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none).map(LayoutPaintedSurfaceHit::Dom)@@ -240,7 +246,10 @@ where}pub fn caret_position(&self, viewport_point: LayoutPoint) -> Option<LayoutCaretPosition<N>> {- let entries = self.hit_test_entries();+ // Caret distance ties follow front-to-back order. Keep that ordering+ // local to the caret query rather than sorting every point query.+ let mut entries = self.hit_test_entries().collect::<Vec<_>>();+ entries.sort_by_key(|entry| std::cmp::Reverse(entry.paint_order));let top_entry = entries.iter().find(|entry| self.hit_for_entry(entry, viewport_point, true).is_some())?;@@ -285,40 +294,35 @@ where})}- /// Builds the front-to-back hit candidates for one query.+ /// Streams candidates directly from canonical geometry, without retaining+ /// an index or duplicating the fragment set into a query-local vector.///- /// Paint order, source provenance, transforms, and clips are canonical- /// tree data. The duplicated candidate vector is deliberately temporary.- fn hit_test_entries(&self) -> Vec<LayoutHitTestEntry<N>> {- let mut entries = self- .fragments- .iter()- .filter_map(|fragment| {- let paint_order = fragment.paint_order?;- let (box_id, is_text) = match fragment.kind {- LayoutFragmentKind::Box { box_id }- | LayoutFragmentKind::InlineBox { box_id, .. } => (box_id, false),- LayoutFragmentKind::Text { box_id, .. } => (box_id, true),- LayoutFragmentKind::Line { .. } => return None,- };- let layout_box = self.boxes.get(box_id.index())?;- if !layout_box.visible {- return None;- }- Some(LayoutHitTestEntry {- source: layout_box.hit_source?,- fragment: fragment.id,- coordinate_space: fragment.coordinate_space,- clip_chain: fragment.clip_chain,- local_rect: fragment.rect,- paint_order,- is_text,- pointer_events: layout_box.pointer_events,- })+ /// Fragment storage order is not paint order; callers select or sort by+ /// the explicit paint ordinal only after resolving geometric hits.+ fn hit_test_entries(&self) -> impl Iterator<Item = LayoutHitTestEntry<N>> + '_ {+ self.fragments.iter().filter_map(|fragment| {+ let paint_order = fragment.paint_order?;+ let (box_id, is_text) = match fragment.kind {+ LayoutFragmentKind::Box { box_id }+ | LayoutFragmentKind::InlineBox { box_id, .. } => (box_id, false),+ LayoutFragmentKind::Text { box_id, .. } => (box_id, true),+ LayoutFragmentKind::Line { .. } => return None,+ };+ let layout_box = self.boxes.get(box_id.index())?;+ if !layout_box.visible {+ return None;+ }+ Some(LayoutHitTestEntry {+ source: layout_box.hit_source?,+ fragment: fragment.id,+ coordinate_space: fragment.coordinate_space,+ clip_chain: fragment.clip_chain,+ local_rect: fragment.rect,+ paint_order,+ is_text,+ pointer_events: layout_box.pointer_events,})- .collect::<Vec<_>>();- entries.sort_by_key(|entry| std::cmp::Reverse(entry.paint_order));- entries+ })}fn caret_position_for_text_entry(diff --git a/moli-layout/tests/phase5_output_contract.rs b/moli-layout/tests/phase5_output_contract.rsindex 1fcc438b0..300a1c654 100644--- a/moli-layout/tests/phase5_output_contract.rs+++ b/moli-layout/tests/phase5_output_contract.rs@@ -2874,6 +2874,92 @@ fn transforms_and_semantic_paint_order_share_the_hit_test_projection() {);}+#[test]+fn point_hits_select_paint_order_before_deduplicating_sources() {+ let source = Source(vec![+ Node::element("root", vec![2, 1, 3]),+ Node::element("foremost", Vec::new()),+ Node::element("back", Vec::new()),+ Node::element("middle", Vec::new()),+ ]);+ let mut styles = Styles::default();+ styles+ .0+ .insert(0, fixed_size(LayoutDisplay::Block, 200.0, 150.0));+ for (source, z_index) in [(1, 3), (2, 1), (3, 2)] {+ styles.0.insert(+ source,+ resolved(+ LayoutDisplay::Block,+ Style {+ position: Position::Absolute,+ inset: Rect {+ left: length(20.0),+ top: length(20.0),+ right: LengthPercentageAuto::auto(),+ bottom: LengthPercentageAuto::auto(),+ },+ size: Size {+ width: length(80.0),+ height: length(80.0),+ },+ ..Style::default()+ },+ )+ .with_position(LayoutPosition::Absolute)+ .with_z_index(z_index),+ );+ }+ let mut output = build(&source, &mut styles);+ let point = LayoutPoint::new(30.0, 30.0);+ let hit = output.hit_test(point, false).unwrap();+ assert_eq!(hit.source, 1, "the last stored box is not foremost");++ // Generated boxes can retarget to the same DOM source. The lower box is+ // stored first, but deduplication must retain the foremost fragment.+ output+ .tree+ .boxes+ .iter_mut()+ .find(|layout_box| layout_box.hit_source == Some(2))+ .unwrap()+ .hit_source = Some(1);+ let hits = output.hit_test_all(point, false);+ assert_eq!(+ hits.iter().map(|hit| hit.source).collect::<Vec<_>>(),+ [1, 3, 0]+ );+ assert_eq!(hits[0].fragment, hit.fragment);+ assert_eq!(output.hit_test(point, false), Some(hits[0]));+ let surfaces = output.painted_surface_hits(point, false);+ assert!(+ surfaces+ .windows(2)+ .all(|pair| pair[0].paint_order() >= pair[1].paint_order())+ );++ for layout_box in &mut output.tree.boxes {+ if layout_box.hit_source == Some(1) {+ layout_box.geometry.pointer_events = false;+ }+ }+ assert_eq!(output.hit_test(point, false).unwrap().source, 3);+ assert_eq!(output.hit_test(point, true).unwrap().source, 1);+ assert_eq!(+ output+ .hit_test_all(point, false)+ .iter()+ .map(|hit| hit.source)+ .collect::<Vec<_>>(),+ [3, 0]+ );+ assert!(+ output+ .hit_test(LayoutPoint::new(-1.0, -1.0), false)+ .is_none()+ );+}+#[test]fn transformed_hit_retains_exact_local_content_box_and_inverse_mapping() {let source = Source(vec![