Gemini Perf Response2

// In layout/src/solver3/mod.rs

/// Holds the results of a layout pass before DisplayList generation
pub struct LayoutResults {
    pub tree: crate::solver3::layout_tree::LayoutTree,
    pub calculated_positions: std::collections::BTreeMap<usize, azul_core::geom::LogicalPosition>,
    pub width: f32,
    pub height: f32,
}

// In layout/src/solver3/paged_layout.rs

// 1. Refactor the inner layout logic to return LayoutResults instead of DisplayList
fn compute_layout_fresh<T: ParsedFontTrait + Sync + 'static>(
    cache: &mut LayoutCache, // Used only for scratch space/buffers
    text_cache: &mut TextLayoutCache,
    fragmentation_context: &mut FragmentationContext,
    new_dom: &StyledDom,
    viewport: LogicalRect,
    font_manager: &crate::font_traits::FontManager<T>,
    get_system_time_fn: azul_core::task::GetSystemTimeCallback,
) -> Result<crate::solver3::LayoutResults> {
    
    // SETUP CONTEXT
    let mut counter_values = BTreeMap::new();
    let empty_text_selections = BTreeMap::new();
    
    // SKIP RECONCILIATION: Just build the tree from scratch
    // This replaces reconcile_and_invalidate()
    let mut ctx_tree = LayoutContext {
        styled_dom: new_dom,
        font_manager,
        selections: &BTreeMap::new(),
        text_selections: &empty_text_selections,
        debug_messages: &mut None, // Skip debug during tree build
        counters: &mut counter_values,
        viewport_size: viewport.size,
        fragmentation_context: Some(fragmentation_context),
        cursor_is_visible: true,
        cursor_location: None,
        cache_map: Default::default(),
        system_style: None,
        get_system_time_fn,
    };

    // O(N) tree build instead of O(N) diffing + O(N) patching
    let mut new_tree = crate::solver3::layout_tree::generate_layout_tree(&mut ctx_tree)?;

    // COMPUTE COUNTERS
    crate::solver3::cache::compute_counters(new_dom, &new_tree, &mut counter_values);

    // SETUP LAYOUT CONTEXT
    let mut cache_map = std::mem::take(&mut cache.cache_map);
    cache_map.resize_to_tree(new_tree.nodes.len());
    
    // Mark ROOT as dirty - this forces full layout without checking dirty flags recursively
    let layout_roots = std::collections::BTreeSet::from([new_tree.root]);
    let intrinsic_dirty = (0..new_tree.nodes.len()).collect(); // Everything needs measuring

    let mut ctx = LayoutContext {
        styled_dom: new_dom,
        font_manager,
        selections: &BTreeMap::new(),
        text_selections: &empty_text_selections,
        debug_messages: &mut None, // Pass mutable reference if you want logs
        counters: &mut counter_values,
        viewport_size: viewport.size,
        fragmentation_context: Some(fragmentation_context),
        cursor_is_visible: true,
        cursor_location: None,
        cache_map,
        system_style: None,
        get_system_time_fn,
    };

    // LAYOUT LOOP (Same as before, but operating on fresh tree)
    // ... [Copy the layout loop logic from layout_document_with_fragmentation] ...
    // ... [BUT STOP before generate_display_list] ...
    
    // Execute sizing and positioning logic...
    // (See full implementation block below)
    
    let cache_map_back = std::mem::take(&mut ctx.cache_map);
    cache.cache_map = cache_map_back;
    
    Ok(crate::solver3::LayoutResults {
        tree: new_tree,
        calculated_positions,
        width: viewport.size.width,
        height: viewport.size.height, // Or calculated content height
    })
}

// 2. Update the main paged layout function to use this optimized path
pub fn layout_document_paged_with_config(...) -> Result<Vec<DisplayList>> {
    // ... [Font loading code remains same] ...

    // --- OPTIMIZED LAYOUT PATH ---
    // 1. Compute Layout (Tree + Positions) ONLY. Do not generate Display List.
    let layout_results = compute_layout_fresh(
        cache,
        text_cache,
        &mut fragmentation_context,
        new_dom,
        viewport,
        font_manager,
        get_system_time_fn,
    )?;

    // 2. NOW generate the display list, but only ONCE for the infinite canvas
    let (scroll_ids, _) = crate::window::LayoutWindow::compute_scroll_ids(&layout_results.tree, new_dom);

    let mut ctx = LayoutContext {
        // ... set up context ...
    };

    let full_display_list = crate::solver3::display_list::generate_display_list(
        &mut ctx,
        &layout_results.tree,
        &layout_results.calculated_positions, // <--- Using positions we just computed
        scroll_offsets,
        &scroll_ids,
        gpu_value_cache,
        renderer_resources,
        id_namespace,
        dom_id,
    )?;

    // 3. Paginate
    // ... [Pagination logic remains same] ...
}

// LayoutCache definition
pub struct LayoutCache {
    pub tree: Option<LayoutTree>,
    // CHANGE THIS:
    // pub calculated_positions: BTreeMap<usize, LogicalPosition>,
    pub calculated_positions: Vec<LogicalPosition>, 
    // ...
}

// In calculate_layout_for_subtree and friends:
// Instead of: calculated_positions.insert(idx, pos);
// Do: 
// if idx >= calculated_positions.len() {
//     calculated_positions.resize(idx + 1, LogicalPosition::zero());
// }
// calculated_positions[idx] = pos;

// Instead of: calculated_positions.get(&idx)
// Do: calculated_positions.get(idx) (returns Option<&T>)

// In printpdf/src/html/mod.rs

// Change this:
// let mut debug_messages = Some(Vec::new()); 
// To:
let mut debug_messages = if cfg!(debug_assertions) { 
    Some(Vec::new()) 
} else { 
    None 
};