//! Intrinsic and used size calculations for layout nodes

use crate::solver3::layout_tree::LayoutNodeId;

use crate::debug_log;

use std::{

    collections::BTreeSet,

    sync::Arc,

};

use azul_core::{

    dom::{FormattingContext, NodeId, NodeType},

    geom::LogicalSize,

    resources::RendererResources,

    styled_dom::{StyledDom, StyledNodeState},

};

use azul_css::{

    css::CssPropertyValue,

    props::{

        basic::PixelValue,

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutFlexWrap, LayoutFloat, LayoutHeight, LayoutPosition, LayoutWidth, LayoutWritingMode},

        property::{CssProperty, CssPropertyType},

    },

    LayoutDebugMessage,

};

use rust_fontconfig::FcFontCache;

#[cfg(feature = "text_layout")]

use crate::text3;

use crate::{

    font::parsed::ParsedFont,

    font_traits::{

        AvailableSpace, FontLoaderTrait, FontManager, ImageSource, InlineContent, InlineImage,

        InlineShape, LayoutCache, LayoutFragment, ObjectFit, ParsedFontTrait, ShapeDefinition,

        StyleProperties, UnifiedConstraints,

    },

    solver3::{

        fc::split_text_for_whitespace,

        geometry::{BoxProps, IntrinsicSizes, WritingModeContext},

        getters::{

            get_css_box_sizing, get_css_height, get_css_width, get_display_property,

            get_direction_property, get_element_font_size, get_flex_direction, get_float,

            get_style_properties, get_text_orientation_property, get_writing_mode, MultiValue,

        },

        layout_tree::{LayoutNodeHot, LayoutTree, get_display_type},

        positioning::get_position_type,

        LayoutContext, LayoutError, Result,

    },

};

const FALLBACK_MIN_CONTENT_WIDTH: f32 = 100.0;

const FALLBACK_MAX_CONTENT_WIDTH: f32 = 300.0;

const FALLBACK_MIN_CONTENT_HEIGHT: f32 = 20.0;

const FALLBACK_MAX_CONTENT_HEIGHT: f32 = 20.0;

/// Resolves a min/max sizing `PixelValue`, falling back to percentage-against-

/// containing-block resolution (with box-model adjustment) when the value is a

/// percentage rather than an absolute length.

///

/// `is_horizontal` selects which axis of `box_props` (left/right vs top/bottom)

/// is subtracted during percentage resolution.

    } else {

    };

/// Resolves a percentage value against the containing block dimension.

///

/// Per CSS 2.1 Section 10.2, percentages resolve directly against the containing

/// block's width or height. The margin/border/padding parameters are accepted for

/// call-site convenience but are intentionally unused — percentage resolution does

/// not subtract box-model extras in content-box sizing.

///

/// Returns `(containing_block_dimension * percentage).max(0.0)`.

// +spec:containing-block:43c719 - percentages resolved against containing block width/height

// +spec:containing-block:723eee - Percentages specify sizing with respect to the containing block

// +spec:containing-block:8ad6f4 - Percentage resolution against containing block (editorial note: transferred percentages)

// +spec:containing-block:257f3b - Block-axis percentages resolve against containing block size

// +spec:containing-block:f1344e - percentage min/max-width resolved against containing block width; negative CB width yields zero

    // +spec:containing-block:b3388b - percentage resolved against containing block size without re-resolution (css-sizing-3 §5.2.1)

    // CSS 2.1 Section 10.2: percentages resolve against containing block,

    // not available space after margins/borders/padding

/// Returns true if the DOM subtree rooted at `dom_id` contains any `NodeType::Text`.

///

/// Used when deciding whether a `FormattingContext::Inline` node should measure

/// its inline content (it acts as an IFC root when nested inlines eventually

/// hold text) versus returning zero (pure inline wrapper with no text reaches).

/// Phase 2a: Calculate intrinsic sizes (bottom-up pass)

/// // +spec:display-contents:f12d4e - intrinsic sizing: size determined by contents, not context

// [g71 TEST] #[inline(never)] — RELIABLE bisection (g70, markers in free band) showed new_tree drops

// 2→0 RIGHT BEFORE this call. It's currently INLINED into layout_document (absent from the lift log),

// so its frame/entry isn't a separate SP-wrapped @sub_ call. Forcing it OUT makes the call a wrapped

// @sub_ → enforce_sp_preservation save/restores SP around it. If new_tree survives (sizingEntry=2),

// the inlined entry/frame-setup was mis-lifting SP. (g60's inline(always) was a no-op — already inlined.)

#[inline(never)]

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

/// # Errors

///

/// Returns a `LayoutError` if intrinsic sizing fails.

    // [az-diag g59 REVERT] RELIABLE field-access bracket (pointer CASTS mis-lift to 0 — g58 proved

    // it; use tree.nodes.len() which is reliable). 0x407B0 = nodes.len at ENTRY. If 2 here but

    // 0x40734 (line ~142, after compute_dirty_ancestor_closure + calculator) reads 0, the corruption

    // is in 121-142. compute_dirty_ancestor_closure RETURNS a HashSet by sret — prime suspect:

    // sret-slot overlapping new_tree, or the hashbrown empty-map bug. 0x407B4 (post-compute_dirty)

    // isolates compute_dirty vs calculator-creation.

    // Pre-compute the "ancestor closure" of dirty_nodes: every dirty

    // node AND each of its ancestors up to root. A node not in this

    // set (and whose `intrinsic_sizes` is already populated) can

    // reuse its cached intrinsic — we skip its entire subtree walk.

    // Before this, `calculate_intrinsic_recursive` walked the full

    // tree from root regardless, costing ~2 ms per warm render on

    // excel.html even when only 3 nodes were actually dirty.

    // [az-diag g59 REVERT] 0x407B4 = nodes.len AFTER compute_dirty_ancestor_closure (its HashSet sret).

    // Fix C (re-enabled §58 Win #3): skip intrinsic computation for subtrees

    // whose values will never be consumed. `tree.subtree_needs_intrinsic` is a

    // static-DOM bitmap precomputed at tree-build time — true if this node or

    // any descendant establishes a shrink-to-fit context. When both the

    // caller and the subtree are non-STF, no one reads the intrinsic, so the

    // whole descent is pure waste.

    //

    // The previous attempt (7667d13e, reverted in bd9ad36d) wrote default

    // (zero) intrinsics and broke auto-height rendering because

    // calculate_used_size_for_node read intrinsic.max_content_height as the

    // height:auto fallback. 97c3d3db refactored that dependency away: for

    // block-level auto-height, used_size.height is 0 pre-layout and

    // apply_content_based_height fills it from the laid-out content size.

    // With that gone, skipping intrinsic is safe.

    // [az-diag g53 REVERT] DECISIVE: is the lifted LayoutTree itself empty/broken? If

    // tree.get(root)=None (0x40738=0) or nodes.len()=0 (0x40734), the InvalidTree@229 is

    // because RECONCILE produced a broken tree — root cause is reconcile, not sizing.

        }

    }

struct IntrinsicSizeCalculator<'a, 'b, 'c, T: ParsedFontTrait> {

    ctx: &'a mut LayoutContext<'b, T>,

    /// Shared text shaping cache, threaded through from the caller so

    /// stages 1–3 of the inline layout pipeline (logical / `BiDi` / shaping)

    /// are cache-hits across the sizing pass's min/max-content measurements

    /// AND the subsequent real layout pass. Previously each pass held its

    /// own `LayoutCache`, so identical text was shaped three times per

    /// `root_layout_pass` — once per min-content measurement, once per

    /// max-content measurement, once at final layout.

    text_cache: &'c mut LayoutCache,

    /// If `Some`, only nodes in this set (the ancestor-closure of

    /// dirty nodes) need recomputation. A clean node whose

    /// `warm.intrinsic_sizes` is already populated reuses the

    /// cached value and skips its entire subtree descent.

    dirty_closure: Option<std::collections::HashSet<usize>>,

}

impl<'a, 'b, 'c, T: ParsedFontTrait> IntrinsicSizeCalculator<'a, 'b, 'c, T> {

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

        // [az-diag g52 REVERT] 0x40720 = node_index entering calculate_intrinsic_recursive

        // (last value after the run = the node that InvalidTree'd or the stray child).

        // Fast path: if this subtree has no dirty nodes AND we

        // already have a cached intrinsic, return the cached value

        // and skip the whole descent. Caller is the ancestor-closure

        // computation in `calculate_intrinsic_sizes` — anything not

        // in that set is guaranteed clean through every descendant.

                {

                // A node the reconcile pass called CLEAN whose intrinsic

                // was not carried over: it recomputes (text measurement,

                // ~3 ms for an IFC root) even though nothing about it

                // changed. Counted so the warm profile shows how much of

                // the sizing pass is this hole rather than real work.

        // Fix C static-DOM short-circuit: if no ancestor needs this intrinsic

        // (none are STF) AND no descendant in this subtree is STF, nobody

        // will ever read the value. Write a default and skip the recursion.

        // `subtree_needs_intrinsic` is precomputed at tree-build time from

        // the DOM's display/position/float properties, so this is a constant

        // lookup with no per-pass work.

        {

        // Previously cloned the full LayoutNode to sidestep borrow conflicts

        // with the `&mut tree` recursive calls below, but we only need the

        // DOM id here — a `Copy` scalar. The clone was allocating a

        // Vec<usize> for children and a TaffyCache on every recursion

        // (~300x on excel.html).

            .dom_node_id;

        // Out-of-flow (absolute/fixed) elements must NOT contribute to their

        // parent's intrinsic size — but they still need their OWN intrinsic size

        // computed, because an abs-pos box with `width:auto` is sized shrink-to-fit

        // (§10.3.7), which reads this node's max-content width. So we compute and

        // store the real intrinsic size below, then return zero to the caller so

        // the parent ignores it. (Previously this early-returned zero AND stored

        // zero on the node, collapsing every auto-width abs-pos box to width 0.)

            LayoutPosition::Absolute | LayoutPosition::Fixed

        );

        // Copy child indices before recursive calls (which need &mut tree).

        // Stack buffer for the common case (≤32 children); heap only for huge nodes.

        let heap_buf: Vec<usize>;

        } else {

        };

        // Propagate STF flag: children inherit `ancestor_is_stf=true` if any

        // ancestor up to and including self is STF.

                )

            // [az-diag g52 REVERT] 0x40728 = child_index about to recurse (last = the stray).

            // [g52 FIX] Defensive: reconcile can mis-list a stray/out-of-range child_index

            // (a Text node mis-listed as a layout child, or a lift artifact in the children

            // array). The unguarded recursion would hit `tree.get(child_index).ok_or(InvalidTree)`

            // at line ~226 and abort the WHOLE intrinsic-sizing pass. Skip gracefully so

            // measurement continues — mirrors process_layout_children's guard (line ~1079).

            // REAL fix = reconcile not listing the stray child.

        }

        // Then calculate this node's intrinsic size based on its children

        // +spec:min-max-sizing:970fef - if min-width/min-height is a <length>, use as floor for intrinsic sizes

            use crate::solver3::getters::{get_css_min_width, get_css_min_height, MultiValue};

            // Resolve em against the element's OWN font-size and rem against the root.

            // css-sizing-3 §5.2.1: a box with a DEFINITE preferred size

            // contributes exactly that size — its min- and max-content are

            // the used width/height, not the (possibly empty) content's.

            // Without this, an empty `width: 794px` block contributed 0, so

            // every shrink-to-fit ancestor (auto-width abspos §10.3.7,

            // floats §10.3.5) collapsed to 0x0 and its children vanished

            // (miniword ENGINE-ISSUE 5c). Intrinsics here are CONTENT sizes,

            // so border-box declarations shed their border+padding first.

            // Applied BEFORE the min floors so an explicit min still wins.

            {

                use azul_css::props::layout::dimensions::{LayoutWidth, LayoutHeight};

                use azul_css::props::layout::LayoutBoxSizing;

                };

                {

                {

            }

        // An out-of-flow box's own intrinsic size is stored above (for its

        // shrink-to-fit auto width), but it does not contribute to its parent's

        // intrinsic size — return zero to the caller.

        } else {

        }

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

        // +spec:block-formatting-context:30def2 - replaced elements use physical 300x150 default, not re-oriented by writing-mode

        // +spec:display-property:015c41 - replaced elements default to 300x150 intrinsic size per css-sizing-3 §5.1

        // +spec:display-property:2c6af3 - replaced elements with auto width/height use max-content size

        // +spec:replaced-elements:6d6030 - Intrinsic sizes for replaced elements (images, virtual views)

        // VirtualViews are replaced elements with a default intrinsic size of 300x150px

        // (same as virtualized view elements)

            // +spec:containing-block:bb5a12 - replaced element intrinsic sizes using initial containing block

            // +spec:display-property:7127f9 - intrinsic sizes of replaced elements without natural sizes (300x150 fallback, aspect ratio)

            // +spec:display-property:f9cede - replaced elements derive intrinsic size from natural dimensions

            // +spec:writing-modes:b18121 - stretch fit inline size from available space, calculate block size via aspect ratio

                // Overlay→DOM: a runtime-swapped image's intrinsic size must

                // drive layout (the DOM is immutable; live content is in the

                // overlay). Produced callback frames are deliberately NOT

                // consulted — `image_for_layout` keeps the DOM's declared

                // (sizeless) callback so a per-frame producer cannot resize

                // the box it draws into.

                // +spec:containing-block:1da6dc - use initial CB inline size for replaced elements with aspect ratio but no intrinsic size

                // Per css-sizing-3 §5.1: "use an inline size matching the corresponding dimension

                // of the initial containing block and calculate the other dimension using the aspect ratio"

                    // Has intrinsic height but no width — use initial CB inline dimension

                } else {

                    // +spec:replaced-elements:43376b - 300px fallback with 2:1 ratio for replaced elements

                    // No intrinsic dimensions — cap at 300x150 per CSS 2.2 §10.3.2

                    // +spec:width-calculation:3b0efe - auto width fallback: 300px capped to device width

                    // +spec:width-calculation:16c305 - auto height fallback: 2:1 ratio, max 150px

                };

                // A replaced element with NO intrinsic size (e.g. a RenderImageCallback

                // <img> like the AzulPaint canvas) must behave like a VirtualView: keep

                // the 300×150 fallback as the min/max-content (so it has a sensible

                // default) but leave `preferred` as None so `flex-grow` / explicit CSS

                // can size it. A `Some(preferred)` here pins the box and defeats

                // flex-grow (the canvas was laid out 300×0 — see the VirtualView arm

                // above, which already uses None for exactly this reason). Images WITH

                // a real intrinsic size keep `preferred = Some` so they display at their

                // natural size when unconstrained.

                } else {

                };

            FormattingContext::Block { .. } => {

                // Check if this block establishes an Inline Formatting Context (IFC).

                // Per CSS 2.2 §9.2.1.1: A block container with mixed block-level and

                // inline-level children creates anonymous block boxes to wrap the inline

                // content. So we only treat as IFC root if there are NO block-level children.

                //

                // We check the actual CSS display property, NOT formatting_context,

                // because a display:block element with only inline children gets

                // FormattingContext::Inline (meaning "establishes IFC for its children"),

                // which is different from being an inline element itself.

                            // Text nodes are inline-level

                                LayoutDisplay::Inline

                                | LayoutDisplay::InlineBlock

                                | LayoutDisplay::InlineFlex

                                | LayoutDisplay::InlineGrid

                                | LayoutDisplay::InlineTable

                            )

                // IFC root only if there are inline children and NO block children.

                // If there are block children, text nodes get anonymous block wrappers.

                // Also check if this block has direct text content (text nodes in DOM)

                // but ONLY if there are no block-level layout children

                } else {

                };

                    // This block is an IFC root - measure all inline content ONCE

                } else {

                    // This is a BFC root (only block children) - aggregate child sizes

                }

            }

            FormattingContext::Inline => {

                // There are THREE cases for FormattingContext::Inline:

                // 1. A Text node (NodeType::Text) - this IS the text content itself

                //    -> Needs to measure itself as an atomic inline unit

                // 2. An IFC root - a block with only inline children (has text child nodes)

                //    -> Should measure its inline content

                // 3. A true inline element (display: inline, e.g., <span>) with no text

                //    -> Returns default(0,0), measured by parent IFC root

                //

                // We distinguish by:

                // - Checking if THIS node is a Text node (case 1)

                // - Checking if this subtree contains any text (case 2)

                //

                // Why descendants, not just direct children: for `<span><a>text</a></span>`,

                // the `<span>` is a layout-tree IFC root (layout_ifc is called on it), but

                // its direct DOM children are inline elements, not text. Restricting the

                // check to direct text children would zero out the span's intrinsic width

                // even though the cell content width depends on it.

                } else {

                };

                } else {

                };

                    // Case 1 or 2: Text node or IFC root - measure inline content

                } else {

                    // Case 3: True inline element - measured by parent IFC root

                }

            }

            FormattingContext::InlineBlock => {

                // Inline-block IS an atomic inline - it needs its own intrinsic size.

                // Check layout tree children AND direct DOM text children (text nodes

                // are not in the layout tree, only in the DOM).

                } else {

                };

                    // InlineBlock with inline children - measure as IFC root.

                    // Returns content-level intrinsic sizes (no margin/padding/border).

                    // The parent adds box-model extras via calculate_block_intrinsic_sizes,

                    // and calculate_used_size_for_node adds padding+border for border-box.

                } else {

                    // InlineBlock with block children - aggregate like block

                }

            }

            FormattingContext::Table => {

            }

            FormattingContext::Flex => {

            }

        }

    // +spec:intrinsic-sizing:ea2c2c - §5.1 min-content size = size as float with auto; max-content = no wrapping

    /// Calculate intrinsic sizes for an IFC root (a block containing inline content).

    /// This collects ALL inline descendants' text and measures it ONCE.

    // +spec:intrinsic-sizing:8f3c0c - hanging glyphs must be excluded from intrinsic size measurement

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

        // [g75] 0x60758 = how many times this IFC sizer is entered; 0x6075C = node_index of THIS call.

        // Collect all inline content from this IFC root and its inline descendants

        // [g76] EXPLICIT match (was `?`): the g75 markers showed collect_inline_content reaching its

        // completion marker B8 (Ok at the source level) yet the IFC sizer never advancing to 0xA1 —

        // i.e. the lifted `Result<Vec<InlineContent>, LayoutError>` return arrives as Err at this call

        // site (a complex by-value Result-return mis-lift). 0x60760 = 1 (Ok) / 0xEE (Err-but-B8-ran).

        // RESILIENCE: on Err, degrade to empty content (→ default intrinsic) instead of aborting the

        // WHOLE layout with InvalidTree, so the page renders and the next real blocker surfaces.

        // g76 PROVED: degrading to Vec::new() here (resilience) lets layout proceed past this

        // InvalidTree but then HANGS in the downstream actual-layout shaping (the documented g47

        // hashbrown empty-map infinite loop). So for a CLEAN (non-hanging) state we PROPAGATE the Err

        // (same as the original `?`), keeping the 0x60760 diagnostic. To chase the g47 hang, flip the

        // Err arm back to `Vec::new()`. 0x60760 = 1 (Ok) / 0xEE (Err-despite-B8 = the Result mis-lift).

        // [g78] OUT-PARAM refactor: the by-value `Result<Vec<InlineContent>, LayoutError>` return

        // mis-lifted Ok→Err (g76/g77 PROVED it: 0x60760=0xEE despite the source reaching B8). Filling

        // a `&mut Vec` out-param and returning `Result<()>` (register-returned, NO sret-of-Vec) lifts

        // cleanly — the established M12.7 "a pointer arg lifts cleanly" pattern. 0x60760 should now =1.

        };

        #[cfg(feature = "web_lift")]

        unsafe { crate::az_mark((0x60760) as u32, (if collect_result.is_ok() { 0x00000001u32 } else { 0x000000EEu32 }) as u32); }

        // Get pre-loaded fonts from font manager

        // +spec:intrinsic-sizing:ae8beb - min-content = zero-width CB, max-content = infinite-width CB

        // +spec:intrinsic-sizing:8c94e2 - min-content/max-content intrinsic size determination via constrained layout

        // Use `measure_intrinsic_widths` instead of two `layout_flow` passes (fix B):

        // it runs stages 1–4 of the pipeline once (logical → BiDi → shape → orient)

        // and derives min/max-content by scanning the shaped items directly. This

        // avoids the BreakCursor line-breaking loop entirely — that loop clones

        // every ShapedCluster it inspects via `peek_next_unit` and accounted for

        // 24% of total CPU on the text_2000 stress fixture. Shaping is cached

        // at the per-item level (keyed on text+style), so the subsequent real

        // layout_flow call for this content gets pure cache hits for stages 1–3.

        // Populate the measurement constraints from the IFC root's real white-space

        // mode instead of always using defaults. With the default (Normal) the scan

        // treats every space as a break opportunity, so a white-space:nowrap / pre

        // element reports a min-content SMALLER than its true unbreakable width and

        // the flex/shrink-to-fit algorithm clips it.

            use crate::solver3::getters::{get_white_space_property, MultiValue};

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

            };

            };

        // [g79 DIAG] Probe the font state at shaping time, then convert the downstream shape_text

        // HANG (g47 hashbrown empty-map loop) → trap so the harness RETURNS and these markers are

        // readable (can't read markers from a hung wasm call). Tests the #4→#3 coupling: if

        // 0x60768(font_chain_cache.len) / 0x6076C(loaded_fonts.len) are 0, the EMPTY FONT CHAIN is

        // the ROOT of the hang (no font → allsorts builds empty hashbrown maps → RawIter loops).

        // [g82] CONDITIONAL trap: if the font_chain_cache is still EMPTY, shaping would HANG (allsorts

        // builds empty hashbrown maps → g47 RawIter loop) → trap instead so the markers are readable

        // (non-hang). If the chain is NON-empty (unique_font_keys BTreeMap fix worked + populated it),

        // PROCEED into measure → shape → text should MEASURE. g81 hung (no conditional) → need to know

        // whether the chain populated. 0x60768=chain.len, 0x6076C=loaded_fonts.len, 0x60704=0xA15.

        #[cfg(feature = "web_lift")]

        {

            let cl = self.ctx.font_manager.font_chain_cache.len();

            unsafe {

                crate::az_mark((0x60768) as u32, (cl as u32) as u32);

                crate::az_mark((0x6076C) as u32, (loaded_fonts.len() as u32) as u32);

                crate::az_mark((0x60704) as u32, (0xA15u32) as u32);

            }

            // [g88] g85+g87 PROVED whack-a-mole does NOT converge: BTreeMap'd unique_font_keys (chain

            // ✓), supported_features+lookups_index (g85), ReadCache (g87) — STILL HANGS. Too many

            // hashbrown empty-map sites across allsorts/std/rust-fontconfig. The ONLY convergent fix is

            // the SYSTEMIC transpiler empty-static mirror (force the lifted hashbrown ctrl-scan to read

            // 0xFF not 0x00). TEMP non-hang trap until that lands. ★ REMOVE to test the systemic fix.

            // [g93] PROCEED into shaping to test the AZ_FORCE_MIRROR_VMADDRS hashbrown-EMPTY_GROUP fix.

            // If text MEASURES → the forced const pages contained EMPTY_GROUP → systemic fix found.

            let _ = (cl, loaded_fonts.len());

        }

        };

        // +spec:display-property:c587fd - min-content block size equals max-content block size for block containers, tables, inline boxes

        // +spec:intrinsic-sizing:02eedc - min-content block size equals max-content block size for block containers

        // For a single-line max-content layout the height is one line box;

        // `measure_intrinsic_widths` returns exactly that.

        // NOTE(writing-modes): min_content_width / max_content_width are named for

        // the physical axis. In vertical writing modes the "inline" axis is vertical,

        // so these are swapped by calculate_block_intrinsic_sizes when computing

        // the parent's intrinsic sizes. The physical naming is intentional here.

    // +spec:containing-block:bb0658 - percentage block-sizes behave as auto during intrinsic computation (no CSS height resolution here)

    // +spec:display-contents:84fe7f - cyclic percentage contributions: percentage-sized children use auto during intrinsic sizing

    // +spec:min-max-sizing:411904 - percentage block-sizes treated as auto during intrinsic sizing (content-sized CB)

    // +spec:min-max-sizing:737e62 - percentage heights don't resolve inside content-sized containing blocks

        // NOTE: Text content detection is now handled in calculate_node_intrinsic_sizes

        // which calls calculate_ifc_root_intrinsic_sizes for blocks with inline content.

        // This function now only handles pure block containers (BFC roots).

        // +spec:height-calculation:d9ca8d - cyclic percentage contributions: percentage min-height/max-height on children should behave as auto when computing intrinsic contributions (not yet implemented)

        // Track margins for CSS 2.2 §8.3.1 collapsing in the block direction.

        // Block margins collapse between siblings (max instead of sum) and

        // parent-child margins can escape (first/last child).

                // +spec:intrinsic-sizing:ed72bb - intrinsic contributions based on outer size, auto margins as zero

                        }

                };

                // CSS 2.2 §8.3.1 margin collapsing for intrinsic sizing:

                // - First child's margin-start can escape (don't add to total)

                // - Between siblings: collapsed gap = max(prev_end, curr_start)

                // - Last child's margin-end can escape (don't add to total)

        }

        // Last child's margin-end may escape — don't add it to total_main_size

        };

    // The max-content main size is the sum of items' max-content contributions.

    // The min-content main size of a single-line flex container is the sum of items'

    // min-content contributions. For multi-line, it is the largest min-content contribution.

    // Auto margins on flex items are treated as 0 for this computation.

        // Determine flex-direction to know if main axis is horizontal or vertical

            }

                } else {

                };

                // For multi-line min-content, track the largest single item

                // Cross axis: largest child determines the container's cross size

        }

        // For single-line (nowrap), min-content = sum; for multi-line (wrap), min-content = max

        // Default flex-wrap is nowrap (single-line)

            );

                    LayoutFlexWrap::NoWrap

                ))

        } else {

        }

    /// Calculate intrinsic sizes for a table element by aggregating cell content

    /// widths per column and row heights.

    /// +spec:table-layout:93b13c - shrink-to-fit for tables uses intrinsic sizing

        // Collect per-column min/max widths and total row heights.

        // Table structure: table > row-group? > row > cell

        // Iterate rows — children may be row groups (thead/tbody/tfoot) or direct rows

                FormattingContext::TableRowGroup => {

                    // Row group contains rows

                    }

                }

            }

        }

                // Also check if cell has IFC content we can measure

                } else {

                    // Try to measure cell content via IFC

                };

                // Add cell box-model extras

            }

        }

}

/// Gathers all inline content for the intrinsic sizing pass.

///

/// This function recursively collects text and inline-level content according to

/// CSS Sizing Level 3, Section 4.1: "Intrinsic Sizes"

/// <https://www.w3.org/TR/css-sizing-3/#intrinsic-sizes>

///

/// For inline formatting contexts, we need to gather:

/// 1. Text nodes (inline content)

/// 2. Inline-level boxes (display: inline, inline-block, etc.)

/// 3. Atomic inline-level elements (replaced elements like images)

///

/// The key difference from `collect_and_measure_inline_content` in fc.rs is that

/// this version is used for intrinsic sizing (calculating min/max-content widths)

/// before the actual layout pass, so it must recursively gather content from

/// inline descendants without laying them out first.

    // [g78] fill the caller's out-param (was a local Vec returned by value → Ok→Err mis-lift).

    // Recursively collect inline content from this node and its inline descendants

    // [g73] B8 = top-level recursion returned Ok (collect_inline_content complete).

/// Recursive helper for collecting inline content.

///

/// According to CSS Sizing Level 3, the intrinsic size of an inline formatting context

/// is based on all inline-level content, including text in nested inline elements.

///

/// This function:

/// - Collects text from the current node if it's a text node

/// - Collects text from DOM children (text nodes may not be in layout tree)

/// - Recursively collects from inline children (display: inline)

/// - Treats non-inline children as atomic inline-level boxes

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

    // [g75] capture node_index of EVERY recursion entry (0x60754) and mark the entry-tree.get

    // FAILURE distinctly (inline-phase=0xBAD) so a node_index that fails HERE (before B1) is

    // visible even though a PRIOR successful call already wrote B8. This is the suspected

    // InvalidTree site (phase stuck at 0xA0 + B8 reached ⇒ a 2nd IFC call fails at this get).

    };

    // CRITICAL FIX: Text nodes may exist in the DOM but not as separate layout nodes!

    // We need to check the DOM children for text content.

        // No DOM ID means this is a synthetic node, skip text extraction

    };

    // First check if THIS node is a text node

                    );

        // Use split_text_for_whitespace to correctly handle white-space: pre with \n

    // CRITICAL: Also check DOM children for text nodes!

    // Text nodes are often not represented as separate layout nodes.

    // However, we must SKIP children that already have a layout tree entry,

    // because those will be handled by process_layout_children() below.

    // Without this guard, text nodes present in both DOM and layout tree

    // get collected twice, causing inline-block containers to be ~2x too wide.

        // Skip DOM children that have layout tree nodes - they will be

        // processed via process_layout_children -> collect_inline_content_recursive

        // Check if this DOM child is a text node

                    );

            // Use split_text_for_whitespace to correctly handle white-space: pre with \n

            );

    }

    // [g73] B6 = DOM-children loop done (about to process_layout_children).

/// Helper to process layout tree children for inline content collection

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

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

    use azul_css::props::layout::{LayoutHeight, LayoutWidth};

    // [g73] PLC entry: 0x60708 = 0xC0<<24 | node_index (which node's children we process).

    // Process layout tree children (these are elements with layout properties)

        // [g73] PLC loop: 0x6070C = current child_index being processed.

        // 2026-06-02: was `.ok_or(LayoutError::InvalidTree)?` — a stray/invalid child_index in

        // tree.children (likely a Text node mis-listed during reconcile, since Text is INLINE

        // content not a layout-tree node) aborted the WHOLE intrinsic-sizing pass with

        // InvalidTree BEFORE the inline text got measured → label height 0. Skip gracefully so

        // measurement continues (the inline text is collected separately above, at the

        // collect_inline_content_recursive DOM-children loop). REAL fix = reconcile not listing it.

        };

        // CSS Sizing Level 3: Inline-level boxes participate in the IFC

            // Recursively collect content from inline children

            // This is CRITICAL for proper intrinsic width calculation!

        } else {

            // Non-inline children are treated as atomic inline-level boxes

            // (e.g., inline-block, images, floats)

            // Their intrinsic size must have been calculated in the bottom-up pass

            // CSS 2.2 § 10.3.9: For inline-block elements with explicit CSS width/height,

            // use the CSS-defined values instead of intrinsic sizes.

            // Resolve CSS width - use explicit value if set, otherwise fall back to intrinsic

                    // +spec:containing-block:495930 - percentages in intrinsic sizing fall back to intrinsic contribution (css-sizing-3 §5.2.1)

                    // +spec:containing-block:5246c0 - cyclic percentage: when containing block size depends on this box's intrinsic contribution, percentages fall back to intrinsic size