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): reject point misses before shared clip checks
ldm061669e8740e7
diff --git a/moli-layout/src/layout_tree/hit_test.rs b/moli-layout/src/layout_tree/hit_test.rsindex 4aa9a256d..aca3f12bf 100644--- a/moli-layout/src/layout_tree/hit_test.rs+++ b/moli-layout/src/layout_tree/hit_test.rs@@ -4,9 +4,9 @@ use std::{collections::HashSet, fmt::Debug, hash::Hash};use super::{model::{- LayoutBoxModel, LayoutClipChainId, LayoutCoordinateSpaceId, LayoutFragmentId,- LayoutFragmentKind, LayoutOutputBoxId, LayoutPoint, LayoutQuad, LayoutRect,- LayoutTransform2D,+ LayoutBoxModel, LayoutClipChainId, LayoutClipNode, LayoutCoordinateSpaceId,+ LayoutFragmentId, LayoutFragmentKind, LayoutOutputBoxId, LayoutPoint, LayoutQuad,+ LayoutRect, LayoutTransform2D,},tree::FrozenLayoutTree,};@@ -91,14 +91,16 @@ whereviewport_point: LayoutPoint,ignore_pointer_events_none: bool,) -> Option<LayoutHit<N>> {+ if !self.viewport.contains(viewport_point) {+ return None;+ }+ let mut clips = PointClipQuery::new(self, viewport_point);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)- {+ if let Some(hit) = self.hit_for_entry(&entry, ignore_pointer_events_none, &mut clips) {foremost = Some(hit);}}@@ -110,11 +112,13 @@ whereviewport_point: LayoutPoint,ignore_pointer_events_none: bool,) -> Vec<LayoutHit<N>> {+ if !self.viewport.contains(viewport_point) {+ return Vec::new();+ }+ let mut clips = PointClipQuery::new(self, viewport_point);let mut hits = self.hit_test_entries()- .filter_map(|entry| {- self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)- })+ .filter_map(|entry| self.hit_for_entry(&entry, ignore_pointer_events_none, &mut clips)).collect::<Vec<_>>();hits.sort_by_key(|hit| std::cmp::Reverse(hit.paint_order));let mut seen = HashSet::new();@@ -131,10 +135,14 @@ whereviewport_point: LayoutPoint,ignore_pointer_events_none: bool,) -> Vec<LayoutPaintedSurfaceHit<N>> {+ if !self.viewport.contains(viewport_point) {+ return Vec::new();+ }+ let mut clips = PointClipQuery::new(self, viewport_point);let mut hits = self.hit_test_entries().filter_map(|entry| {- self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)+ self.hit_for_entry(&entry, ignore_pointer_events_none, &mut clips).map(LayoutPaintedSurfaceHit::Dom)}).chain(@@ -246,13 +254,17 @@ where}pub fn caret_position(&self, viewport_point: LayoutPoint) -> Option<LayoutCaretPosition<N>> {+ if !self.viewport.contains(viewport_point) {+ return None;+ }+ let mut clips = PointClipQuery::new(self, viewport_point);// 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())?;+ .find(|entry| self.hit_for_entry(entry, true, &mut clips).is_some())?;let top_box = self.fragment_box_id(top_entry.fragment)?;let text_entry = entries.iter()@@ -439,23 +451,23 @@ wherefn hit_for_entry(&self,entry: &LayoutHitTestEntry<N>,- viewport_point: LayoutPoint,ignore_pointer_events_none: bool,+ clips: &mut PointClipQuery<'_, N>,) -> Option<LayoutHit<N>> {if !ignore_pointer_events_none && !entry.pointer_events {return None;}- if !self.point_passes_clip_chain(viewport_point, entry.clip_chain) {- return None;- }let inverse = self.coordinate_space(entry.coordinate_space)?.local_to_viewport.inverse()?;- let local_point = inverse.map_point(viewport_point);+ let local_point = inverse.map_point(clips.point);if !entry.local_rect.contains(local_point) {return None;}+ if !clips.passes(entry.clip_chain) {+ return None;+ }let local_content_box = self.fragment(entry.fragment).and_then(|fragment| fragment.box_model.map(|model| model.content))@@ -480,6 +492,12 @@ impl<N> FrozenLayoutTree<N>whereN: Copy + Debug + Eq + Hash,{+ fn point_passes_clip(&self, viewport_point: LayoutPoint, node: &LayoutClipNode) -> bool {+ self.coordinate_space(node.coordinate_space)+ .and_then(|space| space.local_to_viewport.inverse())+ .is_some_and(|inverse| node.rect.contains(inverse.map_point(viewport_point)))+ }+fn point_passes_clip_chain(&self,viewport_point: LayoutPoint,@@ -489,13 +507,7 @@ wherelet Some(node) = self.clip_chain.get(id.index()) else {return false;};- let Some(inverse) = self- .coordinate_space(node.coordinate_space)- .and_then(|space| space.local_to_viewport.inverse())- else {- return false;- };- if !node.rect.contains(inverse.map_point(viewport_point)) {+ if !self.point_passes_clip(viewport_point, node) {return false;}clip = node.parent;@@ -503,3 +515,122 @@ wheretrue}}++/// Scratch for exactly one viewport point. Shared clip ancestors are checked+/// once, and nothing survives the query or changes the retained tree.+struct PointClipQuery<'a, N: Copy + Debug + Eq + Hash> {+ tree: &'a FrozenLayoutTree<N>,+ point: LayoutPoint,+ results: Vec<Option<bool>>,+}++impl<'a, N: Copy + Debug + Eq + Hash> PointClipQuery<'a, N> {+ fn new(tree: &'a FrozenLayoutTree<N>, point: LayoutPoint) -> Self {+ Self {+ tree,+ point,+ results: Vec::new(),+ }+ }++ fn passes(&mut self, clip: Option<LayoutClipChainId>) -> bool {+ if clip.is_none() {+ return true;+ }+ // Allocate only after a candidate's local rectangle contains the point.+ if self.results.is_empty() {+ self.results.resize(self.tree.clip_chain.len(), None);+ }+ let mut current = clip;+ let passed = loop {+ let Some(id) = current else {+ break true;+ };+ let Some(result) = self.results.get(id.index()) else {+ break false;+ };+ if let Some(result) = result {+ break *result;+ }+ let node = &self.tree.clip_chain[id.index()];+ if !self.tree.point_passes_clip(self.point, node) {+ self.results[id.index()] = Some(false);+ break false;+ }+ current = node.parent;+ };+ // Propagate the chain result along the visited prefix. Walking it+ // twice avoids recursion or a second allocation for deep clip chains.+ current = clip;+ while let Some(id) = current {+ let Some(result) = self.results.get_mut(id.index()) else {+ break;+ };+ if result.is_some() {+ break;+ }+ *result = Some(passed);+ current = self.tree.clip_chain[id.index()].parent;+ }+ passed+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::{FrozenCoordinateSpace, LayoutSize, LayoutViewport};++ #[test]+ fn shared_clip_results_are_scoped_to_one_point() {+ let root = LayoutClipChainId::from_index(0);+ let broad = LayoutClipChainId::from_index(1);+ let narrow = LayoutClipChainId::from_index(2);+ let tree = FrozenLayoutTree::new(+ 0_u8,+ LayoutViewport::new(100, 100, 1.0),+ LayoutPoint::ZERO,+ LayoutSize::new(100.0, 100.0),+ LayoutOutputBoxId::from_index(0),+ Vec::new(),+ Vec::new(),+ Vec::new(),+ FrozenCoordinateSpace {+ owner: None,+ local_to_viewport: LayoutTransform2D::IDENTITY,+ local_to_viewport_ignoring_css_transforms: LayoutTransform2D::IDENTITY,+ },+ [(None, 100.0), (Some(root), 200.0), (Some(root), 40.0)]+ .into_iter()+ .map(|(parent, size)| LayoutClipNode {+ parent,+ owner: None,+ coordinate_space: LayoutCoordinateSpaceId::from_index(0),+ rect: LayoutRect::new(0.0, 0.0, size, size),+ })+ .collect(),+ Vec::new(),+ true,+ );+ let mut query = PointClipQuery::new(&tree, LayoutPoint::new(25.0, 25.0));+ assert!(query.results.is_empty());+ assert!(query.passes(Some(broad)));+ assert_eq!(query.results, [Some(true), Some(true), None]);+ assert!(query.passes(Some(narrow)));+ assert_eq!(query.results, [Some(true), Some(true), Some(true)]);++ for point in [+ LayoutPoint::new(75.0, 25.0),+ LayoutPoint::new(150.0, 25.0),+ LayoutPoint::new(f32::NAN, 0.0),+ ] {+ let mut query = PointClipQuery::new(&tree, point);+ for clip in [Some(broad), Some(narrow), Some(root), None, Some(broad)] {+ assert_eq!(+ query.passes(clip),+ tree.point_passes_clip_chain(point, clip)+ );+ }+ }+ }+}diff --git a/moli-layout/src/layout_tree/model.rs b/moli-layout/src/layout_tree/model.rsindex fbdb0c589..aefe19542 100644--- a/moli-layout/src/layout_tree/model.rs+++ b/moli-layout/src/layout_tree/model.rs@@ -25,6 +25,15 @@ impl LayoutViewport {device_pixel_ratio,}}++ /// Tests CSS coordinates against the half-open viewport, excluding NaN+ /// and infinite points without walking any layout geometry.+ pub fn contains(self, point: LayoutPoint) -> bool {+ point.x >= 0.0+ && point.y >= 0.0+ && f64::from(point.x) < f64::from(self.css_width)+ && f64::from(point.y) < f64::from(self.css_height)+ }}/// A two-dimensional point in CSS pixels.@@ -451,6 +460,27 @@ pub struct LayoutFragment {mod tests {use super::*;+ #[test]+ fn viewport_contains_rejects_outside_edges_and_non_finite_points() {+ let viewport = LayoutViewport::new(100, 80, 2.0);+ assert!(viewport.contains(LayoutPoint::ZERO));+ assert!(viewport.contains(LayoutPoint::new(99.5, 79.5)));+ for point in [+ LayoutPoint::new(-1.0, 0.0),+ LayoutPoint::new(0.0, -1.0),+ LayoutPoint::new(100.0, 0.0),+ LayoutPoint::new(0.0, 80.0),+ LayoutPoint::new(f32::NAN, 0.0),+ LayoutPoint::new(0.0, f32::NAN),+ LayoutPoint::new(f32::INFINITY, 0.0),+ LayoutPoint::new(0.0, f32::NEG_INFINITY),+ ] {+ assert!(!viewport.contains(point), "{point:?}");+ }+ assert!(!LayoutViewport::new(0, 80, 1.0).contains(LayoutPoint::ZERO));+ assert!(!LayoutViewport::new(100, 0, 1.0).contains(LayoutPoint::ZERO));+ }+#[test]fn affine_concatenation_and_inverse_round_trip() {let transform = LayoutTransform2D::translation(20.0, 30.0)diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout.rs b/moli-renderer-v8/src/native_bridge/context_host/layout.rsindex 47b34531d..c32777a90 100644--- a/moli-renderer-v8/src/native_bridge/context_host/layout.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/layout.rs@@ -476,6 +476,15 @@ impl JsContextHost {|candidate| self.offset_parent_candidate_is_exposed(*source, candidate),),),+ // Layout preparation still runs, but an out-of-viewport point+ // needs no fragment walk. Use the current request's viewport+ // even when ordinary reads reuse an older, larger tree.+ LayoutQuery::HitTest { point, .. } if !viewport.contains(*point) => {+ LayoutQueryAnswer::HitTest(None)+ }+ LayoutQuery::HitTestAll { point, .. } if !viewport.contains(*point) => {+ LayoutQueryAnswer::HitTestAll(Vec::new())+ }_ => tree.answer_query(query),}).collect();diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rsindex 6f94be9ee..358ff8e4f 100644--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs@@ -2421,6 +2421,65 @@ fn parser_coalesced_text_notifies_main_and_child_mutation_observers() {serde_json::json!([expected, expected]),);}+#[test]+fn point_queries_use_current_viewport_bounds_with_reused_geometry() {+ use moli_layout::{+ GeometryProvider, LayoutFlushReason, LayoutPoint, LayoutQuery, LayoutQueryAnswer,+ LayoutQueryBatch, LayoutViewport,+ };++ let mut vm = new_parsed_test_vm(+ "https://point-query-viewport.test/",+ "<html><body style='margin:0'><div style='width:300px;height:100px'></div></body></html>",+ );+ let before = vm.layout_pass_observability_for_test().1;+ let batch = LayoutQueryBatch::new(vec![+ LayoutQuery::HitTest {+ point: LayoutPoint::new(-1.0, -1.0),+ ignore_pointer_events_none: false,+ },+ LayoutQuery::HitTestAll {+ point: LayoutPoint::new(-1.0, -1.0),+ ignore_pointer_events_none: false,+ },+ LayoutQuery::HitTest {+ point: LayoutPoint::new(150.0, 20.0),+ ignore_pointer_events_none: false,+ },+ LayoutQuery::HitTestAll {+ point: LayoutPoint::new(150.0, 20.0),+ ignore_pointer_events_none: false,+ },+ ]);+ for (width, expect_hit) in [(320, true), (100, false), (320, true)] {+ let answers = GeometryProvider::answer(+ &mut *vm,+ LayoutFlushReason::HitTest,+ LayoutViewport::new(width, 200, 1.0),+ &batch,+ )+ .expect("point query batch");+ assert_eq!(answers.answers[0], LayoutQueryAnswer::HitTest(None));+ assert_eq!(+ answers.answers[1],+ LayoutQueryAnswer::HitTestAll(Vec::new())+ );+ assert_eq!(+ matches!(answers.answers[2], LayoutQueryAnswer::HitTest(Some(_))),+ expect_hit+ );+ let LayoutQueryAnswer::HitTestAll(hits) = &answers.answers[3] else {+ panic!("expected hit list")+ };+ assert_eq!(!hits.is_empty(), expect_hit);+ assert_eq!(+ vm.layout_pass_observability_for_test().1,+ before + 1,+ "cold queries still prepare layout; later viewport checks reuse it"+ );+ }+}+#[test]fn document_point_queries_parse_webidl_coordinates() {let mut vm = new_parsed_test_vm(