Method updateScrollState

valdi/src/valdi/runtime/Context/ViewNode.cpp:2448–2611

                                                 forceLayout,
                                                 /* isFromLazyLayout */ true);

    _lazyLayoutData->availableWidth = _calculatedFrame.width;
    _lazyLayoutData->availableHeight = _calculatedFrame.height;
    return updated;
}

void ViewNode::updateStickyHeaders(bool refreshCache) {
    if (_scrollState == nullptr || !_scrollState->getNativeStickyEnabled()) {
        return;
    }
    if (_viewNodeTree == nullptr) {
        return;
    }

    float scrollY = _scrollState->getDirectionAgnosticContentOffset().y;
    // Pixels of visual overhang above sticky headers. Extends the effective header
    // height for the clamp so a header rendering a bar above its yoga bounds
    // (SectionList.stickyCover) stops sliding before the next section arrives.
    // Mirrors SectionList.tsx's `headerHeight = getHeaderHeight() + coverHeight`.
    float stickyCover = _scrollState->getNativeStickyCover();
    // Pixels below scroll viewport top where headers pin. Matches CSS `top: N`.
    // Effectively shifts the pin position down so headers aren't clipped behind
    // a floating page header with visual footprint past its Yoga bounds.
    float stickyOffset = _scrollState->getNativeStickyOffset();

    // We push translationY updates through the attribute-set path so both the C++ state
    // and the platform-side transform binder fire in the same frame. withLock acquires
    // the tree mutex (recursive -- safe if already held on the Android scroll path) and
    // opens a ViewTransactionScope. Nested calls piggyback on the outer transaction; a
    // top-level call submits at end-of-scope, pushing transforms in the same VSYNC as
    // the scroll gesture.
    _viewNodeTree->withLock([&]() {
        auto& scope = _viewNodeTree->getCurrentViewTransactionScope();

        // Bounded-depth subtree walk. Header nesting in SubscreenSections is deep:
        // scroll -> PullToRefresh -> SubscreenContent -> paddingRight layout ->
        // SectionList root -> SectionListItem root -> column-reverse layout -> header
        // (~8 levels). 16 covers that plus any consumer wrapping without unbounded cost.
        // Skip into nested scrolls: each scroll owns its own sticky pass.
        static constexpr int kStickyMaxDepth = 16;
        auto* owner = AttributeOwner::getNativeOverridenAttributeOwner();
        std::function<void(ViewNode*, int)> walk = [&](ViewNode* node, int depth) {
            if (depth <= 0) {
                return;
            }
            for (auto* child : *node) {
                if (child->getStickyPosition() == StickyPositionTop) {
                    if (refreshCache) {
                        auto* parent = child->getParent().get();
                        // parent Y relative to this scroll node (sum yoga Top edges up the chain).
                        float parentY = 0.0f;
                        float parentH = 0.0f;
                        if (parent == this) {
                            // Direct child of the scroll: no parent section to clamp against.
                            // Treat the sticky track as unbounded so the header stays pinned once
                            // scrolled past its natural Y, matching CSS `position: sticky`
                            // semantics for elements whose containing block is the scroll itself.
                            parentH = std::numeric_limits<float>::max();