//! DOM Reconciliation Module

//!

//! This module provides the reconciliation algorithm that compares two DOM trees

//! and generates lifecycle events. It uses stable keys and content hashing to

//! identify moves vs. mounts/unmounts.

//!

//! The reconciliation strategy is:

//! 1. **Stable Key Match:** If `.with_key()` is used, it's an absolute match (O(1)).

//! 2. **CSS ID Match:** If no key, use the CSS ID as key.

//! 3. **Structural Key Match:** nth-of-type-within-parent + parent's key (recursive).

//! 4. **Hash Match (Content Match):** Check for identical `DomNodeHash`.

//! 5. **Structural Hash Match:** For text nodes, match by structural hash (ignoring content).

//! 6. **Fallback:** Anything not matched is a `Mount` (new) or `Unmount` (old leftovers).

use alloc::{collections::BTreeMap, collections::VecDeque, string::{String, ToString}, vec::Vec};

use core::hash::Hash;

use azul_css::props::property::{CssPropertyType, RelayoutScope};

use crate::{

    dom::{DomId, DomNodeHash, DomNodeId, NodeData, NodeType, IdOrClass},

    events::{

        ComponentEventFilter, EventData, EventFilter, EventPhase, EventSource, EventType,

        LifecycleEventData, LifecycleReason, SyntheticEvent,

    },

    geom::LogicalRect,

    id::NodeId,

    styled_dom::{ChangedCssProperty, NodeHierarchyItemId, NodeHierarchyItem, RestyleResult, StyledNodeState},

    task::Instant,

    OrderedMap,

};

// ============================================================================

// NodeChangeSet — granular per-node change flags

// ============================================================================

/// Bit flags describing what changed about a node between old and new DOM.

/// Multiple flags can be set simultaneously. Uses manual bit manipulation

/// instead of bitflags crate to avoid adding a dependency.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]

pub struct NodeChangeSet {

    pub bits: u32,

}

impl NodeChangeSet {

    // --- Changes that affect LAYOUT (need relayout + repaint) ---

    /// Node type changed entirely (e.g., Text → Image).

    pub const NODE_TYPE_CHANGED: u32    = 0b0000_0000_0000_0001;

    /// Text content changed (for Text nodes).

    pub const TEXT_CONTENT: u32         = 0b0000_0000_0000_0010;

    /// CSS IDs or classes changed (may cause restyle → relayout).

    pub const IDS_AND_CLASSES: u32      = 0b0000_0000_0000_0100;

    /// Inline CSS properties changed that affect layout.

    pub const INLINE_STYLE_LAYOUT: u32  = 0b0000_0000_0000_1000;

    /// Children added, removed, or reordered.

    pub const CHILDREN_CHANGED: u32     = 0b0000_0000_0001_0000;

    /// Image source changed (may affect intrinsic size).

    pub const IMAGE_CHANGED: u32        = 0b0000_0000_0010_0000;

    /// Contenteditable flag changed.

    pub const CONTENTEDITABLE: u32      = 0b0000_0000_0100_0000;

    /// Tab index changed.

    pub const TAB_INDEX: u32            = 0b0000_0000_1000_0000;

    // --- Changes that affect PAINT only (no relayout needed) ---

    /// Inline CSS properties changed that affect paint only.

    pub const INLINE_STYLE_PAINT: u32   = 0b0000_0001_0000_0000;

    /// Styled node state changed (hover, active, focus, etc.).

    pub const STYLED_STATE: u32         = 0b0000_0010_0000_0000;

    // --- Changes that affect NEITHER layout nor paint ---

    /// Callbacks changed (new `RefAny`, different event handlers).

    pub const CALLBACKS: u32            = 0b0000_0100_0000_0000;

    /// Dataset changed.

    pub const DATASET: u32              = 0b0000_1000_0000_0000;

    /// Accessibility info changed.

    pub const ACCESSIBILITY: u32        = 0b0001_0000_0000_0000;

    // --- Composite masks ---

    /// Any change that requires a layout pass.

    pub const AFFECTS_LAYOUT: u32 = Self::NODE_TYPE_CHANGED

        | Self::TEXT_CONTENT

        | Self::IDS_AND_CLASSES

        | Self::INLINE_STYLE_LAYOUT

        | Self::CHILDREN_CHANGED

        | Self::IMAGE_CHANGED

        | Self::CONTENTEDITABLE;

    /// Any change that requires a paint/display-list update (but not layout).

    pub const AFFECTS_PAINT: u32 = Self::INLINE_STYLE_PAINT

        | Self::STYLED_STATE;

    /// Returns true if no visual change occurred (only callbacks/dataset/a11y).

    /// Returns true if layout is needed.

    /// Returns true if paint is needed (but not necessarily layout).

}

impl core::ops::BitOrAssign for NodeChangeSet {

}

impl core::ops::BitOr for NodeChangeSet {

    type Output = Self;

}

/// Extended diff result that includes per-node change information.

#[derive(Debug, Clone)]

#[derive(Default)]

pub struct ExtendedDiffResult {

    /// Original diff result (lifecycle events + node moves).

    pub diff: DiffResult,

    /// Per-node change report for matched (moved) nodes.

    /// Each entry: (`old_node_id`, `new_node_id`, `what_changed`).

    /// Only contains entries for nodes that were matched.

    pub node_changes: Vec<(NodeId, NodeId, NodeChangeSet)>,

}

/// Compare two matched `NodeData` instances field-by-field and return

/// a `NodeChangeSet` describing what changed.

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

    // 1. Node type discriminant

    {

    // 2. Content-specific comparison (same discriminant)

        }

            // Use Hash-based comparison (pointer identity for decoded images,

            // callback identity for callback images)

            use core::hash::Hasher;

        }

    }

    // 3. IDs and classes (now stored in attributes as AttributeType::Id/Class)

    {

        use crate::dom::AttributeType;

    }

    // 4. Inline CSS properties — classify into layout-affecting vs paint-only.

    // After the inline-vs-component unification, inline CSS is stored as a `Css`

    // with rule blocks; iterate it via the `(property, conditions)` flat view to

    // keep the per-property compare semantics this code was written for.

        // Classify a changed/added/removed property into the layout vs paint bucket.

        #[allow(clippy::items_after_statements)]

        // AUDIT: key the diff by (prop_type, conditions), NOT prop_type alone.

        // A node can carry the same property under different conditions (e.g.

        // `color: red` and `color: blue` scoped to `:hover`); keying by

        // prop_type collapsed them into one map slot, so a change to one

        // conditional variant could be silently dropped. Match each new

        // property against an old entry with the SAME prop_type AND the same

        // conditions, and mark any old entry left unmatched as removed.

            // Find an as-yet-unmatched old entry with the same (type, conditions).

                {

            }

            // Unchanged only when we matched an old (type, conditions) slot whose

            // value is identical; otherwise the property was added or changed.

        }

        // Check for removed properties (old (type, conditions) slots never matched)

        }

    // 5. Callbacks

    {

            }

    }

    // 6. Dataset

    // 7. Contenteditable

    // 8. Tab index

    // 9. Styled node state (hover, active, focused, etc.)

/// Calculate the reconciliation key for a node using the priority hierarchy:

/// 1. Explicit key (set via `.with_key()`)

/// 2. CSS ID (set via `.with_id("my-id")`)

/// 3. Structural key: nth-of-type-within-parent + parent's reconciliation key

///

/// The structural key prevents incorrect matching when nodes are inserted

/// before existing nodes (e.g., prepending items to a list) and allows

/// keyless nodes to be matched across frames when their logical position

/// and type are stable (even if content changed — which then fires an

/// `Update` lifecycle event, see `reconcile_dom`).

///

/// When `hierarchy` is empty (or this node has no entry), the structural

/// key degrades to `discriminant(node_type) + classes` — parent/nth-of-type

/// context simply drops out. This lets callers that don't track hierarchy

/// (tests, flat-DOM scenarios) still benefit from explicit-key and CSS-ID

/// matching without divergent behavior.

    use core::hash::Hasher;

    // Terminal (parent-independent) key for a node: Priority 1 explicit key,

    // else Priority 2 CSS ID, else `None` (structural — needs the parent chain).

        // Priority 1: Explicit key

        // Priority 2: CSS ID

        }

    // Fast path: the node itself has an explicit key or CSS ID.

    // Priority 3: structural key, computed ITERATIVELY up the parent chain.

    //

    // AUDIT: the previous implementation recursed once per ancestor with no

    // depth cap and no cycle guard, so a deep DOM overflowed the stack and a

    // corrupt (cyclic) hierarchy recursed forever — and `precompute_*` calls

    // this once per node. Walk upward instead, bounded by the node count.

    //

    // Collect the structural chain from `node_id` upward. The walk stops at:

    //   - the root (a node with no parent) — structural base is just

    //     `discriminant + classes`,

    //   - a terminal (explicit-key / CSS-ID) ancestor, whose key seeds the fold, or

    //   - `n` iterations (a valid parent chain is at most `n` long, so exceeding

    //     that means the hierarchy is cyclic/corrupt — stop).

            }

        }

    }

    // Fold from the topmost ancestor down to `node_id`. `parent_key` threads the

    // accumulated key of the level above (identical to the old recursion, just

    // unrolled bottom-up).

        }

        {

            // nth-of-type: count same-discriminant siblings before `nid`.

            }

    }

/// Precompute reconciliation keys for every node in a DOM tree.

///

/// Called once per side (old/new) at the start of `reconcile_dom`. Returns a

/// vector indexed by node index (`keys[node_id.index()]`) so lookup during

/// reconciliation is O(1).

/// Represents a mapping between a node in the old DOM and the new DOM.

#[derive(Debug, Clone, Copy)]

pub struct NodeMove {

    /// The `NodeId` in the old DOM array

    pub old_node_id: NodeId,

    /// The `NodeId` in the new DOM array

    pub new_node_id: NodeId,

}

/// The result of a DOM diff, containing lifecycle events and node mappings.

#[derive(Debug, Clone)]

#[derive(Default)]

pub struct DiffResult {

    /// Lifecycle events generated by the diff (Mount, Unmount, Resize, Update)

    pub events: Vec<SyntheticEvent>,

    /// Maps Old `NodeId` -> New `NodeId` for state migration (focus, scroll, etc.)

    pub node_moves: Vec<NodeMove>,

}

/// Calculates the difference between two DOM frames and generates lifecycle events.

///

/// This is the main entry point for DOM reconciliation. It compares the old and new

/// DOM trees and produces:

/// - Mount events for new nodes

/// - Unmount events for removed nodes

/// - Resize events for nodes whose bounds changed

/// - Update events for nodes whose logical position is stable but content changed

///

/// # Matching priority

/// For every node, the reconciliation key (`calculate_reconciliation_key`) encodes

/// Priority 1 (`.with_key()`), Priority 2 (CSS ID), and Priority 3 (structural key:

/// nth-of-type + parent key). The tiers are then tried in order:

///

/// 1. **Reconciliation key** — matches logical identity, may fire Update on content change.

/// 2. **Content hash** — exact match including content; catches pure reorders of anonymous nodes.

/// 3. **Structural hash** — matches node type + attrs ignoring text content; for text-edit cases.

///

/// # Arguments

/// * `old_node_data` / `new_node_data` - Per-node data for each frame

/// * `old_hierarchy` / `new_hierarchy` - Parent/sibling pointers. Pass `&[]` if unavailable;

///   the structural-key branch of the reconciliation key degrades gracefully.

/// * `old_layout` / `new_layout` - Layout bounds used to detect Resize events

/// * `dom_id` - The DOM identifier

/// * `timestamp` - Current timestamp for events

#[allow(clippy::needless_pass_by_value)] // owned azul value taken by value (public API / ownership-transfer convention)

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

    // Helper: pop the first non-consumed NodeId from a queue.

        }

    // --- STEP 1: INDEX THE OLD DOM ---

    //

    // Three tiers, in priority order:

    //   Tier 1: reconciliation key (.with_key() / CSS ID / structural key)

    //   Tier 2: content hash (exact node_data hash — matches pure reorders)

    //   Tier 3: structural hash (discriminant + attrs, ignores text — matches text edits)

    //

    // Each tier is keyed with a `VecDeque<NodeId>` because all three can legitimately

    // collide (two sibling divs produce the same structural key, two identical nodes

    // produce the same content hash, etc.); we consume in document order on match.

    // AUDIT: precompute NEW keys too so the Tier-2/Tier-3 keyless tiers can be

    // gated on parent-key agreement (see STEP 2). Also lets Tier 1 look the key

    // up instead of recomputing it per node.

    // Reconciliation key of a node's PARENT (`None` for a root or when the

    // hierarchy is unavailable). Used to keep keyless matches from migrating

    // focus/scroll/dataset state across different parents.

    // --- STEP 2: ITERATE NEW DOM AND CLAIM MATCHES ---

        // Tier 1: Reconciliation key (explicit `.with_key()`, CSS ID, or structural key)

        // AUDIT: parent-key of the new node. The keyless Tier-2/Tier-3 tiers are

        // only allowed to claim an old node whose parent's reconciliation key

        // agrees — otherwise two structurally-identical nodes under DIFFERENT

        // parents would match and migrate focus/scroll/dataset state to an

        // unrelated subtree. When either hierarchy is unavailable this is `None`

        // on both sides, so the gate is a no-op (flat-DOM behavior preserved).

        // An explicit `.with_key()` is a strong, intentional identity marker: if it

        // doesn't match anything in the old DOM we treat the new node as genuinely

        // new (Mount), rather than falling through to coarser content/structural

        // tiers and silently matching an unrelated node.

            // Tier 2: Content hash (exact match — catches pure reorders)

            // Tier 3: Structural hash (text-node fallback — ignores text content)

        // --- STEP 3: PROCESS MATCH OR MOUNT ---

            // FOUND A MATCH (It might be at a different index, but it's the "same" node)

            // Check for Resize

                // Fire Resize Event

            // Fire Update when the node was matched by logical identity (reconciliation

            // key: explicit .with_key(), CSS ID, or structural key) but its content hash

            // differs. Tier-2/Tier-3 matches by definition don't carry an Update — a

            // content-hash match is content-identical, and a structural-hash match is

            // a text edit handled by cursor/text reconciliation elsewhere.

        } else {

            // NO MATCH FOUND -> MOUNT (New Node)

        }

    }

    // --- STEP 4: CLEANUP (UNMOUNTS) ---

    // Any old node that wasn't claimed is effectively destroyed.

    }

/// Creates a lifecycle event with all necessary fields.

/// Check if the node has an `AfterMount` callback registered.

            EventFilter::Component(ComponentEventFilter::AfterMount)

        )

/// Check if the node has a `BeforeUnmount` callback registered.

            EventFilter::Component(ComponentEventFilter::BeforeUnmount)

        )

/// Check if the node has a `NodeResized` callback registered.

            EventFilter::Component(ComponentEventFilter::NodeResized)

        )

/// Check if the node has any lifecycle callback that would respond to updates.

            EventFilter::Component(ComponentEventFilter::Updated)

        )

/// Migrate state (focus, scroll, etc.) from old node IDs to new node IDs.

///

/// This function should be called after reconciliation to update any state

/// that references old `NodeIds` to use the new `NodeIds`.

///

/// # Example

/// ```rust,ignore

/// let diff = reconcile_dom(...);

/// let migration_map = create_migration_map(&diff.node_moves);

/// 

/// // Migrate focus

/// if let Some(current_focus) = focus_manager.focused_node {

///     if let Some(&new_id) = migration_map.get(&current_focus) {

///         focus_manager.focused_node = Some(new_id);

///     } else {

///         // Focused node was unmounted, clear focus

///         focus_manager.focused_node = None;

///     }

/// }

/// ```

/// Executes state migration between the old DOM and the new DOM based on diff results.

///

/// This iterates through matched nodes. If a match has BOTH a merge callback AND a dataset,

/// it executes the callback to transfer state from the old node to the new node.

///

/// This must be called **before** the old DOM is dropped, because we need to access its data.

///

/// # Arguments

/// * `old_node_data` - Mutable reference to the old DOM's node data (source of heavy state)

/// * `new_node_data` - Mutable reference to the new DOM's node data (target for heavy state)

/// * `node_moves` - The matched nodes from the reconciliation diff

///

/// # Example

/// ```rust,ignore

/// let diff_result = reconcile_dom(&old_data, &new_data, ...);

/// 

/// // Execute state migration BEFORE old_dom is dropped

/// transfer_states(&mut old_data, &mut new_data, &diff_result.node_moves);

/// 

/// // Now safe to drop old_dom - heavy resources have been transferred

/// drop(old_dom);

/// ```

    use crate::refany::OptionRefAny;

        // Bounds check

        // 1. Check if the NEW node has requested a merge callback

        };

        // 2. Check if BOTH nodes have datasets

        // We need to temporarily take the datasets to satisfy borrow checker

                // The fresh DOM's dataset allocation. A widget builds its dataset,

                // its VirtualView content `refany`, AND its event-callback

                // `refany`s from clones of ONE `RefAny` — so every one shares THIS

                // allocation (`RefAny::clone` shares `sharing_info`; only the

                // per-clone `instance_id` differs). The merge below keeps the

                // PERSISTENT (old) allocation (e.g. MapWidget shares its tile cache

                // so background fetch threads keep writing into it), so every clone

                // of the fresh one is now orphaned and must be re-pointed — or the

                // widget fragments across two caches: the VirtualView rendered an

                // empty clone (blank/grey tiles) while the live data sat in the

                // dataset, and pan/zoom mutated yet a third copy. Identity = the

                // shared `RefCountInner` pointer (`sharing_info.ptr`).

                // 3. EXECUTE THE MERGE CALLBACK

                // The callback receives both datasets and returns the merged result

                // 4. Store the merged result back in the new node

                // 5. UNIFY: re-point every refany across the NEW DOM that was a

                // clone of the now-discarded fresh dataset onto the merged result,

                // so the whole widget reads ONE cache. Covers VirtualView content

                // refanys + event-callback refanys + any node's dataset cloned

                // from the same source. (Generalises the old special-case that

                // only re-pointed a VirtualView ON the merge node itself — the

                // MapWidget puts its VirtualView in a CHILD and its pan/zoom

                // callbacks on the parent, which that case missed.)

                    }

                }

            }

                // One or both datasets missing - restore what we had

            }

        }

    }

/// Calculate a stable key for a contenteditable node using the hierarchy:

///

/// 1. **Explicit Key** - If `.with_key()` was called, use that

/// 2. **CSS ID** - If the node has a CSS ID (e.g., `#my-editor`), hash that

/// 3. **Structural Key** - Hash of `(nth-of-type, parent_key)` recursively

///

/// The structural key prevents shifting when elements are inserted before siblings.

/// For example, in `<div><p>A</p><p contenteditable>B</p></div>`, if we insert

/// a new `<p>` at the start, the contenteditable `<p>` becomes nth-child(3) but

/// its nth-of-type stays stable (it's still the 2nd `<p>`).

///

/// # Arguments

/// * `node_data` - All nodes in the DOM

/// * `hierarchy` - Parent-child relationships

/// * `node_id` - The node to calculate the key for

///

/// # Returns

/// A stable u64 key for the node

    use core::hash::Hasher;

    // Terminal (parent-independent) key: Priority 1 explicit key, else

    // Priority 2 CSS ID, else `None` (structural — needs the parent chain).

        // Priority 1: Explicit key (from .with_key())

        // Priority 2: CSS ID

        }

    // Fast path: the node itself has an explicit key or CSS ID.

    // Priority 3: structural key, computed ITERATIVELY up the parent chain.

    //

    // AUDIT: replaces unbounded parent-chain recursion (stack overflow on deep

    // DOMs, infinite recursion on a cyclic hierarchy). Same fold as the old

    // recursion, unrolled bottom-up and bounded by the node count.

            }

        }

    }

    // Fold from the topmost ancestor down to `node_id`. Unlike the

    // reconciliation key, the contenteditable structural key ALWAYS writes a

    // `parent_key` (0 at the root) and an `nth_of_type` (0 at the root), so the

    // per-level hashing is unconditional — preserve that exactly.

        // parent_key: 0 at the root, else the accumulated key of the level above.

        // nth-of-type: count same-discriminant siblings before `nid`.

            }

        // Hash the node type discriminant (Discriminant<T> implements Hash)

        // Also hash the classes for additional stability

        }

    }

/// Reconcile cursor byte position when text content changes.

///

/// This function maps a cursor position from old text to new text, preserving

/// the cursor's logical position as much as possible:

///

/// 1. If cursor is in unchanged prefix → stays at same byte offset

/// 2. If cursor is in unchanged suffix → adjusts by length difference

/// 3. If cursor is in changed region → places at end of new content

///

/// # Arguments

/// * `old_text` - The previous text content

/// * `new_text` - The new text content

/// * `old_cursor_byte` - Cursor byte offset in old text

///

/// # Returns

/// The reconciled cursor byte offset in new text

///

/// # Example

/// ```rust,ignore

/// let old_text = "Hello";

/// let new_text = "Hello World";

/// let old_cursor = 5; // cursor at end of "Hello"

/// let new_cursor = reconcile_cursor_position(old_text, new_text, old_cursor);

/// assert_eq!(new_cursor, 5); // cursor stays at same position (prefix unchanged)

/// ```

    // AUDIT: every returned offset is snapped DOWN to the nearest UTF-8 char

    // boundary in `new_text` (and clamped to its length). The prefix/suffix

    // scans below compare byte-by-byte and can land mid-codepoint, so a raw

    // return value could later panic when used to slice `new_text` as a `str`.

    // If texts are equal, cursor is unchanged

    // Empty old text - place cursor at end of new text

    // Empty new text - place cursor at 0

    // Find common prefix (how many bytes from the start are identical)

    // If cursor was in the unchanged prefix, it stays at the same byte offset

    // Find common suffix (how many bytes from the end are identical)

    // Calculate where the suffix starts in old and new text

    // If cursor was in the unchanged suffix, adjust by length difference

        // saturating: an out-of-range cursor (> old_text.len()) must clamp to the

        // end of the new text like every other path here, not underflow-panic.

    // Cursor was in the changed region - place at end of inserted content

    // This handles insertions (cursor moves with new text) and deletions (cursor at edit point)

/// Get the text content from a `NodeData` if it's a Text node.

///

/// Returns the text string if the node is `NodeType::Text`, otherwise `None`.

    } else {

    }

// ============================================================================

// ChangeAccumulator — unifies all change input paths

// ============================================================================

/// Text change info for cursor/selection reconciliation.

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct TextChange {

    /// The text content before the change.

    pub old_text: String,

    /// The text content after the change.

    pub new_text: String,

}

/// 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>,

}

impl NodeChangeReport {

    /// Returns the `DirtyFlag` level needed for this change report.

    /// Maps `RelayoutScope` + `NodeChangeSet` → a simple tri-state.

}

/// Unified change report that merges information from all three change paths:

///

/// 1. **DOM reconciliation** (`compute_node_changes` after `reconcile_dom`)

/// 2. **CSS restyle** (`restyle_on_state_change` for hover/focus/active)

/// 3. **Runtime edits** (`words_changed`, `css_properties_changed`, `images_changed`)

///

/// This is the single source of truth for "what work needs to happen this frame".

#[derive(Debug, Clone, Default)]

pub struct ChangeAccumulator {

    /// Per-node change info. Key is the new-DOM `NodeId`.

    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,

    /// Nodes that are newly mounted (no old counterpart).

    /// These always need full 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>,

}

impl ChangeAccumulator {

    /// Returns true if no changes were detected at all.

    /// Returns true if layout work is needed (any node has scope > None).

    /// Returns true if only paint work is needed (no layout).

    /// Returns true if only non-visual changes occurred (callbacks, dataset, a11y).

    /// Add a node change from DOM reconciliation (Path A).

    /// Add a text change (from runtime edit or DOM reconciliation).