1. Create CallbackInfo (from CallbackInfoRefData + callback_changes Arc<Mutex>)
2. Invoke the callback (timer/thread/single/menu — different fn signatures)
3. Extract callback_changes from Arc<Mutex>
4. Call self.apply_callback_changes(collected_changes, ...) → CallbackChangeResult
5. Merge CallbackChangeResult into CallCallbacksResult
6. Return CallCallbacksResult

let mut ret = CallCallbacksResult {
    should_scroll_render: false,
    callbacks_update_screen: Update::DoNothing,
    modified_window_state: None,
    // ... 25 more fields ...
};

let mut ret_modified_window_state = current_window_state.clone();
let mut ret_timers = FastHashMap::new();
let mut ret_timers_removed = FastBTreeSet::new();
let mut ret_words_changed = BTreeMap::new();
// ... 6 more ...

let ref_data = crate::callbacks::CallbackInfoRefData {
    layout_window: self,
    renderer_resources,
    previous_window_state,
    current_window_state,
    gl_context,
    current_scroll_manager: &current_scroll_states,
    current_window_handle,
    system_callbacks,
    system_style,
    monitors: self.monitors.clone(),
    #[cfg(feature = "icu")]
    icu_localizer: self.icu_localizer.clone(),
    ctx: ...,  // only this varies
};

impl CallbackChangeResult {
    /// Merge this result into a CallCallbacksResult accumulator.
    /// Handles all fields uniformly — new fields only need to be added here.
    pub fn merge_into(self, ret: &mut CallCallbacksResult) {
        ret.stop_propagation = ret.stop_propagation || self.stop_propagation;
        ret.prevent_default = ret.prevent_default || self.prevent_default;
        ret.tooltips_to_show.extend(self.tooltips_to_show);
        ret.hide_tooltip = ret.hide_tooltip || self.hide_tooltip;
        ret.begin_interactive_move = ret.begin_interactive_move || self.begin_interactive_move;

        if self.hit_test_update_requested.is_some() {
            ret.hit_test_update_requested = self.hit_test_update_requested;
        }

        // Timers/threads: merge into Option<HashMap>
        merge_option_map(&mut ret.timers, self.timers);
        merge_option_map(&mut ret.threads, self.threads);
        merge_option_set(&mut ret.timers_removed, self.timers_removed);
        merge_option_set(&mut ret.threads_removed, self.threads_removed);

        // DOM changes: merge BTreeMap<DomId, BTreeMap<NodeId, T>>
        merge_nested_map(&mut ret.words_changed, self.words_changed);
        merge_nested_map(&mut ret.images_changed, self.images_changed);
        merge_nested_map(&mut ret.image_masks_changed, self.image_masks_changed);
        merge_nested_map(&mut ret.css_properties_changed, self.css_properties_changed);
        merge_nested_set(&mut ret.image_callbacks_changed, self.image_callbacks_changed);
        merge_nested_map(&mut ret.nodes_scrolled_in_callbacks, self.nodes_scrolled);

        ret.update_all_image_callbacks = ret.update_all_image_callbacks
            || self.update_all_image_callbacks;

        if self.modified_window_state != ret.modified_window_state
                .as_ref()
                .unwrap_or(&FullWindowState::default()) // compare to current
        {
            ret.modified_window_state = Some(self.modified_window_state);
        }

        if let Some(ft) = self.focus_target {
            // Resolve immediately while we have layout_results access,
            // or store raw and resolve later
            ret.pending_focus_target = Some(ft);
        }

        if !self.queued_window_states.is_empty() {
            ret.queued_window_states.extend(self.queued_window_states);
        }
        if !self.text_input_triggered.is_empty() {
            ret.text_input_triggered.extend(self.text_input_triggered);
        }
    }
}

// Before (28 lines, repeated 4×):
let mut ret = CallCallbacksResult {
    should_scroll_render: false,
    callbacks_update_screen: Update::DoNothing,
    ...
};

// After (1 line):
let mut ret = CallCallbacksResult::default();

impl LayoutWindow {
    /// Generic callback invocation: create CallbackInfo, invoke callback,
    /// collect changes, apply them, merge into result.
    fn invoke_and_collect<F>(
        &mut self,
        hit_dom_node: DomNodeId,
        cursor_relative_to_item: OptionLogicalPosition,
        cursor_in_viewport: OptionLogicalPosition,
        ctx: OptionRefAny,
        // Common params (could be a struct)
        current_window_handle: &RawWindowHandle,
        gl_context: &OptionGlContextPtr,
        image_cache: &mut ImageCache,
        system_fonts: &mut FcFontCache,
        system_style: Arc,
        system_callbacks: &ExternalSystemCallbacks,
        previous_window_state: &Option<FullWindowState>,
        current_window_state: &FullWindowState,
        renderer_resources: &RendererResources,
        // The actual callback invocation (closure)
        invoke_fn: F,
    ) -> (Update, CallbackChangeResult)
    where
        F: FnOnce(CallbackInfo) -> Update,
    {
        let scroll_states = self.get_nested_scroll_states(DomId::ROOT_ID);
        let callback_changes = Arc::new(Mutex::new(Vec::new()));

        let ref_data = CallbackInfoRefData {
            layout_window: self,
            renderer_resources,
            previous_window_state,
            current_window_state,
            gl_context,
            current_scroll_manager: &scroll_states,
            current_window_handle,
            system_callbacks,
            system_style,
            monitors: self.monitors.clone(),
            #[cfg(feature = "icu")]
            icu_localizer: self.icu_localizer.clone(),
            ctx,
        };

        let callback_info = CallbackInfo::new(
            &ref_data, &callback_changes,
            hit_dom_node, cursor_relative_to_item, cursor_in_viewport,
        );

        let update = invoke_fn(callback_info);

        let collected = callback_changes.lock()
            .map(|mut g| core::mem::take(&mut *g))
            .unwrap_or_default();

        let change_result = self.apply_callback_changes(
            collected, current_window_state, image_cache, system_fonts,
        );

        self.queue_iframe_updates(change_result.iframes_to_update.clone());

        (update, change_result)
    }
}

// Timer path:
let (update, change_result) = self.invoke_and_collect(
    hit_dom_node, cursor_relative_to_item, cursor_in_viewport,
    timer_ctx,
    /* common params */,
    |callback_info| {
        let timer = self.timers.get_mut(&TimerId { id: timer_id }).unwrap();
        let tcr = timer.invoke(&callback_info, &system_callbacks.get_system_time_fn);
        should_terminate = tcr.should_terminate;
        tcr.should_update
    },
);
ret.callbacks_update_screen = update;
change_result.merge_into(&mut ret);

/// Environment available during callback invocation.
/// Shared across timer, thread, single-callback, and menu paths.
pub struct CallbackEnv<'a> {
    pub current_window_handle: &'a RawWindowHandle,
    pub gl_context: &'a OptionGlContextPtr,
    pub image_cache: &'a mut ImageCache,
    pub system_fonts: &'a mut FcFontCache,
    pub system_style: Arc,
    pub system_callbacks: &'a ExternalSystemCallbacks,
    pub previous_window_state: &'a Option<FullWindowState>,
    pub current_window_state: &'a FullWindowState,
    pub renderer_resources: &'a RendererResources,
}

pub fn invoke_notification_callback(
    &mut self,
    notification_id: NotificationId,
    action: NotificationAction, // Clicked, Dismissed, ActionButton(idx)
    env: &mut CallbackEnv,
) -> CallCallbacksResult {
    let mut ret = CallCallbacksResult::default();
    let hit_dom_node = DomNodeId::root(); // Notifications aren't DOM-attached

    let (update, change_result) = self.invoke_and_collect(
        hit_dom_node, OptionLogicalPosition::None, OptionLogicalPosition::None,
        OptionRefAny::None, env,
        |callback_info| {
            let cb = self.notification_callbacks.get(&notification_id)?;
            (cb.callback.cb)(cb.refany.clone(), notification_id, action, callback_info)
        },
    );
    ret.callbacks_update_screen = update;
    change_result.merge_into(&mut ret);
    ret
}

pub fn invoke_tray_menu_callback(
    &mut self,
    menu_item_id: TrayMenuItemId,
    env: &mut CallbackEnv,
) -> CallCallbacksResult {
    let mut ret = CallCallbacksResult::default();

    let (update, change_result) = self.invoke_and_collect(
        DomNodeId::root(), OptionLogicalPosition::None, OptionLogicalPosition::None,
        OptionRefAny::None, env,
        |callback_info| {
            let cb = self.tray_callbacks.get(&menu_item_id)?;
            (cb.callback.cb)(cb.refany.clone(), callback_info)
        },
    );
    ret.callbacks_update_screen = update;
    change_result.merge_into(&mut ret);
    ret
}

pub fn invoke_file_watcher_callback(
    &mut self,
    path: &Path,
    change_type: FileChangeType,
    env: &mut CallbackEnv,
) -> CallCallbacksResult { ... } // same ~10 line pattern

Platform Event Handler (macOS/Windows/X11/Wayland)
  → ScrollManager.record_scroll_from_hit_test(delta, source, ...)
  → ScrollInputQueue.push(ScrollInput)
  → start SCROLL_MOMENTUM_TIMER_ID timer (if not already running)

Timer fires (every ~16ms):
  → scroll_physics_timer_callback (layout/src/scroll_timer.rs)
    1. queue.take_recent(100)  — consume pending inputs
    2. Physics integration (velocity, friction, rubber-banding)
    3. push_change(CallbackChange::ScrollTo) for each updated node
    4. Return Update::RefreshDom + Continue (or TerminateTimer)

Timer result flows back:
  → run_single_timer()         → CallCallbacksResult { nodes_scrolled_in_callbacks, ... }
  → invoke_expired_timers()    → Vec<CallCallbacksResult>
  → Platform tick_timers()     → process_callback_result_v2(result)
                                  → scroll_manager.scroll_to() for each node
                                  → generate_frame()
                                  → scroll_all_nodes(txn) sends offsets to WebRender

let needs_processing = result.modified_window_state.is_some()
    || !result.queued_window_states.is_empty()
    || !result.text_input_triggered.is_empty();
// MISSING: || result.nodes_scrolled_in_callbacks.as_ref().map(|s| !s.is_empty()).unwrap_or(false)

let has_scroll_changes = result.nodes_scrolled_in_callbacks.as_ref()
    .map(|s| !s.is_empty()).unwrap_or(false);
if has_window_changes || has_scroll_changes || has_text_input { ... }

fn check_timers_and_threads(&mut self) {
    let timer_results = self.invoke_expired_timers();
    if !timer_results.is_empty() {
        self.frame_needs_regeneration = true;  // blindly set, no result processing!
    }
    ...
}

should_update: if any_changes {
    Update::RefreshDom       // <-- Forces FULL DOM regeneration!
} else {
    Update::DoNothing
},

} else {
    txn.skip_scene_builder();
}
// ... later, always runs:
scroll_all_nodes(layout_window, txn);
synchronize_gpu_values(layout_window, txn);
txn.generate_frame(0, WrRenderReasons::empty());

// All platforms must check:
let has_scroll_changes = result.nodes_scrolled_in_callbacks.as_ref()
    .map(|s| !s.is_empty()).unwrap_or(false);
let needs_processing = result.modified_window_state.is_some()
    || !result.queued_window_states.is_empty()
    || !result.text_input_triggered.is_empty()
    || has_scroll_changes;  // <-- Add this

fn check_timers_and_threads(&mut self) {
    let timer_results = self.invoke_expired_timers();
    for result in &timer_results {
        let needs_processing = result.modified_window_state.is_some()
            || !result.queued_window_states.is_empty()
            || !result.text_input_triggered.is_empty()
            || result.nodes_scrolled_in_callbacks.as_ref()
                .map(|s| !s.is_empty()).unwrap_or(false);
        if needs_processing {
            self.previous_window_state = Some(self.current_window_state.clone());
            let _ = self.process_callback_result_v2(result);
        }
        if matches!(result.callbacks_update_screen,
            Update::RefreshDom | Update::RefreshDomAllWindows) {
            self.frame_needs_regeneration = true;
        }
    }
}

// scroll_timer.rs — proposed change:
should_update: Update::DoNothing,  // Don't trigger DOM refresh
should_terminate: TerminateTimer::Continue,
// The ScrollTo changes flow through nodes_scrolled_in_callbacks
// and are processed by process_callback_result_v2, which already
// returns ShouldReRenderCurrentWindow.

// After processing timer results:
if has_scroll_changes && !needs_dom_rebuild {
    // Scroll-only: update scroll positions + repaint, skip display list rebuild
    generate_frame(display_list_was_rebuilt=false);
}