RESTYLE PATH (event_v2)                    LAYOUT PATH (solver3)
─────────────────────                      ────────────────────
hover/focus/active change                  User's layout_callback() → new StyledDom
       │                                          │
       ▼                                          ▼
restyle_on_state_change()                  reconcile_and_invalidate()
       │                                          │
       ▼                                          ▼
RestyleResult {                            ReconciliationResult {
  changed_nodes: per-node props              intrinsic_dirty: BTreeSet
  max_relayout_scope: 4-level                layout_roots: BTreeSet
  gpu_only_changes: bool                   }  ← binary dirty/clean only
}                                                 │
       │                                          ▼
       ▼                                   layout_document()
ProcessEventResult::                              │
  ShouldRegenerateDom                      DirtyFlag::Layout only
       │                                   (::Paint never set)
       ▼
FULL DOM REBUILD
(calls user's layout_callback again!)
(restyle info discarded)

 ┌─────────────────────┐  ┌──────────────────────┐  ┌────────────────────────┐
 │ PATH A: DOM Rebuild │  │ PATH B: Restyle      │  │ PATH C: Runtime Edits  │
 │ (layout_callback)   │  │ (hover/focus/active)  │  │ (set_text/set_css)     │
 └──────────┬──────────┘  └──────────┬───────────┘  └──────────┬─────────────┘
            │                        │                          │
            ▼                        ▼                          ▼
    reconcile_dom()          restyle_on_state_change()   CallbackChangeResult
    + compute_node_changes() → RestyleResult               .words_changed
    → ExtendedDiffResult       .changed_nodes              .css_properties_changed
      .node_changes            .max_relayout_scope         .images_changed
            │                        │                          │
            └────────────────────────┼──────────────────────────┘
                                     │
                                     ▼
                          ┌─────────────────────┐
                          │  ChangeAccumulator   │   ← NEW: unifies all 3 paths
                          │  per_node: Map<      │
                          │    NodeId →           │
                          │    (NodeChangeSet,    │
                          │     RelayoutScope)    │
                          │  >                    │
                          │  max_scope:           │   
                          │    RelayoutScope      │
                          │  damage_rects: Vec<>  │   ← for future compositor
                          └──────────┬────────────┘
                                     │
                          ┌──────────▼────────────┐
                          │ Decision Engine        │
                          │                        │
                          │ match max_scope {      │
                          │   None →               │
                          │     repaint only       │
                          │   IfcOnly →            │
                          │     reshape IFCs,      │
                          │     local relayout     │
                          │   SizingOnly →         │
                          │     intrinsic +        │
                          │     local relayout     │
                          │   Full →               │
                          │     full subtree       │
                          │     relayout           │
                          │ }                      │
                          └──────────┬────────────┘
                                     │
                                     ▼
                          ┌─────────────────────────────────┐
                          │ reconcile_and_invalidate()       │
                          │  - uses NodeChangeSet to set     │
                          │    DirtyFlag::Paint vs ::Layout  │
                          │  - adds paint_dirty set          │
                          │    (separate from intrinsic_     │
                          │     dirty / layout_roots)        │
                          └──────────┬──────────────────────┘
                                     │
                          ┌──────────▼──────────────────────┐
                          │ layout_document()                │
                          │  - Layout-dirty → full intrinsic │
                          │    + taffy + position pass       │
                          │  - Paint-dirty → skip to display │
                          │    list regeneration             │
                          │  - generate_display_list()       │
                          │    (future: damage_rects for     │
                          │     partial DL regeneration)     │
                          └─────────────────────────────────┘

/// Unified change report that merges information from all three change paths:
/// 1. DOM reconciliation (compute_node_changes)
/// 2. CSS restyle (restyle_on_state_change)
/// 3. Runtime edits (words_changed, css_properties_changed, images_changed)
///
/// This is the single source of truth for "what needs to be done this frame".
#[derive(Debug, Clone, Default)]
pub struct ChangeAccumulator {
    /// Per-node change info. Key is the new-DOM NodeId.
    /// The NodeChangeSet bitflags tell us WHAT changed;
    /// the RelayoutScope tells us HOW MUCH layout work is needed.
    pub per_node: BTreeMap<NodeId, NodeChangeReport>,

    /// Maximum RelayoutScope across all changed nodes.
    /// Quick check: if this is None, we can skip layout entirely.
    pub max_scope: RelayoutScope,

    /// Damage rectangles for compositor-level partial repaint (Phase 3+).
    /// Each rect is in logical coordinates relative to the window.
    pub damage_rects: Vec<LogicalRect>,

    /// Nodes that are newly mounted (no old counterpart).
    /// These always get DirtyFlag::Layout.
    pub mounted_nodes: Vec<NodeId>,

    /// Nodes that were unmounted (no new counterpart).
    /// Used for cleanup (remove from scroll/focus/cursor managers).
    pub unmounted_nodes: Vec<NodeId>,
}

/// Per-node change report combining multiple information sources.
#[derive(Debug, Clone, Default)]
pub struct NodeChangeReport {
    /// Bitflags from DOM-level field comparison.
    pub change_set: NodeChangeSet,

    /// Highest RelayoutScope from any CSS property that changed on this node.
    /// This is more granular than NodeChangeSet's binary LAYOUT/PAINT split.
    ///
    /// - `None` → repaint only (color, opacity, transform)
    /// - `IfcOnly` → reshape text in the containing IFC
    /// - `SizingOnly` → recompute this node's intrinsic size
    /// - `Full` → full subtree relayout (display, position, float, etc.)
    pub relayout_scope: RelayoutScope,

    /// Individual CSS properties that changed (for fine-grained cache invalidation).
    /// Empty if the change was structural (text content, node type, etc.)
    pub changed_css_properties: Vec<CssPropertyType>,

    /// If text content changed, the old and new text for cursor reconciliation.
    pub text_change: Option<TextChange>,
}

/// Text change info for cursor/selection reconciliation.
#[derive(Debug, Clone)]
pub struct TextChange {
    pub old_text: String,
    pub new_text: String,
}

// In compute_node_changes(), replace the CSS property comparison block:

// 4. Inline CSS properties — classify using RelayoutScope
let old_props = old_node.css_props.as_ref();
let new_props = new_node.css_props.as_ref();
if old_props != new_props {
    let mut has_layout = false;
    let mut has_paint = false;
    let mut max_scope = RelayoutScope::None;

    // Build old property map
    let mut old_map = FastHashMap::default();
    for prop in old_props.iter() {
        old_map.insert(prop.property.get_type(), prop);
    }

    // Check new vs old
    let mut seen_types = FastHashMap::default();
    for prop in new_props.iter() {
        let prop_type = prop.property.get_type();
        seen_types.insert(prop_type, ());
        match old_map.get(&prop_type) {
            Some(old_prop) if **old_prop == *prop => {} // unchanged
            _ => {
                let scope = prop_type.relayout_scope(true); // conservative
                if scope > max_scope { max_scope = scope; }
                if scope != RelayoutScope::None {
                    has_layout = true;
                } else {
                    has_paint = true;
                }
            }
        }
    }

    // Check removed properties
    for (prop_type, _) in old_map.iter() {
        if !seen_types.contains_key(prop_type) {
            let scope = prop_type.relayout_scope(true);
            if scope > max_scope { max_scope = scope; }
            if scope != RelayoutScope::None {
                has_layout = true;
            } else {
                has_paint = true;
            }
        }
    }

    if has_layout {
        changes.insert(NodeChangeSet::INLINE_STYLE_LAYOUT);
    }
    if has_paint {
        changes.insert(NodeChangeSet::INLINE_STYLE_PAINT);
    }
}

/// The result of a reconciliation pass (modified).
#[derive(Debug, Default)]
pub struct ReconciliationResult {
    /// Nodes needing intrinsic size recalculation (bottom-up).
    pub intrinsic_dirty: BTreeSet<usize>,
    /// Subtree roots needing top-down layout pass.
    pub layout_roots: BTreeSet<usize>,
    /// Nodes needing display-list regeneration only (no layout).  ← NEW
    pub paint_dirty: BTreeSet<usize>,
}

impl ReconciliationResult {
    pub fn is_clean(&self) -> bool {
        self.intrinsic_dirty.is_empty()
            && self.layout_roots.is_empty()
            && self.paint_dirty.is_empty()
    }

    pub fn needs_layout(&self) -> bool {
        !self.intrinsic_dirty.is_empty() || !self.layout_roots.is_empty()
    }

    pub fn needs_paint_only(&self) -> bool {
        !self.paint_dirty.is_empty() && !self.needs_layout()
    }
}

RelayoutScope       DirtyFlag           Layout work needed
────────────        ─────────           ──────────────────
None                None (or Paint)     Regenerate display list entry only
IfcOnly             Layout              Reshape text in containing IFC + local relayout
SizingOnly          Layout              Recompute intrinsic sizes, local sibling repositioning
Full                Layout              Full subtree relayout

With NodeChangeSet:
NodeChangeSet::TEXT_CONTENT     → IfcOnly (reshape text, may cascade to SizingOnly if line count changes)
NodeChangeSet::IMAGE_CHANGED   → SizingOnly (image may have different intrinsic size) or None (same size)
NodeChangeSet::IDS_AND_CLASSES  → Full (conservative: class change may add any CSS property)
NodeChangeSet::INLINE_STYLE_*  → per-property RelayoutScope
NodeChangeSet::CHILDREN_CHANGED → Full
NodeChangeSet::NODE_TYPE_CHANGED → Full
NodeChangeSet::CALLBACKS        → None (no visual change)
NodeChangeSet::DATASET          → None (no visual change)
NodeChangeSet::STYLED_STATE     → depends on affected CSS properties (via RestyleResult)

layout_callback() → StyledDom(new)
       │
       ▼
reconcile_dom() matches old Text("Hello") ↔ new Text("Hello World")
       │        (via structural hash match)
       ▼
compute_node_changes() sets TEXT_CONTENT flag
       │
       ▼
ChangeAccumulator adds TextChange {
    old_text: "Hello",
    new_text: "Hello World",
}
       │
       ▼
reconcile_cursor_position() maps cursor byte offset
       │        (already exists in diff.rs:936)
       ▼
reconcile_and_invalidate() sets DirtyFlag::Layout
       │        (IfcOnly scope → only reshape the containing IFC)
       ▼
layout_document() reshapes IFC, local relayout

keystroke → TextInputManager.record_input()
       │
       ▼
apply_text_changeset() [in LayoutWindow]
       │
       ├── update text in dirty_text_nodes cache
       ├── CursorManager.set_cursor()
       │
       ▼
ChangeAccumulator adds:
  - NodeChangeSet::TEXT_CONTENT for the IFC root
  - RelayoutScope::IfcOnly
  - TextChange { old, new }
       │
       ▼
relayout_dirty_nodes() [fast path, no reconciliation]
  - Get cached UnifiedConstraints for this IFC
  - Reshape text (stages 1-4 of text pipeline)
  - Check if IFC height changed → may upgrade to SizingOnly
  - Update calculated_positions locally
  - Regenerate display list

apply_focus_restyle() → restyle_on_state_change()
   → RestyleResult { needs_layout: true, max_relayout_scope: IfcOnly, ... }
   → ProcessEventResult::ShouldRegenerateDomCurrentWindow  ← BUG: throws away granular info
   → regenerate_layout() calls user's layout_callback()     ← unnecessary DOM rebuild
   → apply_runtime_states_before_layout() re-applies states ← restyle info recomputed from scratch

pub enum ProcessEventResult {
    DoNothing,
    ShouldReRenderCurrentWindow,            // compositor repaint only
    ShouldUpdateDisplayListCurrentWindow,   // rebuild display list, no layout
    ShouldIncrementalRelayout,              // ← NEW: restyle-driven, no DOM rebuild
    UpdateHitTesterCurrentWindow,           // rebuild hit tester
    ShouldRegenerateDomCurrentWindow,       // full DOM rebuild (user's layout_callback)
    ShouldRegenerateDomAllWindows,          // all windows
}

fn apply_focus_restyle(
    layout_window: &mut LayoutWindow,
    old_focus: Option<NodeId>,
    new_focus: Option<NodeId>,
) -> ProcessEventResult {
    let restyle = layout_result.styled_dom.restyle_on_state_change(...);

    if restyle.changed_nodes.is_empty() {
        return ProcessEventResult::ShouldReRenderCurrentWindow;
    }

    if restyle.gpu_only_changes {
        return ProcessEventResult::ShouldReRenderCurrentWindow; // GPU handles transform/opacity
    }

    if restyle.needs_layout {
        // NEW: Instead of ShouldRegenerateDomCurrentWindow, use incremental path
        // Feed RestyleResult into ChangeAccumulator
        let mut accumulator = ChangeAccumulator::default();
        accumulator.merge_restyle_result(&restyle);

        // Apply directly to the layout tree's dirty flags
        for (node_id, report) in &accumulator.per_node {
            let layout_idx = layout_result.node_id_to_layout_idx(*node_id);
            match report.relayout_scope {
                RelayoutScope::None => {
                    layout_tree.mark_dirty(layout_idx, DirtyFlag::Paint);
                }
                RelayoutScope::IfcOnly => {
                    // Find IFC root and mark it for reshape
                    let ifc_root = layout_tree.find_ifc_root(layout_idx);
                    layout_tree.mark_dirty(ifc_root, DirtyFlag::Layout);
                }
                RelayoutScope::SizingOnly | RelayoutScope::Full => {
                    layout_tree.mark_dirty(layout_idx, DirtyFlag::Layout);
                }
            }
        }

        return ProcessEventResult::ShouldIncrementalRelayout;
    }

    ProcessEventResult::ShouldUpdateDisplayListCurrentWindow
}

// In macOS shell (and equivalent for other platforms):
ProcessEventResult::ShouldIncrementalRelayout => {
    // Don't call user's layout_callback() — DOM is unchanged
    // Just re-run layout_document() with the existing StyledDom
    // The ChangeAccumulator has already set dirty flags on the LayoutTree
    let display_list = layout_document(
        &mut cache,
        // ... same StyledDom, just with dirty flags updated ...
    );
    // Build WR transaction with new display list
    build_webrender_transaction(&display_list);
}

// In process_callback_result_v2(), after collecting CallCallbacksResult:

if let Some(words) = &result.words_changed {
    for (dom_id, nodes) in words {
        for (node_id, new_text) in nodes {
            accumulator.add_text_change(*node_id, RelayoutScope::IfcOnly);
        }
    }
}

if let Some(css) = &result.css_properties_changed {
    for (dom_id, nodes) in css {
        for (node_id, properties) in nodes {
            for prop in properties.iter() {
                let scope = prop.get_type().relayout_scope(true);
                accumulator.add_css_change(*node_id, prop.get_type(), scope);
            }
        }
    }
}

if let Some(images) = &result.images_changed {
    for (dom_id, nodes) in images {
        for (node_id, (image_ref, update_type)) in nodes {
            // Check if intrinsic size changed
            let scope = if size_changed { RelayoutScope::SizingOnly } else { RelayoutScope::None };
            accumulator.add_image_change(*node_id, scope);
        }
    }
}

// Then determine ProcessEventResult from accumulator:
match accumulator.max_scope {
    RelayoutScope::None => ProcessEventResult::ShouldUpdateDisplayListCurrentWindow,
    _ => ProcessEventResult::ShouldIncrementalRelayout,
}

fn hash_styled_node_data(dom: &StyledDom, node_id: NodeId) -> u64 {
    let mut hasher = DefaultHasher::new();
    styled_node.styled_node_state.hash(&mut hasher);
    node_data.get_node_type().hash(&mut hasher);
    hasher.finish()
}

/// Per-node hash broken into independent fields.
/// Each field can be compared separately to determine what changed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NodeDataFingerprint {
    /// Hash of node_type (Text content, Image ref, Div, etc.)
    pub content_hash: u64,
    /// Hash of styled_node_state (hover, focus, active bits)
    pub state_hash: u64,
    /// Hash of inline CSS properties
    pub inline_css_hash: u64,
    /// Hash of ids_and_classes
    pub ids_classes_hash: u64,
    /// Hash of callbacks (event types + function pointers)
    pub callbacks_hash: u64,
    /// Hash of other attributes (contenteditable, tab_index, dataset, a11y)
    pub attrs_hash: u64,
}

impl NodeDataFingerprint {
    pub fn compute(dom: &StyledDom, node_id: NodeId) -> Self {
        // ... hash each field independently ...
    }

    /// Returns a NodeChangeSet by comparing two fingerprints.
    /// This is O(1) — just comparing 6 u64s instead of walking all fields.
    pub fn diff(&self, other: &NodeDataFingerprint) -> NodeChangeSet {
        let mut changes = NodeChangeSet::empty();
        if self.content_hash != other.content_hash {
            // Could be TEXT_CONTENT, IMAGE_CHANGED, or NODE_TYPE_CHANGED
            // We set a generic flag; detailed classification needs NodeData access
            changes.insert(NodeChangeSet::TEXT_CONTENT | NodeChangeSet::IMAGE_CHANGED);
        }
        if self.state_hash != other.state_hash {
            changes.insert(NodeChangeSet::STYLED_STATE);
        }
        if self.inline_css_hash != other.inline_css_hash {
            // Conservative: mark as layout. Detailed classification done by
            // compute_node_changes() which checks relayout_scope() per property.
            changes.insert(NodeChangeSet::INLINE_STYLE_LAYOUT);
        }
        if self.ids_classes_hash != other.ids_classes_hash {
            changes.insert(NodeChangeSet::IDS_AND_CLASSES);
        }
        if self.callbacks_hash != other.callbacks_hash {
            changes.insert(NodeChangeSet::CALLBACKS);
        }
        if self.attrs_hash != other.attrs_hash {
            changes.insert(NodeChangeSet::TAB_INDEX | NodeChangeSet::CONTENTEDITABLE);
        }
        changes
    }

    /// Returns true if all fields are identical.
    pub fn is_identical(&self, other: &NodeDataFingerprint) -> bool {
        self == other
    }

    /// Quick check: does this change affect layout?
    /// Only does the expensive field-by-field check if quick hash check says "maybe".
    pub fn might_affect_layout(&self, other: &NodeDataFingerprint) -> bool {
        self.content_hash != other.content_hash
            || self.inline_css_hash != other.inline_css_hash
            || self.ids_classes_hash != other.ids_classes_hash
            || self.attrs_hash != other.attrs_hash
    }

    /// Quick check: is this a visual change at all?
    pub fn might_affect_visuals(&self, other: &NodeDataFingerprint) -> bool {
        self.content_hash != other.content_hash
            || self.state_hash != other.state_hash
            || self.inline_css_hash != other.inline_css_hash
            || self.ids_classes_hash != other.ids_classes_hash
    }
}

Tier 1 (O(1) per node, in reconcile_recursive):
    Compare NodeDataFingerprint fields.
    If all match → DirtyFlag::None (skip entirely).
    If only state/callbacks/attrs differ → quick classification.
    If content/css/ids differ → go to Tier 2.

Tier 2 (O(n) per changed field, only for changed nodes):
    compute_node_changes() does field-by-field NodeData comparison.
    For CSS props: uses relayout_scope() per property.
    Returns precise NodeChangeSet + RelayoutScope.

impl ChangeAccumulator {
    /// After layout, compute damage rects from the changed nodes' positions.
    pub fn compute_damage_rects(
        &mut self,
        calculated_positions: &PositionVec,
        used_sizes: &[LogicalSize],
    ) {
        for (node_id, report) in &self.per_node {
            if report.change_set.is_visually_unchanged() {
                continue;
            }
            let idx = node_id.index();
            if let Some(pos) = calculated_positions.get(idx) {
                let size = used_sizes.get(idx).copied().unwrap_or_default();
                self.damage_rects.push(LogicalRect {
                    origin: *pos,
                    size,
                });
            }
        }
    }
}

core/src/diff.rs                            — Fix compute_node_changes(), add ChangeAccumulator,
                                              NodeChangeReport, TextChange, NodeDataFingerprint
core/src/events.rs                          — Add ShouldIncrementalRelayout to ProcessEventResult
core/src/styled_dom.rs                      — (unchanged, RestyleResult already correct)
css/src/props/property.rs                   — (unchanged, relayout_scope() already exists)
layout/src/solver3/cache.rs                 — ReconciliationResult.paint_dirty, NodeDataFingerprint
                                              in LayoutNode, update reconcile_recursive()
layout/src/solver3/layout_tree.rs           — Store NodeDataFingerprint instead of u64 hash
layout/src/solver3/mod.rs                   — Handle paint_dirty in layout_document()
layout/src/window.rs                        — Apply words_changed/css_properties_changed
dll/src/desktop/shell2/common/event_v2.rs   — Feed RestyleResult + CallCallbacksResult → ChangeAccumulator,
                                              apply_focus_restyle() → incremental path
dll/src/desktop/shell2/common/layout_v2.rs  — Add incremental_relayout(), update regenerate_layout()
dll/src/desktop/shell2/macos/mod.rs         — Handle ShouldIncrementalRelayout in render loop
dll/src/desktop/shell2/macos/events.rs      — Map ShouldIncrementalRelayout to RegenerateDisplayList