Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat: implement default wheel scrolling
ldm0c09656bf3bfa
diff --git a/moli-layout/src/layout_tree/model.rs b/moli-layout/src/layout_tree/model.rsindex 0283617f2..a6aed75c2 100644--- a/moli-layout/src/layout_tree/model.rs+++ b/moli-layout/src/layout_tree/model.rs@@ -301,6 +301,8 @@ pub struct LayoutScrollExtent {pub minimum_offset: LayoutPoint,pub maximum_offset: LayoutPoint,pub is_scroll_container: bool,+ pub allows_user_scroll_x: bool,+ pub allows_user_scroll_y: bool,pub clips_overflow: bool,}diff --git a/moli-layout/src/layout_tree/query.rs b/moli-layout/src/layout_tree/query.rsindex 3de2899cc..1bb30ccdc 100644--- a/moli-layout/src/layout_tree/query.rs+++ b/moli-layout/src/layout_tree/query.rs@@ -52,6 +52,8 @@ pub struct LayoutElementMetrics<N> {pub scrollport: LayoutQuad,pub scrollable_overflow: LayoutQuad,pub is_scroll_container: bool,+ pub allows_user_scroll_x: bool,+ pub allows_user_scroll_y: bool,pub clips_overflow: bool,pub visible: bool,pub pointer_events: bool,diff --git a/moli-layout/src/layout_tree/source_query.rs b/moli-layout/src/layout_tree/source_query.rsindex cdc654aeb..29651dd05 100644--- a/moli-layout/src/layout_tree/source_query.rs+++ b/moli-layout/src/layout_tree/source_query.rs@@ -160,6 +160,8 @@ where.local_to_viewport.map_rect(extent.scrollable_overflow),is_scroll_container: extent.is_scroll_container,+ allows_user_scroll_x: extent.allows_user_scroll_x,+ allows_user_scroll_y: extent.allows_user_scroll_y,clips_overflow: extent.clips_overflow,visible: geometry.visible,pointer_events: geometry.pointer_events,diff --git a/moli-layout/src/projection.rs b/moli-layout/src/projection.rsindex c3619577d..9ee9ab645 100644--- a/moli-layout/src/projection.rs+++ b/moli-layout/src/projection.rs@@ -446,6 +446,10 @@ whereminimum_offset,maximum_offset,is_scroll_container,+ allows_user_scroll_x: is_root+ || self.world.boxes[index].style.allows_user_scroll_x(),+ allows_user_scroll_y: is_root+ || self.world.boxes[index].style.allows_user_scroll_y(),clips_overflow: self.world.boxes[index].style.clips_overflow(),});}diff --git a/moli-layout/src/style.rs b/moli-layout/src/style.rsindex 6d7e9d57c..45617cc32 100644--- a/moli-layout/src/style.rs+++ b/moli-layout/src/style.rs@@ -1496,6 +1496,14 @@ impl ResolvedLayoutStyle {.any(|overflow| matches!(overflow, taffy::Overflow::Hidden | taffy::Overflow::Scroll))}+ pub(crate) fn allows_user_scroll_x(&self) -> bool {+ self.taffy.overflow.x == taffy::Overflow::Scroll+ }++ pub(crate) fn allows_user_scroll_y(&self) -> bool {+ self.taffy.overflow.y == taffy::Overflow::Scroll+ }+pub(crate) fn text_leaf_from(parent: &Self) -> Self {Self {computed: parent.computed.clone(),diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rsindex 11676d518..639c38938 100644--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs@@ -98,6 +98,133 @@ async fn fetch_server_response((status, response[header_end + 4..].to_vec())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn websocket_cdp_mouse_wheel_scrolls_page_and_honors_prevent_default() {+ let (addr, server) = spawn_test_protocol_server().await;+ let (mut browser, _) =+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))+ .await+ .expect("connect browser websocket");+ let target_id = create_dynamic_target(&mut browser, 1).await;+ let mut page = connect_dynamic_page(addr, &target_id).await;++ let installed = send_cdp_command(+ &mut page,+ 1,+ "Runtime.evaluate",+ None,+ json!({+ "expression": r#"+ (() => {+ document.documentElement.style.margin = "0";+ document.body.style.margin = "0";+ document.body.innerHTML =+ '<div style="height: 500px"></div>' ++ '<div id="marker" style="height: 20px"></div>' ++ '<div style="height: 2500px"></div>';+ window.__wheelDeltas = [];+ window.addEventListener("wheel", event => {+ window.__wheelDeltas.push(event.deltaY);+ }, { capture: true });+ return document.getElementById("marker").getBoundingClientRect().top;+ })()+ "#,+ "returnByValue": true+ }),+ )+ .await;+ let marker_before = response_by_id(&installed, 1)["result"]["result"]["value"]+ .as_f64()+ .expect("initial marker top");++ let wheel = send_cdp_command(+ &mut page,+ 2,+ "Input.dispatchMouseEvent",+ None,+ json!({+ "type": "mouseWheel",+ "x": 10,+ "y": 10,+ "deltaX": 0,+ "deltaY": 120+ }),+ )+ .await;+ assert!(response_by_id(&wheel, 2).get("result").is_some());++ let scrolled = send_cdp_command(+ &mut page,+ 3,+ "Runtime.evaluate",+ None,+ json!({+ "expression": r#"+ ({+ scrollY,+ markerTop: document.getElementById("marker").getBoundingClientRect().top,+ wheelDeltas: window.__wheelDeltas+ })+ "#,+ "returnByValue": true+ }),+ )+ .await;+ let value = &response_by_id(&scrolled, 3)["result"]["result"]["value"];+ assert_eq!(value["scrollY"], json!(120));+ assert_eq!(+ value["markerTop"].as_f64().expect("scrolled marker top"),+ marker_before - 120.0+ );+ assert_eq!(value["wheelDeltas"], json!([120]));++ let cancel = send_cdp_command(+ &mut page,+ 4,+ "Runtime.evaluate",+ None,+ json!({+ "expression": r#"+ window.addEventListener("wheel", event => event.preventDefault(), {+ capture: true,+ passive: false+ })+ "#+ }),+ )+ .await;+ assert!(response_by_id(&cancel, 4).get("result").is_some());+ let canceled_wheel = send_cdp_command(+ &mut page,+ 5,+ "Input.dispatchMouseEvent",+ None,+ json!({+ "type": "mouseWheel",+ "x": 10,+ "y": 10,+ "deltaX": 0,+ "deltaY": 80+ }),+ )+ .await;+ assert!(response_by_id(&canceled_wheel, 5).get("result").is_some());+ let final_scroll = send_cdp_command(+ &mut page,+ 6,+ "Runtime.evaluate",+ None,+ json!({ "expression": "scrollY", "returnByValue": true }),+ )+ .await;+ assert_eq!(+ response_by_id(&final_scroll, 6)["result"]["result"]["value"],+ json!(120)+ );++ abort_test_cdp_server(server).await;+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn websocket_cdp_dynamic_page_routes_to_existing_target_owner() {let (addr, server) = spawn_test_protocol_server().await;diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rsindex 24d5a2c07..e2924a526 100644--- a/moli-renderer-v8/src/native_bridge/element.rs+++ b/moli-renderer-v8/src/native_bridge/element.rs@@ -401,7 +401,8 @@ pub(crate) use geometry::{observable_bounding_client_rect, observable_caret_position, observable_deep_hit_test,observable_event_offset, observable_geometry_batch, observable_hit_test_all,observable_input_hit_test, observable_scroll_adjusted_client_rect,- observable_sources_with_fragments, scroll_node_into_view_at_start,+ observable_sources_with_fragments, perform_wheel_scroll_default_action,+ queue_scroll_observable_effects, scroll_node_into_view_at_start,};pub(super) use global_attributes::{anchor_target_getter_function, anchor_target_setter_function, area_no_href_setter_function,diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rsindex 8e561350f..4eef52818 100644--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs@@ -19,7 +19,10 @@ pub(in crate::native_bridge) use metrics::{node_scroll_top_getter_function, node_scroll_top_setter_function,node_scroll_width_getter_function,};-pub(crate) use metrics::{scroll_node_into_view_at_start, scroll_node_into_view_if_needed};+pub(crate) use metrics::{+ perform_wheel_scroll_default_action, queue_scroll_observable_effects,+ scroll_node_into_view_at_start, scroll_node_into_view_if_needed,+};pub(crate) use provider::{observable_bounding_client_rect, observable_bounding_client_rects, observable_caret_position,observable_client_rects, observable_deep_hit_test, observable_element_metrics,diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rsindex 44c2462e4..fec27494e 100644--- a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs+++ b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs@@ -85,6 +85,7 @@ fn node_scroll_position_setter_for_object<'s>(};let value = value.clamp(minimum, maximum);let is_scrolling_element = runtime.dom_host().document_element_handle() == Some(handle);+ let document = runtime.dom_host().owner_document_handle(handle);let Some(element) = runtime.dom_host_mut().node_mut(handle)@@ -107,7 +108,7 @@ fn node_scroll_position_setter_for_object<'s>(if horizontal { current.1 } else { value },);} else {- crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);+ queue_scroll_observable_effects(scope, runtime_ptr, document, false);}}Ok(())@@ -158,22 +159,44 @@ fn set_node_scroll_position(top: f64,queue_observable_effects: bool,) {- let runtime = unsafe { &mut *runtime_ptr };- let Some(element) = runtime- .dom_host_mut()- .node_mut(handle)- .and_then(|node| node.data_mut().as_element_mut())- else {- return;+ let (changed, document) = {+ let runtime = unsafe { &mut *runtime_ptr };+ let document = runtime.dom_host().owner_document_handle(handle);+ let Some(element) = runtime+ .dom_host_mut()+ .node_mut(handle)+ .and_then(|node| node.data_mut().as_element_mut())+ else {+ return;+ };+ (+ element.set_scroll_left(left) | element.set_scroll_top(top),+ document,+ )};- let changed = element.set_scroll_left(left) | element.set_scroll_top(top);if changed && queue_observable_effects {- crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);- let document = runtime.dom_host().owner_document_handle(handle);- if let Some(document) = document {- queue_revealed_lazy_image_loads(scope, runtime_ptr, document);- }- queue_revealed_lazy_media_loads(scope, runtime_ptr);+ queue_scroll_observable_effects(scope, runtime_ptr, document, false);+ }+}++pub(crate) fn queue_scroll_observable_effects(+ scope: &mut v8::PinScope<'_, '_>,+ runtime_ptr: *mut JsContextHost,+ document: Option<DomHandle>,+ queue_document_events: bool,+) {+ // Native lazy loading deliberately combines the retained pre-scroll+ // projection with live element offsets, so admit those requests before+ // retiring the sampled projection. Observable geometry and author+ // IntersectionObservers, on the other hand, must see a fresh projection.+ if let Some(document) = document {+ queue_revealed_lazy_image_loads(scope, runtime_ptr, document);+ }+ queue_revealed_lazy_media_loads(scope, runtime_ptr);+ unsafe { &*runtime_ptr }.invalidate_layout_after_interaction_state_change();+ crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);+ if queue_document_events {+ let _ = unsafe { &mut *runtime_ptr }.queue_document_scroll_events(scope);}}@@ -259,6 +282,146 @@ fn apply_observable_window_scroll(true}+fn consume_wheel_axis(+ current: f64,+ minimum: f64,+ maximum: f64,+ remaining: f64,+ allows_user_scroll: bool,+) -> (f64, f64) {+ if !allows_user_scroll || remaining == 0.0 {+ return (current, remaining);+ }+ let target = (current + remaining).clamp(minimum, maximum);+ (target, remaining - (target - current))+}++/// Run the uncancelled default action for one pixel-mode WheelEvent.+///+/// Each axis starts at the innermost scroll container under the pointer. Any+/// delta left at that container's boundary continues along the layout ancestor+/// chain, matching the scroll chaining users expect from a trackpad or wheel.+pub(crate) fn perform_wheel_scroll_default_action(+ scope: &mut v8::PinScope<'_, '_>,+ runtime_ptr: *mut JsContextHost,+ handle: DomHandle,+ delta_x: f64,+ delta_y: f64,+) -> Result<bool, moli_layout::LayoutError> {+ let mut remaining_x = if delta_x.is_finite() { delta_x } else { 0.0 };+ let mut remaining_y = if delta_y.is_finite() { delta_y } else { 0.0 };+ if remaining_x == 0.0 && remaining_y == 0.0 {+ return Ok(false);+ }++ let runtime = unsafe { &*runtime_ptr };+ let target = if runtime+ .dom_host()+ .node(handle)+ .is_some_and(Node::is_document)+ {+ let Some(root) = runtime.dom_host().document_element_handle() else {+ return Ok(false);+ };+ root+ } else if runtime.dom_host().is_connected(handle) {+ handle+ } else {+ return Ok(false);+ };+ let Some(mut geometry) = observable_scroll_into_view_geometry(+ runtime,+ target,+ moli_layout::LayoutFlushReason::SynchronousGeometry,+ )?+ else {+ return Ok(false);+ };++ // ScrollIntoView geometry begins at the target's parent. Include the+ // target itself so an empty overflow scroller still responds when its own+ // background is the hit-test result.+ if let Some(metrics) = observable_element_metrics(+ runtime,+ target,+ moli_layout::LayoutFlushReason::SynchronousGeometry,+ )? && metrics.is_scroll_container+ && geometry+ .scroll_containers+ .iter()+ .all(|container| container.source != target)+ {+ geometry.scroll_containers.insert(+ 0,+ moli_layout::LayoutScrollContainerMetrics {+ source: target,+ metrics,+ },+ );+ }++ let mut changed = false;+ for container in geometry.scroll_containers {+ if remaining_x == 0.0 && remaining_y == 0.0 {+ break;+ }+ let (current_x, current_y) =+ node_scroll_position(unsafe { &*runtime_ptr }, container.source);+ let (target_x, next_remaining_x) = consume_wheel_axis(+ current_x,+ f64::from(container.metrics.minimum_scroll_offset.x),+ f64::from(container.metrics.maximum_scroll_offset.x),+ remaining_x,+ container.metrics.allows_user_scroll_x,+ );+ let (target_y, next_remaining_y) = consume_wheel_axis(+ current_y,+ f64::from(container.metrics.minimum_scroll_offset.y),+ f64::from(container.metrics.maximum_scroll_offset.y),+ remaining_y,+ container.metrics.allows_user_scroll_y,+ );+ remaining_x = next_remaining_x;+ remaining_y = next_remaining_y;+ if target_x == current_x && target_y == current_y {+ continue;+ }++ let container_document = unsafe { &*runtime_ptr }+ .dom_host()+ .owner_document_handle(container.source);+ let is_document_scroller = container_document.is_some_and(|document| {+ unsafe { &*runtime_ptr }+ .dom_host()+ .dom()+ .document_element_handle_for_document(document)+ == Some(container.source)+ });+ if is_document_scroller {+ changed |= apply_observable_window_scroll(+ scope,+ runtime_ptr,+ container.source,+ target_x,+ target_y,+ current_x,+ current_y,+ );+ } else {+ set_node_scroll_position(+ scope,+ runtime_ptr,+ container.source,+ target_x,+ target_y,+ true,+ );+ changed = true;+ }+ }+ Ok(changed)+}+pub(crate) fn scroll_node_into_view_if_needed(scope: &mut v8::PinScope<'_, '_>,runtime_ptr: *mut JsContextHost,diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rsindex 493d16e4e..d9f67af89 100644--- a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs+++ b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs@@ -628,6 +628,8 @@ fn mock_element_metrics(scrollport: quad,scrollable_overflow: quad,is_scroll_container: false,+ allows_user_scroll_x: false,+ allows_user_scroll_y: false,clips_overflow: false,visible: rect.width > 0.0 && rect.height > 0.0,pointer_events: true,diff --git a/moli-renderer-v8/src/script_vm/input_dispatch.rs b/moli-renderer-v8/src/script_vm/input_dispatch.rsindex e18d3882b..a2a2fc732 100644--- a/moli-renderer-v8/src/script_vm/input_dispatch.rs+++ b/moli-renderer-v8/src/script_vm/input_dispatch.rs@@ -23,8 +23,9 @@ use crate::native_bridge::element::{construct_touch_event, construct_touch_event_with_points, construct_wheel_event,contenteditable_editing_host, dispatch_public_event, observable_input_hit_test,perform_drop_default_action, perform_mouse_focus_default_action,- replace_contenteditable_selection, replace_text_control_selection,- select_contenteditable_contents, text_control_set_selection_range_internal,+ perform_wheel_scroll_default_action, replace_contenteditable_selection,+ replace_text_control_selection, select_contenteditable_contents,+ text_control_set_selection_range_internal,text_control_set_selection_range_with_direction_internal, text_control_value, update_focus,};use crate::runtime::{@@ -458,7 +459,15 @@ impl ScriptVm {let mut context_host = self._context_host.borrow_mut();context_host.set_hovered_element_for_input(hit_handle);}- let Some(handle) = capture_handle.or(hit_handle) else {+ let wheel_fallback_handle = (event_name == "wheel")+ .then(|| {+ self._context_host+ .borrow()+ .dom_host()+ .document_element_handle()+ })+ .flatten();+ let Some(handle) = capture_handle.or(hit_handle).or(wheel_fallback_handle) else {return Ok(input_dispatch_outcome(false));};let hover_transition = if tracks_mouse_hover_for_event(event_name) {@@ -708,6 +717,15 @@ impl ScriptVm {if let Some(event) = event {let dispatched =dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);+ if event_name == "wheel" && dispatched.allows_default() {+ let _ = perform_wheel_scroll_default_action(+ scope,+ runtime_ptr,+ pointer_dispatch_handle,+ delta_x,+ delta_y,+ )?;+ }if event_name == "mousedown" && dispatched.allows_default() {// Chromium transfers mouse focus only after the// pointer/mouse down events have run and only whendiff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rsindex 8d543437a..40c1c910c 100644--- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs+++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs@@ -242,6 +242,180 @@ fn element_scroll_into_view_if_needed_updates_observable_window_scroll() {assert_eq!(result["scrollingElementScroll"], result["standardScroll"]);}+#[test]+fn wheel_default_action_scrolls_and_refreshes_geometry_unless_canceled() {+ let mut vm = new_storage_test_vm("https://wheel-default-scroll.test/");+ vm.eval(+ r#"+ (() => {+ if (!document.documentElement) {+ document.appendChild(document.createElement("html"));+ }+ if (!document.body) {+ document.documentElement.appendChild(document.createElement("body"));+ }+ document.documentElement.style.margin = "0";+ document.body.style.margin = "0";+ document.body.innerHTML =+ '<div style="height: 500px"></div>' ++ '<div id="marker" style="height: 20px"></div>' ++ '<div style="height: 2500px"></div>';+ window.__wheelDeltas = [];+ window.addEventListener("wheel", event => {+ window.__wheelDeltas.push(event.deltaY);+ }, { capture: true });+ })()+ "#,+ )+ .expect("wheel fixture should initialize");+ refresh_layout_for_test(&mut vm);++ let before = vm+ .eval("document.getElementById('marker').getBoundingClientRect().top")+ .expect("initial marker geometry should evaluate")+ .parse::<f64>()+ .expect("initial marker top should be numeric");+ let outcome = vm+ .dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 120.0)+ .expect("wheel input should dispatch");+ assert!(outcome.handled);++ let result = vm+ .eval(+ r#"+ JSON.stringify({+ scrollY,+ scrollingElementScrollTop: document.scrollingElement.scrollTop,+ markerTop: document.getElementById("marker").getBoundingClientRect().top,+ wheelDeltas: window.__wheelDeltas+ })+ "#,+ )+ .expect("post-wheel geometry should evaluate");+ let result: serde_json::Value =+ serde_json::from_str(&result).expect("post-wheel result should be JSON");+ assert_eq!(result["scrollY"], 120.0);+ assert_eq!(result["scrollingElementScrollTop"], 120.0);+ assert_eq!(result["markerTop"], before - 120.0);+ assert_eq!(result["wheelDeltas"], serde_json::json!([120]));++ vm.eval(+ r#"+ window.addEventListener("wheel", event => event.preventDefault(), {+ capture: true,+ passive: false+ })+ "#,+ )+ .expect("wheel cancellation listener should install");+ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 80.0)+ .expect("canceled wheel input should dispatch");+ assert_eq!(+ vm.eval("String(scrollY)")+ .expect("canceled wheel scroll position should evaluate"),+ "120"+ );+}++#[test]+fn window_scroll_refreshes_intersection_observer_geometry() {+ let mut vm = new_storage_test_vm("https://scroll-intersection-observer.test/");+ vm.eval(+ r#"+ (() => {+ if (!document.documentElement) {+ document.appendChild(document.createElement("html"));+ }+ if (!document.body) {+ document.documentElement.appendChild(document.createElement("body"));+ }+ document.documentElement.style.margin = "0";+ document.body.style.margin = "0";+ document.body.innerHTML =+ '<div style="height: 800px"></div>' ++ '<div id="lazy-target" style="height: 20px"></div>' ++ '<div style="height: 1000px"></div>';+ })()+ "#,+ )+ .expect("intersection scroll fixture should initialize");+ refresh_layout_for_test(&mut vm);++ vm.eval(+ r#"+ (() => {+ window.__intersectionStates = [];+ window.__intersectionObserver = new IntersectionObserver(entries => {+ window.__intersectionStates.push(entries[0].isIntersecting);+ });+ window.__intersectionObserver.observe(+ document.getElementById("lazy-target")+ );+ })()+ "#,+ )+ .expect("intersection observer should register");+ assert_eq!(+ vm.eval("JSON.stringify(window.__intersectionStates)")+ .expect("initial intersection state should flush"),+ "[false]"+ );++ vm.eval("window.scrollTo(0, 400)")+ .expect("window scroll should evaluate");+ assert_eq!(+ vm.eval("JSON.stringify(window.__intersectionStates)")+ .expect("scrolled intersection state should flush"),+ "[false,true]"+ );+}++#[test]+fn wheel_default_action_scrolls_the_innermost_container_then_chains_to_the_root() {+ let mut vm = new_storage_test_vm("https://wheel-scroll-chain.test/");+ vm.eval(+ r#"+ (() => {+ if (!document.documentElement) {+ document.appendChild(document.createElement("html"));+ }+ if (!document.body) {+ document.documentElement.appendChild(document.createElement("body"));+ }+ document.documentElement.style.margin = "0";+ document.body.style.margin = "0";+ document.body.innerHTML =+ '<div id="scroller" style="width: 200px; height: 100px; overflow: auto">' ++ '<div style="height: 500px"></div>' ++ '</div>' ++ '<div style="height: 2000px"></div>';+ })()+ "#,+ )+ .expect("nested wheel fixture should initialize");+ refresh_layout_for_test(&mut vm);++ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 60.0)+ .expect("nested wheel input should dispatch");+ assert_eq!(+ vm.eval("JSON.stringify([document.getElementById('scroller').scrollTop, window.scrollY])")+ .expect("nested wheel positions should evaluate"),+ "[60,0]"+ );++ vm.eval(+ "document.getElementById('scroller').scrollTop = document.getElementById('scroller').scrollHeight"+ )+ .expect("nested scroller should move to its boundary");+ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 40.0)+ .expect("chained wheel input should dispatch");+ assert_eq!(+ vm.eval("String(window.scrollY)")+ .expect("root chained scroll position should evaluate"),+ "40"+ );+}+#[test]fn dom_core_prototype_accessors_brand_check_live_and_detached_receivers() {let mut vm = new_storage_test_vm("https://example.com/");diff --git a/moli-renderer-v8/src/window_host.rs b/moli-renderer-v8/src/window_host.rsindex c27fa2f97..218201356 100644--- a/moli-renderer-v8/src/window_host.rs+++ b/moli-renderer-v8/src/window_host.rs@@ -32,8 +32,7 @@ use super::{iframe_handle_viewport, observable_event_offset,perform_click_default_action_for_dispatched_event,prepare_legacy_activation_for_dispatched_click,- queue_animation_start_for_listener_target, queue_revealed_lazy_image_loads,- queue_revealed_lazy_media_loads,+ queue_animation_start_for_listener_target, queue_scroll_observable_effects,},enter_active_child_window_scope, enter_top_level_lightweight_popup_scope,node_runtime_and_handle_from_object, throw_dom_exception,@@ -1077,13 +1076,7 @@ pub(crate) fn scroll_window_to(if !set_scroll_position(scope, global, x, y) && !scrolling_element_changed {return;}- crate::observer_runtime::queue_intersection_checks(scope, host_ptr);- if let Some(document) = document {- queue_revealed_lazy_image_loads(scope, host_ptr, document);- }- queue_revealed_lazy_media_loads(scope, host_ptr);- let runtime = unsafe { &mut *host_ptr };- let _ = runtime.queue_document_scroll_events(scope);+ queue_scroll_observable_effects(scope, host_ptr, document, true);}pub(crate) fn current_window_scroll_position(scope: &mut v8::PinScope<'_, '_>) -> (f64, f64) {