//! 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 crate::solver3::layout_tree::LayoutNodeId;

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, LayoutHeight, 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_overflow_x,

            get_overflow_y, get_scrollbar_gutter_property, get_text_align, get_white_space_property, 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(Copy, 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.

    ///

    /// TODO(superplan): currently unused — the layout cache only ever touches

    /// slot 0 (see the `get_size(0, ..)` / `store_size(0, ..)` call sites). This

    /// is the intended entry point for wiring the full 9-slot scheme.

            (true, false) => {

            }

            (false, true) => {

            }

            (false, false) => {

            }

        }

    /// Classify a CONCRETE containing-block size into (measurement slot,

    /// canonicalized key). The call sites only have resolved `f32`s — the

    /// availability enums are gone by this depth — so "indefinite" is

    /// detected by value: non-finite or the ≥1e9 sentinel family.

    ///

    /// WHY THIS EXISTS (2026-08-08, measured on big.md): with everything

    /// collapsed onto slot 0, ~507 nodes were each sized TWICE per pass —

    /// the measure visit under an INDEFINITE height and the final visit

    /// under the resolved height — and the single slot ping-ponged between

    /// the two keys: 506 `h_qinf` + 508 `h_sinf` misses, a structural 100%

    /// miss rate on a pass where nothing changed. Separate slots per

    /// known/unknown combination make both visits hit from the second pass

    /// on; canonicalizing the indefinite axis to `f32::MAX` keeps the

    /// epsilon compare meaningful (`INFINITY - INFINITY` is NaN, which

    /// fails every `<` test and would turn a same-key lookup into a miss).

        const INDEFINITE: f32 = 1.0e9;

        );

        };

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

        // Valid only for a fully-definite query (both axes are real lengths),

        // and the matching entry may live in ANY slot — pass 1 stored its

        // result under the measure-constraint slot, not the definite one.

                {

            }

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

// Independent per-pass state FLAGS, not a state machine to enum-ify: each

// bool is set by a different stage and read by a different consumer.

#[allow(clippy::struct_excessive_bools)]

#[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>,

    /// One-shot latch: the next `layout_document` call is a RESIZE-ONLY

    /// relayout of the SAME `StyledDom` object (set by the dll's

    /// `incremental_relayout_for_resize`, consumed unconditionally at entry).

    /// Skips reconcile + `cache_map` remap wholesale — see the Step-1 branch

    /// in `layout_document` for the contract and the dom-id sanity guard.

    pub resize_only_hint: bool,

    /// Census: did the LAST `layout_document` take the resize-only

    /// reconcile-skip branch? The external observable that distinguishes

    /// "skipped the walk" from "walked and found everything clean" (both

    /// produce identical pixels and identical reuse censuses).

    pub last_reconcile_was_skipped: bool,

    /// The last reconcile RAN and preserved the tree's structure exactly —

    /// zero fresh nodes, zero drops, indices stable. Content changes (a text

    /// edit reflowing its IFC) land here, and it is what lets the per-IFC

    /// display-list patch engage for them: unchanged nodes splice their

    /// items from the previous DL, only reflowed IFCs re-emit.

    pub last_reconcile_structure_preserved: bool,

    /// Whether the last display-list BUILD went through the per-IFC patch

    /// (splice + re-emit) rather than a full emission — the honest marker

    /// the `dl_text_patch` law reads.

    pub last_build_was_patched: bool,

    /// The PRECISE damage of the last patched build (logical px): old ∪ new

    /// bounds of every re-emitted or moved/resized node. A patched build may

    /// change the ITEM COUNT (the new text emits different runs), which

    /// makes the renderer's old-vs-new item diff bail to a full repaint —

    /// but the patch knows exactly what it touched, so the renderers prefer

    /// this when the diff gives up. `None` after a full emission.

    pub last_patch_damage: Option<Vec<LogicalRect>>,

    /// The `DynamicSelectorContext` the cached display list was BUILT under.

    /// The structure-preserved patch arm requires the current context to be

    /// EQUAL: a cascade-external flip (viewport crossing an @media bound, a

    /// theme/OS change) restyles reused nodes without touching `NodeData` or

    /// `css_dirty`, so spliced items would serve the OLD styles (the

    /// blue-desktop-box-after-crossing-to-mobile bug).

    pub last_dynamic_context: Option<azul_css::dynamic_selector::DynamicSelectorContext>,

    /// `used_size` of every layout node as of the PREVIOUS pass — captured at

    /// the resize-skip branch (the pass overwrites `used_size` in the shared

    /// tree object). DL patching diffs these against the new sizes: a node

    /// whose size changed must re-emit its items (a translated background

    /// rect would be the wrong SIZE, not just the wrong place).

    pub previous_sizes: Vec<Option<LogicalSize>>,

    /// GRANULAR DIFF channel (task #15b, one-shot): per flattened `NodeId`,

    /// `true` = the pre-cascade DOM fingerprints proved this node AND every

    /// ancestor unchanged on BOTH tiers (structure + style). Reconcile may

    /// then reuse the old node's fingerprint after a cheap state-hash check

    /// instead of re-hashing node content — the diff feeds the later

    /// stages instead of being thrown away. Set by the dll's full-produce

    /// arm; consumed (taken) by `reconcile_and_invalidate`.

    pub dom_diff_clean: Option<Vec<bool>>,

    /// Census: fingerprint computations skipped via `dom_diff_clean` in the

    /// LAST reconcile — the external observable for the channel's tests.

    pub last_fingerprint_skips: usize,

    /// Presentation hint of the LAST pass, set ONLY when the DL patch fired:

    /// the dominant translation + exceptions. The CPU compositor turns it

    /// into a retained-pixmap blit + strip repaint (round 3). One-shot in

    /// spirit — the consumer must guard against re-application on the SAME

    /// display list (buffers-held retries re-run the present path).

    pub last_patch_move: Option<super::display_list::PatchMoveSummary>,

    /// Reconciliation census of the LAST pass: how many nodes were CLONED

    /// from the previous tree (warm shaped-text + intrinsic caches carried

    /// forward) vs built FRESH (no warm data). This pair is what makes cache

    /// reuse TESTABLE from outside solver3: `resize_relayout_bug.rs` asserts

    /// a same-DOM viewport resize reuses every node — the regression that

    /// motivated it (`old_tree = None` on any viewport change) re-shaped 917

    /// paragraphs and re-measured 1112 intrinsic widths per resize while

    /// every test still passed, because rebuilt-from-scratch produces the

    /// same pixels as reused, just ~130 ms slower.

    pub last_reconcile_reused: usize,

    /// See [`Self::last_reconcile_reused`].

    pub last_reconcile_fresh: usize,

    /// How many nodes the LAST pass actually recomputed intrinsic sizes for

    /// (the `intrinsic_dirty` set at the final `calculate_intrinsic_sizes`

    /// call). Same testability rationale as the reconcile census: the

    /// scrollbar-reflow loop used to mark EVERY node intrinsic-dirty

    /// (`(0..len).collect()`) — 75 ms re-measuring a whole document whose

    /// content had not changed — and no pixel test could see it, because

    /// recomputed intrinsics equal reused intrinsics.

    pub last_intrinsic_dirty: usize,

    /// 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<LayoutNodeId, 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).

    /// The third key component (`u64`) is the GPU-key-population fingerprint

    /// (`GpuValueCache::dl_emission_fingerprint`): the emitted list is a

    /// function of which nodes carry transform/opacity keys, and diff-driven

    /// animation mints keys AFTER a layout pass — matching on (hash, viewport)

    /// alone served the pre-key list back and made animations invisible.

    pub cached_display_list: Option<(

        SubtreeHash,

        LogicalRect,

        u64,

        std::sync::Arc<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(Copy, 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,

    /// `GlyphInstance`s inside the cached DL's `Text` items — the offset

    /// COPIES of `glyph_runs` instances. Counter, not a byte total (the

    /// bytes are inside `cached_display_list_bytes`).

    pub cached_display_list_text_instances: usize,

    /// Item slots in the cached DL (each costs `size_of::<DisplayListItem>()`

    /// inline). Counter, not a byte total.

    pub cached_display_list_items: 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 {

            // Real walk — this was a FLAT 2048 guess, which hid the DL's

            // per-Text-item glyph copies (20 B/painted glyph) entirely.

        }

}

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

    /// Nodes CLONED from the previous tree, warm data (shaped text, intrinsic

    /// widths) and all. The observable half of cache reuse — see

    /// [`LayoutCache::last_reconcile_reused`] for why this is load-bearing.

    pub reused_nodes: usize,

    /// Nodes built fresh (`create_node_from_dom`): genuinely new or

    /// Layout-dirty, with NO warm data. On a same-DOM relayout (a pure

    /// resize) this being anything but 0 means warm caches were thrown away.

    pub fresh_nodes: usize,

    /// The INDICES of those fresh nodes — the display-list patch re-emits

    /// exactly these (their previous items describe content that no longer

    /// exists: an edited text run, a same-count replace), instead of the

    /// whole intrinsic-dirty ancestor chain whose items are unchanged.

    pub fresh_indices: BTreeSet<usize>,

    /// Fingerprint computations skipped because the pre-cascade DOM diff

    /// proved the node (and its ancestors) unchanged. See

    /// `LayoutCache::dom_diff_clean`.

    pub fingerprint_skips: 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.

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

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

#[allow(clippy::cast_possible_truncation)] // bounded graphics/coord/counter/fixed-point cast

    };

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

    }

/// 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};

    };

    // Table-structural parents drop whitespace per CSS 2.2 section 17.2.1;

    // flex/grid containers drop it per css-flexbox-1 section 4 /

    // css-grid-1 section 6 (whitespace-only anonymous items are not

    // rendered).

        LayoutDisplay::Table

            | LayoutDisplay::InlineTable

            | LayoutDisplay::TableRowGroup

            | LayoutDisplay::TableHeaderGroup

            | LayoutDisplay::TableFooterGroup

            | LayoutDisplay::TableRow

            | LayoutDisplay::Flex

            | LayoutDisplay::InlineFlex

            | LayoutDisplay::Grid

            | LayoutDisplay::InlineGrid

    );

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

        {

    }

/// # Errors

///

/// Returns a `LayoutError` if layout reconciliation fails.

    // A viewport SIZE change invalidates every VIEWPORT-DEPENDENT computed

    // size — and nothing else. The old code dropped the ENTIRE cached tree

    // here (`old_tree = None`), which made every node reconcile as brand-new

    // (`recon_old_tree_none` 1209/1209 on a same-DOM resize) and threw away

    // every warm handle with it: measured on big.md, ~54 ms of re-SHAPING

    // (917 `text_shape_stage` calls — shaping does not depend on the

    // viewport) plus ~75 ms of intrinsic-width recomputation (also

    // viewport-independent) per resize, ~130 ms of a 246 ms pass re-deriving

    // bit-identical results. That was the single largest reason a drag-resize

    // could not approach interactive rates (scripts/RSS_MAP §36,

    // ICON_CACHE_AND_RELAYOUT_REUSE §4).

    //

    // KEEPING the tree is sound because the things that DO depend on the

    // viewport re-derive through keys, not through tree identity:

    //

    //   * size/layout cache slots are KEYED by `containing_block_size`

    //     (`NodeCache::get_size/get_layout`) — the new viewport enters as the

    //     root containing block and every affected chain misses its key and

    //     recomputes. This is exactly the mechanism that fixed #9 "grey on

    //     resize" (an abs-positioned node's containing block IS the

    //     viewport, so its key changes); dropping the whole tree on top of

    //     it was belt-and-braces from before the keys existed.

    //   * conditional (@media-style) properties evaluate per pass against

    //     the dynamic-selector context (`style_cache` is rebuilt per

    //     `LayoutContext`), and shaping keys carry the RESOLVED font size —

    //     a viewport-relative font re-shapes via its changed content hash.

    //   * `layout_roots.insert(0)` below still forces the full top-down

    //     layout pass at the new size; reconciliation merely decides what

    //     that pass may REUSE (shaped runs, intrinsic widths), not whether

    //     it runs.

        false, // the root has no ancestor whose restyle could reach it

    // 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).

/// Every `dom_node_id` in a freshly reconciled tree must address a node of

/// the `StyledDom` it was reconciled against.

///

/// WHY THIS IS AN ASSERTION AND NOT A `Result`. A tree that survives with a

/// stale id does not fail — it succeeds at describing the WRONG node. Some

/// thirty display-list sites, the style getters, the hit-test areas and the

/// damage attribution all read `styled_dom` through this id, and each one

/// silently returns another node's data. The reported symptom was a ribbon

/// tab click repainting rects belonging to unrelated nodes; the only reason

/// it was ever caught is that `compute_counters` happened to index far

/// enough out of range to trip a bounds check. Checking the invariant once,

/// here, converts that whole class of silent corruption into one failure

/// that names the node.

///

/// Cost: one comparison per layout node, against a pass that does real work

/// per node.

        };

        );

    }

        );

    }

/// 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 | StyleWhiteSpace::PreWrap |

StyleWhiteSpace::PreLine)

    ) {

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

                }

                _ => {

                }

            }

    }

/// Ordinal-match a freshly created anonymous inline wrapper to the old

/// parent's Nth anon wrapper and, when the run's children are IDENTICAL

/// (same dom ids, same order), carry the warm caches forward.

///

/// Anonymous wrappers have no `dom_node_id`, so ordinary reconciliation

/// cannot see them — every reconcile pass recreated them cold and flipped

/// their parent to `children_are_different = true` UNCONDITIONALLY, which put

/// every paragraph's parent into `intrinsic_dirty` + `layout_roots` on EVERY

/// pass (measured on big.md: 240 intrinsic IFC roots and 112 inline-content

/// re-collections per resize with a bit-identical DOM, ~12 ms). The ordinal

/// IS the identity: wrappers exist only for inline runs, runs are ordered by

/// child position, so the Nth wrapper under a node corresponds to the Nth run

/// — the same matching `layout_document`'s `cache_map` remap already performs

/// post-hoc for the size caches.

///

/// Only SELF-VALIDATING or content-derived caches are carried:

/// `inline_content_cache` re-validates itself against the subtree

/// fingerprint, and `intrinsic_sizes` are content-derived with the children

/// verified identical. Layout-derived state (`inline_layout_result`, used

/// sizes, baselines) stays `None` and re-derives through the CB-size-keyed

/// caches like any other clean node.

///

/// Returns whether the wrapper matched; the caller folds `!matched` into

/// `children_are_different` instead of flipping it unconditionally. A DIRTY

/// child inside a matched run still invalidates through that child's own

/// `mark_dirty` propagation — matching the wrapper never masks content edits.

    };

    // Children live on the TREE (hot/warm/cold split), not the node struct.

    else {

    };

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

#[allow(clippy::cast_possible_truncation)] // bounded graphics/coord/counter/fixed-point cast

#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

/// # Errors

///

/// Returns a `LayoutError` if recursive reconciliation fails.

    // 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();

    }

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

    // UNLESS the pre-cascade DOM diff proved this node (and its ancestors)

    // unchanged on both tiers. The diff cannot see runtime STATE

    // (hover/focus applied after produce), so a skip still requires the

    // state hash to match the old fingerprint; content/inline/attr hashing

    // (the expensive part) is what gets skipped.

                    use core::hash::{Hash, Hasher};