//! Handling Viewport Resizing and Layout Thrashing

//!

//! The viewport size is a fundamental input to the entire layout process.

//! A change in viewport size must trigger a relayout.

//!

//! 1. The `layout_document` function takes the `viewport` as an argument. The `LayoutCache` stores

//!    the `viewport` from the previous frame.

//! 2. The `reconcile_and_invalidate` function detects that the viewport has changed size

//! 3. This single change—marking the root as a layout root—forces a full top-down pass

//!    (`calculate_layout_for_subtree` starting from the root). This correctly recalculates all

//!    percentage-based sizes and repositions all elements according to the new viewport dimensions.

//! 4. The intrinsic size calculation (bottom-up) can often be skipped, as it's independent of the

//!    container size, which is a significant optimization.

use std::{

    collections::{BTreeMap, BTreeSet, HashMap},

    hash::{DefaultHasher, Hash, Hasher},

};

/// Floating-point comparison epsilon for cache size lookups.

/// Controls the tolerance for cache hit matching in the per-node multi-slot cache.

const CACHE_SIZE_EPSILON: f32 = 0.1;

use azul_core::{

    diff::NodeDataFingerprint,

    dom::{FormattingContext, NodeId, NodeType},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    styled_dom::{StyledDom, StyledNode},

};

use azul_css::{

    css::CssPropertyValue,

    props::{

        layout::{

            LayoutDisplay, LayoutFlexWrap, LayoutHeight, LayoutJustifyContent, LayoutOverflow,

            LayoutPosition, LayoutWritingMode,

        },

        property::{CssProperty, CssPropertyType},

        style::StyleTextAlign,

    },

    LayoutDebugMessage, LayoutDebugMessageType,

};

use crate::{

    font_traits::{FontLoaderTrait, ParsedFontTrait, TextLayoutCache},

    solver3::{

        fc::{self, layout_formatting_context, LayoutConstraints, OverflowBehavior},

        geometry::PositionedRectangle,

        getters::{

            get_css_height, get_display_property, get_justify_content, get_overflow_x,

            get_overflow_y, get_scrollbar_gutter_property, get_text_align, get_white_space_property, get_wrap, get_writing_mode,

            MultiValue,

        },

        layout_tree::{

            get_display_type, is_block_level, AnonymousBoxType, DirtyFlag, LayoutNode, LayoutNodeHot, LayoutTreeBuilder, SubtreeHash,

        },

        positioning::get_position_type,

        scrollbar::ScrollbarRequirements,

        sizing::calculate_used_size_for_node,

        LayoutContext, LayoutError, LayoutTree, Result,

    },

    text3::cache::AvailableSpace as Text3AvailableSpace,

};

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

// Per-Node Multi-Slot Cache (inspired by Taffy's 9+1 slot cache architecture)

//

// Instead of a global BTreeMap keyed by (node_index, available_size), each node

// gets its own deterministic cache with 9 measurement slots + 1 full layout slot.

// This eliminates O(log n) lookups, prevents slot collisions between MinContent/

// MaxContent/Definite measurements, and cleanly separates sizing from positioning.

//

// Reference: https://github.com/DioxusLabs/taffy — Cache struct in src/tree/cache.rs

// Azul improvement: cache is EXTERNAL (Vec<NodeCache> parallel to LayoutTree.nodes)

// rather than stored on the node, keeping LayoutNode slim and avoiding &mut tree

// for cache operations.

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

/// Determines whether `calculate_layout_for_subtree` should only compute

/// the node's size (for parent's sizing pass) or perform full layout

/// including child positioning.

///

/// Inspired by Taffy's `RunMode` enum. The two-mode approach enables the

/// classic CSS two-pass layout: Pass 1 (ComputeSize) measures all children,

/// Pass 2 (PerformLayout) positions them using the measured sizes.

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

pub enum ComputeMode {

    /// Only compute the node's border-box size and baseline.

    /// Does NOT store child positions. Used in BFC Pass 1 (sizing).

    ComputeSize,

    /// Compute size AND position all children.

    /// Stores the full layout result including child positions.

    /// Used in BFC Pass 2 (positioning) and as the final layout step.

    PerformLayout,

}

/// Constraint classification for deterministic cache slot selection.

///

/// Inspired by Taffy's `AvailableSpace` enum. Each constraint type maps to a

/// different cache slot, preventing collisions between e.g. MinContent and

/// Definite measurements of the same node.

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

pub enum AvailableWidthType {

    /// A definite pixel value (or percentage resolved to pixels).

    Definite,

    /// Shrink-to-fit: the smallest size that doesn't cause overflow.

    MinContent,

    /// Use all available space: the largest size the content can use.

    MaxContent,

}

/// Cache entry for sizing (ComputeSize mode) — stores NO positions.

///

/// This is the lightweight entry stored in the 9 measurement slots.

/// It records what constraints were provided and what size resulted,

/// enabling Taffy's "result matches request" optimization.

#[derive(Debug, Clone)]

pub struct SizingCacheEntry {

    /// The available size that was provided as input.

    pub available_size: LogicalSize,

    /// The computed border-box size (output).

    pub result_size: LogicalSize,

    /// Baseline for inline alignment (if applicable).

    pub baseline: Option<f32>,

    /// First child's escaped top margin (CSS 2.2 § 8.3.1).

    pub escaped_top_margin: Option<f32>,

    /// Last child's escaped bottom margin (CSS 2.2 § 8.3.1).

    pub escaped_bottom_margin: Option<f32>,

}

/// Cache entry for full layout (PerformLayout mode).

///

/// This is the single "final layout" slot. It includes child positions

/// (relative to parent's content-box) and overflow/scrollbar info.

#[derive(Debug, Clone)]

pub struct LayoutCacheEntry {

    /// The available size that was provided as input.

    pub available_size: LogicalSize,

    /// The computed border-box size (output).

    pub result_size: LogicalSize,

    /// Content overflow size (for scrolling).

    pub content_size: LogicalSize,

    /// Child positions relative to parent's content-box (NOT absolute).

    pub child_positions: Vec<(usize, LogicalPosition)>,

    /// First child's escaped top margin.

    pub escaped_top_margin: Option<f32>,

    /// Last child's escaped bottom margin.

    pub escaped_bottom_margin: Option<f32>,

    /// Scrollbar requirements for this node.

    pub scrollbar_info: ScrollbarRequirements,

}

/// Per-node cache entry with 9 measurement slots + 1 full layout slot.

///

/// Inspired by Taffy's `Cache` struct (9+1 slots per node). The deterministic

/// slot index is computed from the constraint combination, so entries never

/// clobber each other (unlike the old global BTreeMap where fixed-point

/// collisions were possible).

///

/// NOT stored on LayoutNode — lives in the external `LayoutCacheMap`.

#[derive(Debug, Clone)]

pub struct NodeCache {

    /// 9 measurement slots (Taffy's deterministic scheme):

    /// - Slot 0: both dimensions known

    /// - Slots 1-2: only width known (MaxContent/Definite vs MinContent)

    /// - Slots 3-4: only height known (MaxContent/Definite vs MinContent)

    /// - Slots 5-8: neither known (2×2 combos of width/height constraint types)

    pub measure_entries: [Option<SizingCacheEntry>; 9],

    /// 1 full layout slot (with child positions, overflow, baseline).

    /// Only populated after PerformLayout, not after ComputeSize.

    pub layout_entry: Option<LayoutCacheEntry>,

    /// Fast check for dirty propagation (Taffy optimization).

    /// When true, all slots are empty — ancestors are also dirty.

    pub is_empty: bool,

}

impl Default for NodeCache {

}

impl NodeCache {

    /// Clear all cache entries, marking this node as dirty.

    /// Compute the deterministic slot index from constraint dimensions.

    ///

    /// This is Taffy's slot selection scheme: given whether width/height are

    /// "known" (definite constraint provided by parent) and what type of

    /// constraint applies to the unknown dimension(s), we get a unique slot 0–8.

            (true, false) => {

            }

            (false, true) => {

            }

            (false, false) => {

            }

        }

    /// Look up a sizing cache entry, implementing Taffy's "result matches request"

    /// optimization: if the caller provides the result size as a known dimension

    /// (common in Pass1→Pass2 transitions), it's still a cache hit.

        // Exact match on input constraints

        {

        // "Result matches request" — if the caller provides the result size

        // as a known dimension, it's still a hit. This is the key optimization

        // that makes two-pass layout O(n): Pass 1 measures a node, Pass 2

        // provides the measured size as a constraint → automatic cache hit.

        {

    /// Store a sizing result in the given slot.

    /// Look up the full layout cache entry.

        {

        // "Result matches request" for layout too

        {

    /// Store a full layout result.

}

/// External layout cache, parallel to `LayoutTree.nodes`.

///

/// `cache_map.entries[i]` holds the cache for `LayoutTree.nodes[i]`.

/// Stored on `LayoutCache` (persists across frames).

///

/// This is Azul's improvement over Taffy's on-node cache:

/// - `LayoutNode` stays slim (0 bytes overhead)

/// - No `&mut tree` needed to read/write cache entries

/// - Cache can be resized independently after reconciliation

/// - O(1) indexed lookup (Vec) instead of O(log n) (BTreeMap)

#[derive(Debug, Clone, Default)]

pub struct LayoutCacheMap {

    pub entries: Vec<NodeCache>,

}

impl LayoutCacheMap {

    /// Resize to match tree length after reconciliation.

    /// New nodes get empty (dirty) caches. Removed nodes' caches are dropped.

    /// O(1) lookup by layout tree index.

    #[inline]

    /// O(1) mutable lookup by layout tree index.

    #[inline]

    /// Invalidate a node and propagate dirty flags upward through ancestors.

    ///

    /// Implements Taffy's early-stop optimization: propagation halts at the

    /// first ancestor whose cache is already empty (i.e., already dirty).

    /// This prevents redundant O(depth) propagation when multiple children

    /// of the same parent are dirtied.

        // Propagate upward (Taffy's early-stop optimization)

        }

}

/// The persistent cache that holds the layout state between frames.

#[derive(Debug, Clone, Default)]

pub struct LayoutCache {

    /// The fully laid-out tree from the previous frame. This is our primary cache.

    pub tree: Option<LayoutTree>,

    /// The final, absolute positions of all nodes from the previous frame.

    pub calculated_positions: super::PositionVec,

    /// The viewport size from the last layout pass, used to detect resizes.

    pub viewport: Option<LogicalRect>,

    /// Stable scroll IDs computed from node_data_hash (layout index -> scroll ID)

    pub scroll_ids: HashMap<usize, u64>,

    /// Mapping from scroll ID to DOM NodeId for hit testing

    pub scroll_id_to_node_id: HashMap<u64, NodeId>,

    /// CSS counter values for each node and counter name.

    /// Key: (layout_index, counter_name), Value: counter value

    /// This stores the computed counter values after processing counter-reset and

    /// counter-increment.

    pub counters: HashMap<(usize, String), i32>,

    /// Cache of positioned floats for each BFC node (layout_index -> FloatingContext).

    /// This persists float positions across multiple layout passes, ensuring IFC

    /// children always have access to correct float exclusions even when layout is

    /// recalculated.

    pub float_cache: HashMap<usize, fc::FloatingContext>,

    /// Per-node multi-slot cache (inspired by Taffy's 9+1 architecture).

    /// External to LayoutTree — indexed by node index for O(1) lookup.

    /// Persists across frames; resized after reconciliation.

    pub cache_map: LayoutCacheMap,

    /// Snapshot of calculated_positions from the previous frame, used by the

    /// compositor to compute damage rects (old bounds vs new bounds).

    pub previous_positions: super::PositionVec,

    /// Cached display list keyed by `(root_subtree_hash, viewport)`.

    /// When the reconciled tree has the same root subtree_hash AND

    /// the same viewport as the cached one, the display list is

    /// returned as-is — skipping layout, positioning, and

    /// display-list generation entirely. Cleared whenever

    /// `mark_dirty` fires on any node (since the root's upstream

    /// invalidation chain clears its ancestors).

    pub cached_display_list: Option<(SubtreeHash, LogicalRect, super::display_list::DisplayList)>,

    /// Raw pointer of the StyledDom from the previous layout pass. When the

    /// same `&StyledDom` reference is passed again AND the viewport is unchanged,

    /// skip reconcile entirely and return the cached display list (saves ~0.8 ms).

    pub prev_dom_ptr: usize,

    pub prev_viewport: LogicalRect,

}

/// Approximate heap-byte breakdown of the solver3 LayoutCache.

#[derive(Debug, Clone, Default)]

pub struct Solver3CacheMemoryReport {

    pub tree_bytes: usize,

    pub tree_report: Option<super::layout_tree::LayoutTreeMemoryReport>,

    pub calculated_positions_bytes: usize,

    pub previous_positions_bytes: usize,

    pub scroll_ids_bytes: usize,

    pub scroll_id_to_node_id_bytes: usize,

    pub counters_bytes: usize,

    pub float_cache_bytes: usize,

    pub cache_map_bytes: usize,

    pub cached_display_list_bytes: usize,

}

impl Solver3CacheMemoryReport {

}

impl LayoutCache {

    /// Drop all incremental-reuse state so the next `layout_document` lays the

    /// DOM out from scratch (cold path), as if no previous frame existed.

    ///

    /// Required before laying out a DOM whose NodeIds are NOT a stable evolution

    /// of whatever this (shared) cache last held — namely VirtualView / iframe

    /// child DOMs, which their callbacks rebuild wholesale on every invocation.

    /// Incremental reconciliation matches/reuses subtrees by NodeId + subtree

    /// hash; on a wholesale rebuild those NodeIds are reassigned, so reusing the

    /// prior tree can graft NodeIds that no longer exist in the new StyledDom

    /// (panic: out-of-bounds node_data index when the DOM shrinks — e.g. the map

    /// dropping tiles on zoom-out).

    /// Approximate heap bytes retained by this LayoutCache.

        // cache_map: Vec<NodeCache>; NodeCache has 9 Option<SizingCacheEntry>

        // + 1 Option<LayoutCacheEntry>. Count filled layout entries' child_positions.

        }

        Solver3CacheMemoryReport {

        }

}

/// The result of a reconciliation pass.

#[derive(Debug, Default)]

pub struct ReconciliationResult {

    /// Set of nodes whose intrinsic size needs to be recalculated (bottom-up pass).

    pub intrinsic_dirty: BTreeSet<usize>,

    /// Set of layout roots whose subtrees need a new top-down layout pass.

    pub layout_roots: BTreeSet<usize>,

    /// Set of nodes that only need a paint/display-list update (no relayout).

    pub paint_dirty: BTreeSet<usize>,

}

impl ReconciliationResult {

    /// Checks if any layout or paint work is needed.

    /// Returns true if full layout work is needed for at least one node.

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

}

/// After dirty subtrees are laid out, this repositions their clean siblings

/// without recalculating their internal layout. This is a critical optimization.

///

/// This function acts as a dispatcher, inspecting the parent's formatting context

/// and calling the appropriate repositioning algorithm. For complex layout modes

/// like Flexbox or Grid, this optimization is skipped, as a full relayout is

/// often required to correctly recalculate spacing and sizing for all siblings.

    // Find the unique parents of all dirty layout roots. These are the containers

    // where sibling positions need to be adjusted.

    }

        };

        // Dispatch to the correct repositioning logic based on the parent's layout mode.

            // Cases that use simple block-flow stacking can be optimized.

            // Other contexts either don't contain children in a way that this

            // optimization applies (e.g., Inline, TableCell) or are handled by other

            // layout mechanisms (e.g., OutOfFlow).

        }

    }

/// Convert LayoutOverflow to OverflowBehavior

/// CSS Overflow Module Level 3: initial value of `overflow` is `visible`.

// +spec:overflow:3a6297 - initial value 'visible', maps hidden/scroll/auto overflow behaviors

    }

/// Convert StyleTextAlign to fc::TextAlign

// +spec:text-alignment-spacing:43ea0a - text-align-all shorthand: aligns all lines except last (overridden by text-align-last)

    }

/// Collects DOM child IDs from the node hierarchy into a Vec.

///

/// This is a helper function that flattens the sibling iteration into a simple loop.

/// Children with `display: none` are filtered out since they generate no boxes.

    };

        // DEBUG (2026-06-02 children-None): first_child_id returned None for this

        // parent → 0xC0000000 marker @0x40540+parent*4. REVERT before commit.

        unsafe {

        }

    };

    // +spec:display-property:9f02c6 - display:none elements generate no boxes

    // +spec:display-property:3b507e - display:none excludes subtree from box tree

        };

    }

    // DEBUG (2026-06-02 children-None): record collected child count per parent

    // @0x40540+parent*4 (0xCC00_00NN). N=0 with first_child Some ⇒ get_display_type

    // mis-lift skipped them; N>0 ⇒ walk works. REVERT before commit.

    unsafe {

    }

/// Checks if a flex container is simple enough to be treated like a block-stack for

/// repositioning.

    };

    // Must be a single-line flex container

    // Must be start-aligned, so there's no space distribution to recalculate.

        LayoutJustifyContent::FlexStart | LayoutJustifyContent::Start

    ) {

    // Crucially, no clean siblings can have flexible sizes, otherwise a dirty

    // sibling's size change could affect their resolved size.

    // NOTE: This check is expensive and incomplete. A more robust solution might

    // store flags on the LayoutNode indicating if flex factors are present.

    // For now, we assume that if a container *could* have complex flex behavior,

    // we play it safe and require a full relayout. This heuristic is a compromise.

    // To be truly safe, we'd have to check all children for flex-grow/shrink > 0.

/// Repositions clean children within a simple block-flow layout (like a BFC or a

/// table-row-group). It stacks children along the main axis, preserving their

/// previously calculated cross-axis alignment.

    };

    );

        };

            // This child was DIRTY and has been correctly repositioned.

            // Update the pen to the position immediately after this child.

            };

            } else {

            };

        } else {

            // This child is *clean*. Calculate its new position and shift its

            // entire subtree.

            };

            } else {

            };

            );

        }

    }

/// Helper to recursively shift the absolute position of a node and all its descendants.

/// Compares the new DOM against the cached tree, creating a new tree

/// and identifying which parts need to be re-laid out.

/// Count how many of the supplied DOM children would actually end up

/// in the layout tree. Mirrors the filters applied by

/// `LayoutTreeBuilder::build_recursive` so reconciliation can compare

/// like-for-like:

///

/// - `display: none` nodes are skipped entirely.

/// - In table structural contexts (table, row-group, row) whitespace

///   text nodes are skipped (CSS 2.2 §17.2.1, matches

///   `should_skip_for_table_structure`).

/// - Whitespace-only inline runs that sit between block siblings

///   collapse to zero boxes (CSS 2.2 §9.2.2.1).

///

/// The first two rules drop children unconditionally; the third only

/// fires on siblings surrounding a block-level child, so we detect it

/// by walking the run pairs. We do not build the runs — just count

/// survivors.

    use super::getters::{get_display_property, MultiValue};

    use super::layout_tree::{is_block_level, is_whitespace_only_text};

    };

        azul_css::props::layout::display::LayoutDisplay::Table

            | azul_css::props::layout::display::LayoutDisplay::InlineTable

            | azul_css::props::layout::display::LayoutDisplay::TableRowGroup

            | azul_css::props::layout::display::LayoutDisplay::TableHeaderGroup

            | azul_css::props::layout::display::LayoutDisplay::TableFooterGroup

            | azul_css::props::layout::display::LayoutDisplay::TableRow

    );

    // When parent has any block child, whitespace-only inline runs

    // surrounding blocks collapse. We approximate that by skipping

    // whitespace text whenever any block sibling exists.

        // display:none drops

        };

        // Table-structural whitespace drops.

        // Whitespace-only inline run collapse when mixed with blocks.

        {

    }

    // A viewport SIZE change invalidates every computed size: percentage, flex,

    // and absolute insets (top/right/bottom/left) all resolve against the

    // viewport / containing block. Incrementally reusing the cached layout tree

    // left out-of-flow and VirtualView nodes sized against the OLD viewport — e.g.

    // the map's absolutely-positioned container kept its old size, so a maximized

    // window showed tiles only in the original rect and grey everywhere else

    // (#9 "grey on resize"). On a size change, drop the cached tree so the whole

    // tree is laid out fresh against the new viewport. (Position-only moves keep

    // the incremental path.)

    } else {

    };

    // Clean up layout roots: if a parent is a layout root, its children don't need to be.

            }

    // layout_document's step marker is stuck at 1 (post-`?` not reached), the

    // lifted `?` mis-discriminated this Ok as Err (niche-Result mis-lift).

/// CSS 2.2 § 9.2.2.1: Checks whether an inline run consists entirely of

/// whitespace-only text nodes, in which case it should NOT generate an

/// anonymous IFC wrapper in a BFC mixed-content context.

///

/// This prevents whitespace between block elements from creating empty

/// anonymous blocks that take up vertical space (regression c33e94b0).

///

/// Exception: if the parent (or any ancestor) has `white-space: pre`,

/// `pre-wrap`, or `pre-line`, whitespace IS significant and the wrapper

/// must still be created.

    use azul_css::props::style::text::StyleWhiteSpace;

    // Check if the parent preserves whitespace

    };

    // If white-space preserves whitespace, don't strip

        Some(StyleWhiteSpace::Pre) | Some(StyleWhiteSpace::PreWrap) | Some(StyleWhiteSpace::PreLine)

    ) {

    // Check that every node in the run is a whitespace-only text node

                }

                _ => {

                }

            }

    }

/// Recursively traverses the new DOM and old tree, building a new tree and marking dirty nodes.

    }

    // Compute the new multi-field fingerprint instead of a single hash.

        )

    };

    // Compare fingerprints to determine what changed (Layout, Paint, or Nothing).

        None => {

        },

                // Cache the env check in a `OnceLock<bool>`: this branch

                // fires once per dirty node (hundreds on cold layout),

                // and a direct `env::var` is a mutex + hashmap lookup

                // on macOS (~100 ns/call) even when the env var is unset.

                static FP_DUMP_ENABLED: std::sync::OnceLock<bool> =

                    std::sync::OnceLock::new();

                    use std::sync::atomic::{AtomicUsize, Ordering};

                    static DUMPED: AtomicUsize = AtomicUsize::new(0);

            } else {

            }

        }

    };

    // M12.7: `|| old_tree.is_none()` — on COLD layout there is no old tree to

    // clone, so we MUST create a fresh node; taking the else-branch would hit

    // `ok_or(InvalidTree)` on a None old_tree. This is both semantically correct

    // AND robust against a mis-lifted `dirty_flag`/Option match (the suspected

    // niche-enum mis-discriminant) wrongly steering cold nodes into the else.

        );

        // Blockify replaced/inline flex-or-grid items (CSS Display 3 §2.7). The

        // full `process_node` build does this; this incremental path called

        // `create_node_from_dom` directly and skipped it, so a flex-item <img>

        // (e.g. the AzulPaint canvas) stayed inline and ignored flex-grow.

    } else {

        // Paint-only or clean: clone the old node (preserving layout cache)

        // If paint-only change, update the fingerprint and dirty flag

    };

    // reconcile_recursive sees it. 0 = correct (the first node); 64 (matching the

    // build-marker root_idx) = the usize return mis-reads here.

    // CRITICAL: For list-items, create a ::marker pseudo-element as the first child

    // This must be done after the node is created but before processing children

    // Per CSS Lists Module Level 3, ::marker is generated as the first child of list-items

    {

        use crate::solver3::getters::get_display_property;

    }

    // Reconcile children to check for structural changes and build the new tree structure.

    // CSS 2.2 §17.2.1: Filter whitespace-only text nodes from table structural elements

    // (table, row-group, row). Without this, the reconciler sees them as "inline" children

    // mixed with block-level <td>/<th>, triggering incorrect anonymous IFC wrapping.

    // The layout tree builder already does this via should_skip_for_table_structure().

    {

        use super::getters::{get_display_property, MultiValue};

        };

            azul_css::props::layout::display::LayoutDisplay::Table

            | azul_css::props::layout::display::LayoutDisplay::InlineTable

            | azul_css::props::layout::display::LayoutDisplay::TableRowGroup

            | azul_css::props::layout::display::LayoutDisplay::TableHeaderGroup

            | azul_css::props::layout::display::LayoutDisplay::TableFooterGroup

            | azul_css::props::layout::display::LayoutDisplay::TableRow

        ) {

    }

    // Compute both positional and DOM-keyed lookups for the old

    // tree's children. The DOM-keyed map is authoritative for

    // reconciliation (positional drifts every time the layout-tree

    // builder drops a DOM child — whitespace text, display:none,

    // table-structural whitespace — or inserts an anonymous

    // wrapper that isn't in the DOM).

    // Count of old layout children that correspond to a real DOM

    // node (exclude anonymous wrappers). This is what we compare

    // against the layout-relevant subset of new DOM children to

    // decide whether the structural shape actually changed.

    // Filter new DOM children to the subset the layout-tree builder

    // would actually emit. This mirrors `should_skip_for_table_structure`

    // and the `is_whitespace_only_inline_run` logic. Without this

    // filter, `children_are_different` fires on every reconcile

    // because the DOM has whitespace text nodes the layout tree

    // drops.

    // +spec:display-property:42f9c0 - anonymous block boxes wrap inline runs when block container has mixed block/inline children

    // CSS 2.2 Section 9.2.1.1: Anonymous Block Boxes

    // When a block container has mixed block/inline children, we must:

    // 1. Wrap consecutive inline children in anonymous block boxes

    // 2. Leave block-level children as direct children

    // CSS Flexbox §4 / Grid §6: every in-flow child of a flex/grid container

    // becomes a (blockified) flex/grid item. Anonymous-block wrapping of inline

    // runs is a BLOCK-container concept and must NOT apply here — otherwise an

    // inline-level child (e.g. an <img> with flex-grow, default display

    // inline-block) gets wrapped in an anonymous IFC block, so it's no longer a

    // direct flex item and its flex-grow is ignored (laid out 300×0). Processing

    // each child directly lets `blockify_node_display` (in create_node_from_dom)

    // see the flex/grid parent and blockify the child into a real flex item.

        LayoutDisplay::Flex

            | LayoutDisplay::InlineFlex

            | LayoutDisplay::Grid

            | LayoutDisplay::InlineGrid

    );

        // All children are inline (block container) OR the parent is a flex/grid

        // container (all children are direct items) — no anonymous boxes needed.

        // Process each child directly.

            // DOM-ID match rather than positional — tree builder

            // may have dropped some DOM children (whitespace text

            // nodes) so positional drift mis-aligns the cache.

            // DOM-id match only: positional fallback would align

            // anonymous wrappers against real DOM nodes and trigger

            // spurious fingerprint mismatches (see fp_diff dump).

        }

    } else {

        // Mixed content: block and inline children

        // We must create anonymous block boxes around consecutive inline runs

                // End current inline run if any

                    // CSS 2.2 § 9.2.2.1: If the inline run consists entirely of

                    // whitespace-only text nodes (and white-space doesn't preserve it),

                    // skip creating the anonymous IFC wrapper. This prevents inter-block

                    // whitespace from creating empty blocks that take up vertical space.

                    // +spec:display-property:bef3fc - anonymous blocks of only collapsible whitespace removed from rendering tree

                    } else {

                    // Create anonymous IFC wrapper for the inline run

                    // This wrapper establishes an Inline Formatting Context

                    );

                            anon_idx,

                        )));

                    // Process each inline child under the anonymous wrapper

                        // Inline children live under the anon wrapper

                        // in the old tree, so the parent's direct

                        // `old_children_by_dom` map won't hit them.

                        // Fall through to the global `dom_to_layout`

                        // map; we don't care which anon wrapper they

                        // were under, only that their cold data

                        // (fingerprint) gets matched correctly.

                    }

                    // NOTE: We intentionally do NOT unconditionally

                    // mark the anonymous wrapper as intrinsic_dirty

                    // here. If any of the inline children are

                    // themselves dirty, their own `mark_dirty` call

                    // propagates upward through this wrapper, so

                    // wrappers whose content is unchanged keep their

                    // cached layout. Setting `children_are_different`