//! Layout tree construction from a styled DOM, including anonymous box generation

use std::{

    cell::Cell,

    collections::BTreeMap,

    hash::{Hash, Hasher},

    sync::Arc,

};

use azul_core::diff::NodeDataFingerprint;

use crate::text3::cache::UnifiedConstraints;

thread_local! {

    /// Per-thread counter for IFC IDs, reset to 0 at the start of each layout

    /// pass (see [`IfcId::reset_counter`]).

    ///

    /// This was previously a process-global `AtomicU32`. Two `layout_document`

    /// calls running concurrently on different threads (the `Sync` layout bound

    /// permits this) shared that single counter, so their IFC IDs interleaved and

    /// collided. A thread-local counter gives each pass its own sequence — a single

    /// pass is single-threaded (`LayoutContext` holds non-`Sync` `RefCell` caches),

    /// so IDs stay deterministic and stable across frames while never colliding

    /// across concurrent passes.

    static IFC_ID_COUNTER: Cell<u32> = const { Cell::new(0) };

}

/// Unique identifier for an Inline Formatting Context (IFC).

///

/// An IFC represents a region where inline content (text, inline-blocks, images)

/// is laid out together. One IFC can contain content from multiple DOM nodes

/// (e.g., `<p>Hello <span>world</span>!</p>` is one IFC with 3 text runs).

///

/// The ID is generated using a per-thread counter that resets at the start

/// of each layout pass. This ensures:

/// - IDs are unique within a layout pass

/// - The same logical IFC gets the same ID across frames (for selection stability)

/// - Concurrent `layout_document` passes on different threads can't collide

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

pub struct IfcId(pub u32);

impl IfcId {

    /// Generate a new unique IFC ID (within the current thread's layout pass).

    /// Reset the IFC ID counter. Called at the start of each layout pass.

}

/// Tracks a layout node's membership in an Inline Formatting Context.

///

/// Text nodes don't store their own `inline_layout_result` - instead, they

/// participate in their parent's IFC. This struct provides the link from

/// a text node back to its IFC's layout data.

///

/// # Architecture

///

/// ```text

/// DOM:  <p>Hello <span>world</span>!</p>

///

/// Layout Tree:

/// ├── LayoutNode (p) - IFC root

/// │   └── inline_layout_result: Some(UnifiedLayout)

/// │   └── ifc_id: IfcId(5)

/// │

/// ├── LayoutNode (::text "Hello ")

/// │   └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 0 })

/// │

/// ├── LayoutNode (span)

/// │   └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 1 })

/// │   └── LayoutNode (::text "world")

/// │       └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 1 })

/// │

/// └── LayoutNode (::text "!")

///     └── ifc_membership: Some(IfcMembership { ifc_id: 5, run_index: 2 })

/// ```

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

pub struct IfcMembership {

    /// The IFC ID this node's content was laid out in.

    pub ifc_id: IfcId,

    /// The index of the IFC root `LayoutNode` in the layout tree.

    /// Used to quickly find the node with `inline_layout_result`.

    pub ifc_root_layout_index: usize,

    /// Which run index within the IFC corresponds to this node's text.

    /// Maps to `ContentIndex::run_index` in the shaped items.

    pub run_index: u32,

}

use azul_core::{

    dom::{FormattingContext, NodeData, NodeId, NodeType},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    styled_dom::StyledDom,

};

use azul_css::{

    corety::LayoutDebugMessage,

    css::CssPropertyValue,

    codegen::format::GetHash,

    props::{

        basic::{

            pixel::DEFAULT_FONT_SIZE, PhysicalSize, PixelValue, PropertyContext, ResolutionContext,

        },

        layout::{

            LayoutDisplay, LayoutFloat, LayoutHeight, LayoutMaxHeight, LayoutMaxWidth,

            LayoutMinHeight, LayoutMinWidth, LayoutOverflow, LayoutPosition, LayoutWidth,

            LayoutWritingMode,

        },

        property::{CssProperty, CssPropertyType},

        style::{StyleTextAlign, StyleWhiteSpace},

    },

};

use taffy::{Cache as TaffyCache, Layout, LayoutInput, LayoutOutput};

#[cfg(feature = "text_layout")]

use crate::text3;

use crate::{

    debug_log,

    font::parsed::ParsedFont,

    font_traits::{FontLoaderTrait, ParsedFontTrait, UnifiedLayout},

    solver3::{

        geometry::{BoxProps, IntrinsicSizes, PositionedRectangle},

        getters::{

            get_css_height, get_css_max_height, get_css_max_width, get_css_min_height,

            get_css_min_width, get_css_width, get_direction_property as get_direction,

            get_display_property, get_float, get_overflow_x,

            get_overflow_y, get_position, get_text_align,

            get_text_orientation_property as get_text_orientation,

            get_white_space_property, get_writing_mode, MultiValue,

        },

        scrollbar::ScrollbarRequirements,

        LayoutContext, Result,

    },

    text3::cache::AvailableSpace,

};

/// Represents the invalidation state of a layout node.

///

/// The states are ordered by severity, allowing for easy "upgrading" of the dirty state.

/// A node marked for `Layout` does not also need to be marked for `Paint`.

///

/// Because this enum derives `PartialOrd` and `Ord`, you can directly compare variants:

///

/// - `DirtyFlag::Layout > DirtyFlag::Paint` is `true`

/// - `DirtyFlag::Paint >= DirtyFlag::None` is `true`

/// - `DirtyFlag::Paint < DirtyFlag::Layout` is `true`

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

pub enum DirtyFlag {

    /// The node's layout is valid and no repaint is needed. This is the "clean" state.

    #[default]

    None,

    /// The node's geometry is valid, but its appearance (e.g., color) has changed.

    /// Requires a display list update only.

    Paint,

    /// The node's geometry (size or position) is invalid.

    /// Requires a full layout pass and a display list update.

    Layout,

}

/// A hash that represents the content and style of a node PLUS all of its descendants.

/// If two `SubtreeHashes` are equal, their entire subtrees are considered identical for layout

/// purposes.

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

pub struct SubtreeHash(pub u64);

/// Per-item metrics cached from the last IFC layout.

///

/// These metrics enable incremental IFC relayout (Phase 2 optimization):

/// when a single inline item changes, we can check whether its advance width

/// changed and potentially skip full line-breaking for unaffected lines.

///

/// Index in `CachedInlineLayout::item_metrics` matches the item order in

/// `UnifiedLayout::items`.

#[derive(Copy, Debug, Clone)]

pub struct InlineItemMetrics {

    /// The DOM `NodeId` of the source node for this item (for dirty checking).

    /// `None` for generated content (list markers, hyphens, etc.)

    pub source_node_id: Option<NodeId>,

    /// Advance width of this item (glyph run width, inline-block width, etc.)

    pub advance_width: f32,

    /// Advance height contribution from this item to its line box.

    pub line_height_contribution: f32,

    /// Whether this item can participate in line breaking.

    /// `false` for items inside `white-space: nowrap` or `white-space: pre`.

    pub can_break: bool,

    /// Which line this item was placed on (0-indexed).

    pub line_index: u32,

    /// X offset within its line.

    pub x_offset: f32,

}

/// Cached inline layout result with the constraints used to compute it.

///

/// This structure solves a fundamental architectural problem: inline layouts

/// (text wrapping, inline-block positioning) depend on the available width.

/// Different layout phases may compute the layout with different widths:

///

/// 1. **Min-content measurement**: width = `MinContent` (effectively 0)

/// 2. **Max-content measurement**: width = `MaxContent` (effectively infinite)

/// Cached output of `collect_and_measure_inline_content` (see

/// `LayoutNodeWarm::inline_content_cache`).

#[derive(Debug, Clone)]

pub struct CachedInlineContent {

    /// The collected inline content (text runs, atomics, markers).

    pub content: Vec<crate::text3::cache::InlineContent>,

    /// `ContentIndex` -> child layout-node index, as collection built it.

    pub child_map: std::collections::HashMap<crate::text3::cache::ContentIndex, usize>,

    /// Validity key: the fingerprints of the IFC root and its descendants,

    /// folded in tree order. Anything that changes text, style or structure

    /// changes a fingerprint, so an equal key means an identical collection.

    pub subtree_fingerprint: u64,

    /// Hash of `content` alone, computed ONCE when the collection is (re)built.

    ///

    /// The per-visit "current content hash" used to re-hash the full inline

    /// content on EVERY `layout_ifc` entry — 2 292 hashes × ~12.7 µs ≈ 29 ms

    /// per resize relayout on big.md, hashing bytes that by definition had not

    /// changed (an equal `subtree_fingerprint` is what admitted the cached

    /// collection in the first place). Visits now fold only the seven

    /// constraint-level container properties on top of this base.

    pub content_hash_base: u64,

}

/// 3. **Final layout**: width = `Definite(actual_column_width)`

///

/// Without tracking which constraints were used, a cached result from phase 1

/// would incorrectly be reused in phase 3, causing text to wrap at the wrong

/// positions (the root cause of table cell width bugs).

///

/// By storing the constraints alongside the result, we can:

/// - Invalidate the cache when constraints change

/// - Keep multiple cached results for different constraint types if needed

/// - Ensure the final render always uses a layout computed with correct widths

#[derive(Debug, Clone)]

pub struct CachedInlineLayout {

    /// The computed inline layout.

    ///

    /// (d6h RETIREMENT) Under `AZ_DENSE_TEXT=1`, when the dense view is

    /// retained AND covers every item (pure clusters), this holds a

    /// SHARED EMPTY sentinel instead of the real thing — the ~192 B/item

    /// sparse retention is the campaign's target. Every production

    /// reader is dense-first by d1-d6h; `verify` mode retains BOTH and

    /// A/B-asserts; flag-off is unchanged. `overflow` (below) carries

    /// the one field the sentinel loses.

    pub layout: Arc<UnifiedLayout>,

    /// (d6h) The real layout's overflow info, captured at store time —

    /// the incremental-relayout guard reads it after the sentinel swap.

    pub overflow: crate::text3::cache::OverflowInfo,

    /// The available width constraint used to compute this layout.

    /// This is the key for cache validity checking.

    /// +spec:writing-modes:1dcba2 - "available width" (CSS2.1) = auto size in inline axis

    pub available_width: AvailableSpace,

    /// Whether this layout was computed with float exclusions.

    /// Float-aware layouts should not be overwritten by non-float layouts.

    pub has_floats: bool,

    /// The full constraints used to compute this layout.

    /// Used for quick relayout after text edits without rebuilding from CSS.

    pub constraints: Option<UnifiedConstraints>,

    /// Glyph runs derived from `layout` at STORE time (a pure function of

    /// it — see `get_glyph_runs_simple`). The display-list generator used to

    /// re-derive these on EVERY paint of every IFC (the run-grouping walk was

    /// the bulk of `dl_inline_text`'s 6.8 ms/resize on big.md); computing them

    /// once alongside the layout makes every later paint a lookup. Rides

    /// `GlyphSwap` reuse for free — a reused layout is a reused run list.

    ///

    /// (#25) Stored COMPACT — 8 B/glyph instead of the 20 B `GlyphInstance`

    /// (y and size are per-run-uniform in the simple-run contract; deviants

    /// ride the exception table). Paint expands into the same offset Vec it

    /// always built; `AZ_DENSE_TEXT=verify` roundtrip-gates the encoding.

    pub glyph_runs: Arc<Vec<crate::text3::glyphs::CompactGlyphRun>>,

    /// Per-item metrics for incremental IFC relayout (Phase 2).

    ///

    /// Each entry corresponds to one `PositionedItem` in `layout.items`.

    /// These metrics enable the IFC relayout decision tree:

    /// - Check if a dirty node's `advance_width` changed → skip repositioning if not

    /// - Use `can_break` + `line_index` for the nowrap fast path

    /// - Use `x_offset` for shifting subsequent items without full line-breaking

    pub item_metrics: Vec<InlineItemMetrics>,

    /// Cached line break boundaries for incremental relayout.

    /// Enables checking if a width change fits on the same line without

    /// re-running the full line-breaking algorithm.

    pub line_breaks: Option<crate::text3::cache::CachedLineBreaks>,

    /// §3.2 step (d5): the ONE cache-stable Arc the display list carries

    /// as its `TextLayout` payload. `TextPayload{dense,sparse}` when the

    /// dense view is retained, else the `layout` Arc itself (identical

    /// to the pre-d5 payload). Built at store time so damage `ptr_eq`

    /// stays stable across paints.

    pub payload: Arc<dyn std::any::Any + Send + Sync>,

    /// §3.2 step (d1): the dense view of `layout`, retained when

    /// `AZ_DENSE_TEXT` is active (`glyph_runs` derive from THIS instance).

    /// Readers migrate from `layout` onto it one by one; the sparse form

    /// retires when the last reader has moved (plan §10.4).

    pub dense: Option<Arc<crate::text3::dense::DenseText>>,

    /// Hash of the `InlineContent` this layout was shaped from. The Phase 2d

    /// fast-path reuse in fc.rs keys cache validity on WIDTH only; without this,

    /// a same-width `RefreshDom` whose text CHANGED would reuse the stale shaped

    /// layout (#11 stale display list). 0 = unknown ⇒ never fast-path-reuse.

    pub inline_content_hash: u64,

}

/// §3.2 step (d5): the display list's `TextLayout` payload when the dense

/// view is retained — BOTH forms behind one cache-stable Arc, so

/// `TextLayout` damage diffing (`Arc::ptr_eq`) keeps firing exactly as

/// before. Downcasters try this first and fall back to a bare

/// `UnifiedLayout` payload (the flag-off path). The `sparse` half is

/// what current consumers read; it empties at the d6 retirement, which

/// is when the consumers move onto `dense`.

#[derive(Debug)]

pub struct TextPayload {

    pub dense: Arc<crate::text3::dense::DenseText>,

    pub sparse: Arc<UnifiedLayout>,

}

/// §3.2 flip step (a): the paint-run computation, routed by `AZ_DENSE_TEXT`.

///

/// - unset/`0` — the sparse reference walker (production default).

/// - `1`      — build [`crate::text3::dense::DenseText`] and walk THAT

///   (`get_glyph_runs_simple_dense`), the compact model's first production

///   consumer.

/// - `verify` — dense path PLUS an A/B assert against the reference; the

///   e2e corpus run with this set is the flip proof over real layouts.

///

/// Layouts containing combined blocks (tate-chu-yoko) fall back to the

/// reference under the flag: the dense model keeps atomics on the sparse

/// side by design and the twin would silently DROP their glyphs.

/// The process-wide `AZ_DENSE_TEXT` mode: 0 off, 1 on, 2 verify.

///

/// (d7) DEFAULT ON: the dense model is the stored form in production —

/// the retirement (d6h) plateaued at 65.2 MB heap vs 73.6 flag-off on

/// the 960-line corpus, with the full battery + flag-on corpus +

/// flag-on reftests green. `AZ_DENSE_TEXT=0` is the escape hatch;

/// `verify` retains both forms and A/B-asserts every dense-first arm.

    static MODE: std::sync::OnceLock<u8> = std::sync::OnceLock::new();

/// #25: converts the transient builder output into the stored compact form.

/// Under `AZ_DENSE_TEXT=verify` every run is roundtripped and compared

/// BIT-EXACTLY against its original — the same proof obligation the dense

/// campaign carried: the stored form must be an encoding, never a rewrite.

                );

            } else {

            }

/// Testable core of [`compute_glyph_runs`] — `mode` injected so the d1

/// retention pin can exercise the dense path without env-var races.

    use crate::text3::cache::ShapedItem;

    {

    // §3.2 step (d1): the dense view is RETAINED on the cache entry, not

    // rebuilt-and-dropped per walk — the readers migrate onto it one by

    // one, and the sparse `layout` retires when the last one has.

                r.color, o.color,

                r.background_color, o.background_color,

                r.font_hash, o.font_hash,

                r.font_size_px, o.font_size_px,

                r.text_decoration, o.text_decoration,

                r.source_node_id, o.source_node_id,

            );

        }

/// §3.2 step (d2): per-item metrics FROM the dense view. Returns None

/// unless the layout was PURE clusters (`dense.clusters.len()` must

/// equal `layout.items.len()` — the dense builder silently skips

/// objects/tabs/breaks/combined blocks, and `item_metrics` is

/// index-aligned with ALL items, so a shorter vec would silently

/// misalign the incremental-relayout decision tree).

///

/// Field-for-field vs the sparse extraction (the d2 gate pins this):

/// `advance_width` = ClusterCompact.advance (BASE advance == bounds().width

/// since the d2 redefinition), `line_height_contribution` = the run's

/// resolved line height (== ascent+descent by the half-leading identity),

/// `can_break` = true (clusters are never `ShapedItem::Break`), `line_index` =

/// `LineRecord.source_index`, `x_offset` = ClusterCompact.x.

    {

            }

        }

        } else {

        };

            can_break: true,

        });

    }

impl CachedInlineLayout {

    /// Creates a new cached inline layout.

        // Payload built from the STORED form — under the retirement the

        // sparse half is the sentinel and consumers expand from dense.

    /// Creates a new cached inline layout with full constraints.

        };

        // Payload built from the STORED form — under the retirement the

        // sparse half is the sentinel and consumers expand from dense.

    /// (d6h) The stored layout, MATERIALIZED if it is the retirement

    /// sentinel: dense expands (exact by the d6h expansion gate) into a

    /// transient sparse copy. The universal accessor for readers that

    /// measure or walk content; flag-off / verify / non-pure entries

    /// return the stored Arc untouched.

    #[must_use]

    /// (d6h) THE RETIREMENT: under `AZ_DENSE_TEXT=1`, a pure-cluster

    /// layout whose dense view is retained stores a SHARED EMPTY

    /// sentinel in `layout` — the per-item sparse retention (the

    /// campaign's ~192 B/cluster target) drops here. The real overflow

    /// info is captured first (the incremental guard reads it).

    /// `verify` mode (2) retains BOTH so every dense-first arm keeps

    /// A/B-asserting; flag-off (0) is byte-for-byte unchanged.

        // Empty layouts are skipped: nothing to save, and the identity

        // swap would be pure Arc churn (unit fixtures rely on ptr_eq).

            static EMPTY: std::sync::OnceLock<Arc<UnifiedLayout>> = std::sync::OnceLock::new();

    /// (d5) The cache-stable DL payload — see the `payload` field.

        }

    /// (d2) Metrics source selection: dense when retained AND the layout

    /// is pure clusters; sparse otherwise. Under `AZ_DENSE_TEXT=verify` the

    /// dense result is A/B-asserted against the sparse extraction.

        };

        };

                );

            }

    /// Extracts per-item metrics from a computed `UnifiedLayout`.

    ///

    /// This is called automatically by the constructors. The metrics

    /// enable incremental IFC relayout in Phase 2c/2d by providing

    /// cached advance widths, line assignments, and break information

    /// for each positioned item.

    #[allow(clippy::cast_possible_truncation)] // bounded layout/render numeric cast

        use crate::text3::cache::{ShapedItem, get_item_vertical_metrics_approx};

                // Objects (inline-blocks, images) and other generated items

                // don't expose source_node_id directly on ShapedItem.

                // Phase 2c will refine this via the ContentIndex mapping.

                ShapedItem::Object { .. }

                | ShapedItem::CombinedBlock { .. }

                | ShapedItem::Tab { .. }

            };

            // For Phase 2a, default can_break = true for all items.

            // Phase 2c will refine this by checking the white-space property

            // on the IFC root's style or the item's own style context.

            // (Note: text3::StyleProperties doesn't carry white-space;

            //  that's resolved at the IFC/BFC boundary level.)

    /// Checks if this cached layout is valid for the given constraints.

    ///

    /// A cached layout is valid if:

    /// 1. The available width matches (definite widths must be equal, or both are the same

    ///    indefinite type)

    /// 2. OR the new request doesn't have floats but the cached one does (keep float-aware layout)

    ///

    /// The second condition preserves float-aware layouts, which are more "correct" than

    /// non-float layouts and shouldn't be overwritten.

        // A cached layout with NO floats must not be reused when the new request DOES

        // have floats: the line boxes have to re-wrap around the float exclusions.

        // Without this, the two-pass IFC path (no-float sizing pass, then float-aware

        // re-layout) reuses the pass-1 no-float line breaks and text ignores the float

        // entirely (#19). Mirrors should_replace_with()'s gain-float branch so the two

        // stay consistent.

        // If we have a float-aware layout and the new request doesn't have floats,

        // keep the float-aware layout (it's more accurate)

            // But only if the width constraint type matches

        // Otherwise, require exact width match

    /// Tolerance for comparing definite layout widths (in logical pixels).

    /// Sub-pixel differences below this threshold are treated as identical

    /// to avoid unnecessary relayout from floating-point rounding.

    const LAYOUT_WIDTH_EPSILON: f32 = 0.1;

    /// Checks if the width constraint matches.

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

            // Definite widths must match within a small epsilon

            }

            // MinContent matches MinContent

            // MaxContent matches MaxContent

            // Different constraint types don't match

        }

    /// Determines if this cached layout should be replaced by a new layout.

    ///

    /// Returns true if the new layout should replace this one.

        // Always replace if we gain float information

        // Replace if width constraint changed

    /// Returns a reference to the inner `UnifiedLayout`.

    ///

    /// This is a convenience method for code that only needs the layout data

    /// and doesn't care about the caching metadata.

    #[inline]

    /// Returns a clone of the inner Arc<UnifiedLayout>.

    ///

    /// This is useful for APIs that need to return an owned reference

    /// to the layout without exposing the caching metadata.

    #[inline]

}

/// A layout tree node representing the CSS box model.

///

/// ## Memory Layout Optimization (`#[repr(C)]`)

///

/// Fields are ordered by access frequency (hottest first) to maximize CPU

/// cache line utilization during tree traversal. With `#[repr(C)]`, the

/// compiler preserves this ordering. The 6 hottest fields (~140 bytes)

/// occupy the first 2-3 cache lines (64 bytes each), which are loaded

/// first by the hardware prefetcher.

///

/// | Tier   | Fields                                  | ~Bytes | Accesses |

/// |--------|-----------------------------------------|--------|----------|

/// | HOT    | `box_props`, `dom_node_id`, children,       |  ~140  |  410+    |

/// |        | `used_size`, `formatting_context`, parent    |        |          |

/// | WARM   | `intrinsic_sizes..computed_style`          |  ~220  |  ~80     |

/// | COLD   | `dirty_flag..is_anonymous`                 |  ~190  |  ~20     |

///

/// Note: An absolute position is a final paint-time value and shouldn't be

/// cached on the node itself, as it can change even if the node's

/// layout is clean (e.g., if a sibling changes size). We will calculate

/// it in a separate map.

#[derive(Debug, Clone)]

#[repr(C)]

pub struct LayoutNode {

    // ── HOT tier: accessed on every node in every layout pass ────────────

    // These fields should fit in the first 2-3 cache lines (~128-192 bytes).

    /// The resolved box model properties (margin, border, padding)

    /// in logical pixels. Cached after first resolution.

    /// (148 accesses — hottest field)

    pub box_props: BoxProps,

    /// Reference back to the original DOM node (None for anonymous boxes)

    /// (111 accesses)

    pub dom_node_id: Option<NodeId>,

    /// Children indices in the layout tree

    /// (53 accesses)

    pub children: Vec<usize>,

    /// The size used during the last layout pass.

    /// (43 accesses)

    pub used_size: Option<LogicalSize>,

    /// The formatting context this node establishes or participates in.

    /// (30 accesses)

    pub formatting_context: FormattingContext,

    /// Parent index (None for root)

    /// (25 accesses)

    pub parent: Option<usize>,

    // ── WARM tier: frequently accessed but not on every node ─────────────

    /// Cached intrinsic sizes (min-content, max-content, etc.)

    /// (16 accesses — sizing pass only)

    pub intrinsic_sizes: Option<IntrinsicSizes>,

    // +spec:display-property:af3a89 - alignment baseline for inline-level boxes

    /// The baseline of this box, if applicable, measured from its content-box top edge.

    /// (14 accesses — IFC/table alignment)

    pub baseline: Option<f32>,

    /// Cached inline layout result with the constraints used to compute it.

    ///

    /// This field stores both the computed layout AND the constraints (available width,

    /// float state) under which it was computed. This is essential for correctness:

    /// 

    /// - Table cells are measured multiple times with different widths

    /// - Min-content/max-content intrinsic sizing uses special constraint values

    /// - The final layout must use the actual available width, not a measurement width

    ///

    /// By tracking the constraints, we avoid the bug where a min-content measurement

    /// (with width=0) would be incorrectly reused for final rendering.

    /// (13 accesses — IFC roots / table cells)

    /// BOXED (rare-data split, 2026-08-11): populated only on IFC roots /

    /// table cells; the 296-B inline Option was paid by EVERY node.

    pub inline_layout_result: Option<Box<CachedInlineLayout>>,

    /// See [`LayoutNodeWarm::inline_content_cache`]. BOXED likewise (88 B).

    pub inline_content_cache: Option<Box<CachedInlineContent>>,

    /// Cached scrollbar information (calculated during layout)

    /// Used to determine if scrollbars appeared/disappeared requiring reflow

    /// (12 accesses — scrollable containers only)

    pub scrollbar_info: Option<ScrollbarRequirements>,

    /// The position of this node *relative to its parent's content box*.

    /// (9 accesses — positioning pass)

    pub relative_position: Option<LogicalPosition>,

    /// The actual content size (children overflow size) for scrollable containers.

    /// This is the size of all content that might need to be scrolled, which can

    /// be larger than `used_size` when content overflows the container.

    /// (7 accesses — scrollable containers)

    pub overflow_content_size: Option<LogicalSize>,

    /// Cache for Taffy layout computations for this node.

    /// (6 accesses — Taffy bridge)

    pub taffy_cache: TaffyCache,

    /// Pure min-content / max-content measure results from the taffy bridge

    /// (`(min, max)` outer sizes), keyed by NOTHING — a pure content

    /// measurement is viewport-independent, so it stays valid until the

    /// node's content changes. Invalidated wherever `taffy_cache` is

    /// (the intrinsic-dirty ancestor closure). WHY separate from

    /// `taffy_cache`: taffy's slot classes collide under the flex

    /// algorithm's candidate-width probing (Definite(0)/Definite(w1)/…

    /// share a slot and evict each other within one pass), so min/max

    /// entries did not survive to the NEXT pass — 312 full min/max-content

    /// subtree re-layouts per steady resize on big.md, each re-breaking

    /// every IFC line in the subtree AND evicting the Definite entry of

    /// the single-slot IFC cache on the way (the 429 `text_layout_flow`

    /// calls). (2 accesses — Taffy bridge measure path)

    pub measured_content_sizes: (Option<LayoutOutput>, Option<LayoutOutput>),

    /// Pre-computed CSS properties needed during layout.

    /// Computed once during layout tree build to avoid repeated style lookups.

    /// (5 accesses — cache.rs only)

    pub computed_style: ComputedLayoutStyle,

    /// Pseudo-element type (`::marker`, `::before`, `::after`) if this node is a pseudo-element

    /// (5 accesses — pseudo-elements only)

    pub pseudo_element: Option<PseudoElement>,

    /// Escaped top margin (CSS 2.1 margin collapsing)

    /// If this BFC's first child's top margin "escaped" the BFC, this contains

    /// the collapsed margin that should be applied by the parent.

    /// (4 accesses — BFC margin collapsing)

    pub escaped_top_margin: Option<f32>,

    /// Escaped bottom margin (CSS 2.1 margin collapsing)\

    /// If this BFC's last child's bottom margin "escaped" the BFC, this contains

    /// the collapsed margin that should be applied by the parent.

    /// (4 accesses)

    pub escaped_bottom_margin: Option<f32>,

    /// Parent's formatting context (needed to determine if stretch applies)

    /// (4 accesses — flex/grid children)

    pub parent_formatting_context: Option<FormattingContext>,

    /// If this node participates in an IFC (is inline content like text),

    /// stores the reference back to the IFC root and the run index.

    /// This allows text nodes to find their layout data in the parent's IFC.

    /// (3 accesses — text nodes only)

    pub ifc_membership: Option<IfcMembership>,

    /// The layout tree index of this node's containing block.

    /// - For abs-pos elements: nearest positioned (non-static) ancestor

    /// - For fixed elements: root / None (viewport)

    /// - For normal-flow: parent (None = implicit)

    ///   Used for clip exemption: abs-pos elements whose containing block

    ///   is above an overflow clipper should not be clipped.

    pub containing_block_index: Option<usize>,

    // ── COLD tier: construction / reconciliation / debugging only ────────

    /// Type of anonymous box (if applicable)

    /// (2 accesses)

    pub anonymous_type: Option<AnonymousBoxType>,

    /// O3-render: when this node is one PART of a structural-split PREVIEW,

    /// the flat byte range of the source node's inline content this part

    /// displays (`u32::MAX` end = to the end). The IFC build slices its

    /// collected content by this range. `None` = the node shows everything

    /// (the universal case outside previews).

    pub preview_byte_range: Option<(u32, u32)>,

    /// Multi-field fingerprint of this node's data (style, text, etc.)

    /// for granular change detection during reconciliation.

    /// (2 accesses — reconciliation only)

    pub node_data_fingerprint: NodeDataFingerprint,

    /// A hash of this node's data and all of its descendants. Used for

    /// fast reconciliation.

    /// (9 accesses — all in cache.rs reconciliation)

    pub subtree_hash: SubtreeHash,

    /// Dirty flags to track what needs recalculation.

    /// (7 accesses — reconciliation setup)

    pub dirty_flag: DirtyFlag,

    /// Unresolved box model properties (raw CSS values).

    /// These are resolved lazily during layout when containing block is known.

    /// (1 access — initial resolution only)

    pub unresolved_box_props: crate::solver3::geometry::UnresolvedBoxProps,

    /// If this node is an IFC root, stores the IFC ID.

    /// Used to identify which IFC this node's `inline_layout_result` belongs to.

    /// (1 access — IFC creation only)

    pub ifc_id: Option<IfcId>,

}

/// Pre-computed CSS properties needed during layout.

/// 

/// This struct stores resolved CSS values that are frequently accessed during

/// layout calculations. By computing these once during layout tree construction,

/// we avoid O(n * m) style lookups where n = nodes and m = layout passes.

///

/// All values are resolved to their final form (no 'inherit', 'initial', etc.)

#[derive(Debug, Clone, Default)]

pub struct ComputedLayoutStyle {

    /// CSS `display` property

    pub display: LayoutDisplay,

    /// CSS `position` property

    pub position: LayoutPosition,

    /// CSS `float` property

    pub float: LayoutFloat,

    /// CSS `overflow-x` property

    pub overflow_x: LayoutOverflow,

    /// CSS `overflow-y` property

    pub overflow_y: LayoutOverflow,

    /// CSS `writing-mode` property

    pub writing_mode: azul_css::props::layout::LayoutWritingMode,

    /// CSS `direction` property (ltr/rtl)

    pub direction: azul_css::props::style::StyleDirection,

    /// CSS `text-orientation` property (for vertical writing modes)

    pub text_orientation: azul_css::props::style::effects::StyleTextOrientation,

    /// CSS `width` property (None = auto)

    pub width: Option<azul_css::props::layout::LayoutWidth>,

    /// CSS `height` property (None = auto)

    pub height: Option<azul_css::props::layout::LayoutHeight>,

    /// CSS `min-width` property

    pub min_width: Option<azul_css::props::layout::LayoutMinWidth>,

    /// CSS `min-height` property

    pub min_height: Option<azul_css::props::layout::LayoutMinHeight>,

    /// CSS `max-width` property

    pub max_width: Option<azul_css::props::layout::LayoutMaxWidth>,

    /// CSS `max-height` property

    pub max_height: Option<azul_css::props::layout::LayoutMaxHeight>,

    /// CSS `text-align` property

    pub text_align: StyleTextAlign,

}

// Note: LayoutNode methods that cross hot/warm/cold boundaries have been

// moved to LayoutTree methods (resolve_box_props, get_content_size).

/// CSS pseudo-elements that can be generated

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

pub enum PseudoElement {

    /// `::marker` pseudo-element for list items

    Marker,

    /// `::before` pseudo-element

    Before,

    /// `::after` pseudo-element

    After,

}

// +spec:display-property:b7f4bf - anonymous inline/block boxes are both called "anonymous boxes"

/// Types of anonymous boxes that can be generated

// +spec:display-property:ae4f16 - anonymous boxes are treated as descendants alongside pseudo-elements

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

pub enum AnonymousBoxType {

    /// Anonymous block box wrapping inline content

    InlineWrapper,

    /// O3-render: the SECOND (or later) part of a structural-split preview —

    /// a box with a real `dom_node_id` (the split node, via the

    /// `dom_to_layout` multimap) that displays a byte-slice of its content.

    /// Exists only between recording a split and the app's re-render.

    SplitPreviewPart,

    /// Anonymous box for a list item marker (bullet or number)

    /// DEPRECATED: Use `PseudoElement::Marker` instead

    ListItemMarker,

    /// Anonymous table wrapper

    TableWrapper,

    /// Anonymous table row group (tbody)

    TableRowGroup,

    /// Anonymous table row

    TableRow,

    /// Anonymous table cell

    TableCell,

}

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

// SoA (struct-of-arrays) layout node split for cache performance

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

/// Hot layout node fields — accessed on every node in every layout pass.

///

/// Stored in a separate `Vec` for cache locality. At ~100 bytes per node,

/// 1000 nodes fit in ~100 KB (L2 cache), vs ~550 KB with the monolithic struct.

// ~100B per-node hot type stored/moved in Vecs across every layout pass; kept

// non-Copy on purpose so it isn't silently bulk-copied (Copy would mask the

// cost and churn the many `.clone()` call sites).

#[allow(missing_copy_implementations)]

#[derive(Debug, Clone)]

pub struct LayoutNodeHot {

    /// The resolved box model properties (margin, border, padding)

    /// Stored in packed i16×10 encoding to reduce cache footprint.

    /// Use `box_props.unpack()` to get f32 `ResolvedBoxProps` for computation.

    pub box_props: crate::solver3::geometry::PackedBoxProps,

    /// Reference back to the original DOM node (None for anonymous boxes)

    pub dom_node_id: Option<NodeId>,

    /// The size used during the last layout pass.

    pub used_size: Option<LogicalSize>,

    /// The formatting context this node establishes or participates in.

    pub formatting_context: FormattingContext,

    /// Parent index (None for root)

    pub parent: Option<usize>,

}

/// Warm layout node fields — accessed frequently but not on every node.

///

/// Stored in a separate `Vec`. These fields are accessed during specific

/// layout phases (sizing, IFC, table alignment) but not during the main

/// constraint-solving loop.

#[derive(Debug, Clone, Default)]

pub struct LayoutNodeWarm {

    /// Cached intrinsic sizes (min-content, max-content, etc.)

    pub intrinsic_sizes: Option<IntrinsicSizes>,

    /// The baseline of this box, measured from its content-box top edge.

    pub baseline: Option<f32>,

    /// Cached inline layout result with the constraints used to compute it.

    /// BOXED (rare-data split, 2026-08-11): only IFC roots populate this,

    /// but the 296-B inline Option was paid by EVERY node. 8 B here now.

    pub inline_layout_result: Option<Box<CachedInlineLayout>>,

    /// Cached result of `collect_and_measure_inline_content` for this IFC

    /// root, valid while the subtree's fingerprints are unchanged.

    ///

    /// Collection resolves the FULL cascade (`get_style_properties`) for

    /// every text run and inline span. That ran on every layout — even one

    /// that went on to reuse the cached line layout — and measured 2 ms per

    /// IFC, 32 ms per pagination: the single largest remaining cost after

    /// the line-breaker and font-signature fixes.

    /// BOXED (rare-data split): IFC roots only; was 88 B inline per node.

    pub inline_content_cache: Option<Box<CachedInlineContent>>,

    /// Cached scrollbar information

    pub scrollbar_info: Option<ScrollbarRequirements>,

    /// The position relative to parent's content box.

    pub relative_position: Option<LogicalPosition>,

    /// The actual content size for scrollable containers.

    pub overflow_content_size: Option<LogicalSize>,

    /// Cache for Taffy layout computations.

    pub taffy_cache: TaffyCache,

    /// Pure min/max-content measure results — see the facade field's doc.

    pub measured_content_sizes: (Option<LayoutOutput>, Option<LayoutOutput>),

    /// Pre-computed CSS properties needed during layout.

    pub computed_style: ComputedLayoutStyle,

    /// Pseudo-element type if this node is a pseudo-element

    pub pseudo_element: Option<PseudoElement>,

    /// Escaped top margin (CSS 2.1 margin collapsing)

    pub escaped_top_margin: Option<f32>,

    /// Escaped bottom margin (CSS 2.1 margin collapsing)

    pub escaped_bottom_margin: Option<f32>,

    /// Parent's formatting context

    pub parent_formatting_context: Option<FormattingContext>,

    /// IFC membership for text nodes

    pub ifc_membership: Option<IfcMembership>,

    /// Containing block index for clip exemption

    pub containing_block_index: Option<usize>,

}

/// Cold layout node fields — construction / reconciliation / debugging only.

///

/// Stored in a separate `Vec`. These fields are rarely accessed during layout;

/// mostly used during tree construction, reconciliation, and dirty tracking.

#[derive(Debug, Clone)]

#[derive(Default)]

pub struct LayoutNodeCold {

    /// Type of anonymous box (if applicable)

    pub anonymous_type: Option<AnonymousBoxType>,

    /// O3-render: when this node is one PART of a structural-split PREVIEW,

    /// the flat byte range of the source node's inline content this part

    /// displays (`u32::MAX` end = to the end). The IFC build slices its

    /// collected content by this range. `None` = the node shows everything

    /// (the universal case outside previews).

    pub preview_byte_range: Option<(u32, u32)>,

    /// Multi-field fingerprint for granular change detection.

    pub node_data_fingerprint: NodeDataFingerprint,

    /// Hash of this node's data + all descendants.

    pub subtree_hash: SubtreeHash,

    /// Dirty flags for recalculation tracking.

    pub dirty_flag: DirtyFlag,

    /// Unresolved box model properties (raw CSS values).

    pub unresolved_box_props: crate::solver3::geometry::UnresolvedBoxProps,

    /// IFC ID if this node is an IFC root.

    pub ifc_id: Option<IfcId>,

}

impl LayoutNode {

    /// Split this full layout node into hot/warm/cold components.

    /// Used during `LayoutTreeBuilder::build()` to create the `SoA` layout.

}

/// How far [`LayoutTree::get_ifc_root_layout_index`] walks up looking for the

/// box that owns an inline descendant's layout. Inline nesting is shallow in

/// practice; the bound only stops a malformed tree from spinning.

const IFC_ANCESTOR_WALK_LIMIT: usize = 64;

/// A position in the LAYOUT tree — distinct from a DOM [`NodeId`] BY TYPE.

///

/// The layout tree interleaves anonymous boxes and splits during

/// construction, so layout indices and DOM indices diverge for any real DOM.

/// Conflating them (`node_id.index()` used as a layout index) froze CPU-path

/// scrolling once (`build_scroll_offset_map`) and is exactly the mistake this

/// newtype turns into a compile error: the ONLY sanctioned ways to obtain a

/// `LayoutNodeId` from a DOM node are [`LayoutTree::dom_to_layout`] and the

/// scroll-id tables. Solver-interior code that produces indices locally wraps

/// them with [`LayoutNodeId::new`] — an explicit, greppable assertion that

/// the value really is a layout index.

///

/// The raw `SoA` vectors (`nodes`, `warm`, `cold`, `children_arena`) stay

/// `usize`-indexed for interior arithmetic; the typed boundary is the

/// accessor surface (`get`/`warm`/`cold`/`get_content_size`/...), which is

/// what map-derived consumer code calls.

#[repr(transparent)]

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

pub struct LayoutNodeId(pub usize);

impl LayoutNodeId {

    #[inline]

    #[must_use]

    /// The raw vector index. Greppable by design: every `.index()` is a

    /// deliberate exit from the typed space.

    #[inline]

    #[must_use]

}

impl core::fmt::Display for LayoutNodeId {

}

/// The complete layout tree structure.

///

/// Uses a struct-of-arrays (`SoA`) layout for cache performance:

/// - `nodes` (hot): accessed on every node in every layout pass

/// - `warm`: accessed during specific layout phases

/// - `cold`: construction / reconciliation only

#[derive(Debug, Clone)]

pub struct LayoutTree {

    /// Hot layout data — box props, parent, `used_size`, formatting context

    pub nodes: Vec<LayoutNodeHot>,

    /// Warm layout data — intrinsic sizes, baseline, inline layout, etc.

    pub warm: Vec<LayoutNodeWarm>,

    /// Cold layout data — dirty flags, fingerprints, reconciliation data

    pub cold: Vec<LayoutNodeCold>,

    /// Root node index

    pub root: usize,

    /// Mapping from DOM node IDs to layout node indices

    // BTreeMap (not HashMap): std HashMap's RandomState hasher needs an RNG seed

    // that isn't available in the remill-lifted wasm (no getrandom), so inserts

    // silently no-op there — dom_to_layout came back empty (node mapping lost,

    // get_node_size/position returned None → 0-rects). BTreeMap is deterministic,

    // matches the rest of azul-core, and lifts reliably (M12.7).

    pub dom_to_layout: BTreeMap<NodeId, Vec<LayoutNodeId>>,

    /// Flat arena holding all children indices contiguously.

    pub children_arena: Vec<usize>,

    /// Per-node (start, len) into `children_arena`. Indexed by node index.

    pub children_offsets: Vec<(u32, u32)>,

    /// Per-node bit: this node or any descendant establishes a shrink-to-fit

    /// (STF) context whose sizing algorithm reads children's intrinsic sizes

    /// (flex/grid/table/inline-block containers, floats, or abspos elements).

    ///

    /// If `subtree_needs_intrinsic[i]` is false AND no ancestor of `i` is STF

    /// either, the intrinsic sizing pass can skip the entire subtree — nothing

    /// will ever read those values. This is the static-DOM optimization from

    /// §58 Win #3 (the "safely re-enabled Fix C").

    ///

    /// Computed once at tree build time in `generate_layout_tree`. An empty

    /// vec means "assume every subtree needs intrinsics" (safe fallback for

    /// code paths that construct `LayoutTree` without going through the

    /// builder — currently none, but preserves the invariant for tests).

    pub subtree_needs_intrinsic: Vec<bool>,

}

/// Approximate per-field heap-byte breakdown of a [`LayoutTree`].

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

pub struct LayoutTreeMemoryReport {

    pub node_count: usize,

    pub hot_bytes: usize,

    pub warm_bytes: usize,

    pub warm_inline_layout_bytes: usize,

    /// Shaped clusters retained across the whole tree. A cluster is one

    /// grapheme, so on Latin text this is roughly the CHARACTER COUNT of

    /// everything laid out — the number that explains `warm.inline`.

    pub shaped_cluster_count: usize,

    /// Shaped glyphs retained. Differs from the cluster count only for

    /// ligatures and combining marks.

    pub shaped_glyph_count: usize,

    /// Bytes of per-cluster heap `String` (each cluster owns a copy of its

    /// own text). Called out separately because it is pure duplication of

    /// text the DOM already holds.

    pub shaped_cluster_text_bytes: usize,

    /// Distinct `Arc<StyleProperties>` allocations the retained glyphs point

    /// at, by pointer identity.

    ///

    /// A document has a handful of distinct text styles (body, headings,

    /// code), so a healthy number here is single digits no matter how many

    /// glyphs there are. A count that tracks the GLYPH count means the

    /// sharing predicate has silently stopped sharing — Stylo hit exactly

    /// this, ending up with 109k `ComputedValues` where 2,200 were expected

    /// because one pseudo-element rule defeated the predicate. At 248 B per

    /// `StyleProperties` that failure is invisible and expensive.

    pub distinct_glyph_style_arcs: usize,

    /// Paint-run cache (`CachedInlineLayout::glyph_runs`): heap bytes of the

    /// retained `Vec<SimpleGlyphRun>` lists, each distinct Arc counted once

    /// (`GlyphSwap` reuse shares them). This is the store-time derivation that

    /// makes every paint a lookup — the retained cost of that trade.

    pub glyph_run_bytes: usize,

    /// Distinct `SimpleGlyphRun`s behind `glyph_run_bytes`.

    pub glyph_run_count: usize,

    /// Total `GlyphInstance`s retained across those runs (the 20 B/each bulk).

    pub glyph_instance_count: usize,

    pub warm_taffy_cache_bytes: usize,

    pub cold_bytes: usize,

    pub dom_to_layout_bytes: usize,

    pub children_arena_bytes: usize,

    pub children_offsets_bytes: usize,

}

impl LayoutTreeMemoryReport {

}

impl LayoutTree {