Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

83.7 KB
Raw Blame
//! Table / tool panes still hosted on App + startup project picker.
//!
//! Extracted per demonolith Wave 7. New pane bodies land here (or provider_panes),
//! not in `mod.rs`.

use ghidrust_core::FibScale;
use ghidrust_core::ThemeDensity;
use crate::layout_tokens::{card_frame, chip_frame, sized_button_height, FieldWidth};
use super::GhidrustApp;
use crate::checksum::ChecksumMode;
use crate::decrypt_ui::DecryptTab;
use crate::dock_tabs::DockTab;
use crate::listing::ui_detail_pane;
use crate::menu_actions::{decompile_entry_for_va, parse_address};
use crate::panes::{BookmarkKind, PaneKind};
use eframe::egui::{self, Color32};
use egui_dock::DockState;
use ghidrust_core::{
    disassemble_at_opts, recover_obfuscated_strings, AppearanceTheme, CommentKind, Program,
    RecoverStringsOpts, ThemeMode, XRef, BUILTIN_TYPES,
};
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};


/// Data Type Preview — every well-known Stage-0 interpretation of `bytes`.
pub(crate) fn preview_all(bytes: &[u8]) -> Vec<(&'static str, String)> {
    let mut out = Vec::new();
    if let Some(&b) = bytes.first() {
        out.push(("int8", format!("{}", b as i8)));
        out.push(("uint8", format!("{}", b)));
    }
    if bytes.len() >= 2 {
        let w = u16::from_le_bytes([bytes[0], bytes[1]]);
        out.push(("int16", format!("{}", w as i16)));
        out.push(("uint16", format!("{w} ({w:#x})")));
    }
    if bytes.len() >= 4 {
        let d = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
        out.push(("int32", format!("{}", d as i32)));
        out.push(("uint32", format!("{d} ({d:#x})")));
        out.push(("float", format!("{}", f32::from_bits(d))));
    }
    if bytes.len() >= 8 {
        let q = u64::from_le_bytes([
            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
        ]);
        out.push(("int64", format!("{}", q as i64)));
        out.push(("uint64", format!("{q} ({q:#x})")));
        out.push(("double", format!("{}", f64::from_bits(q))));
        out.push(("pointer64", format!("{q:#018x}")));
    }
    let ascii: String = bytes
        .iter()
        .take(16)
        .map(|b| {
            if (0x20..=0x7f).contains(b) {
                *b as char
            } else {
                '.'
            }
        })
        .collect();
    out.push(("ascii", ascii));
    out
}

impl GhidrustApp {

    pub(crate) fn ui_startup_picker(&mut self, ctx: &egui::Context) {
        let t = self.tokens();
        let d = self.theme_spec().density;
        let primary = Color32::from_rgb(t.primary[0], t.primary[1], t.primary[2]);
        let muted = Color32::from_rgb(
            t.on_surface_variant[0],
            t.on_surface_variant[1],
            t.on_surface_variant[2],
        );
        let surface = Color32::from_rgb(
            t.surface_container[0],
            t.surface_container[1],
            t.surface_container[2],
        );

        // Fib card width — clamp to viewport with Fib chrome insets.
        let card_w = d
            .field_wide
            .min(ctx.screen_rect().width() - d.console_handle_w)
            .max(d.scroll_sm);

        egui::CentralPanel::default().show(ctx, |ui| {
            ui.vertical_centered(|ui| {
                ui.add_space(FibScale::XL2);
                ui.heading(
                    egui::RichText::new("Ghidrust")
                        .size(d.control_min_height - FibScale::MD)
                        .color(primary),
                );
                if let Some(tex) = self.logo_texture.as_ref() {
                    ui.add_space(FibScale::LG);
                    let logo_h = d.field_narrow + FibScale::XL2; // 89+34 = 123 ≈ prior 112
                    let size = tex.size_vec2();
                    let logo_w = (logo_h * size.x / size.y).clamp(d.field_micro + FibScale::SM, d.field_compact);
                    ui.add(egui::Image::new(tex).fit_to_exact_size(egui::vec2(logo_w, logo_h)));
                    ui.add_space(FibScale::MD);
                } else {
                    ui.add_space(FibScale::MD);
                }
                ui.label(
                    egui::RichText::new("Open a project to reverse engineer")
                        .color(muted)
                        .size(FibScale::LG),
                );
                ui.add_space(FibScale::XL);

                card_frame(ui, &d)
                    .fill(surface)
                    .show(ui, |ui| {
                        ui.set_width(card_w);
                        ui.set_max_width(card_w);

                        // ── Recent projects (IDE-style list) ──
                        ui.label(
                            egui::RichText::new("Recent projects")
                                .strong()
                                .size(FibScale::LG),
                        );
                        ui.add_space(FibScale::SM);

                        let recents = self.recent_projects.clone();
                        let list_h = if recents.is_empty() {
                            d.console_handle_w
                        } else {
                            d.field_std
                        };

                        chip_frame(ui, &d)
                            .stroke(ui.visuals().widgets.noninteractive.bg_stroke)
                            .show(ui, |ui| {
                                ui.set_width(card_w - d.space_md);
                                egui::ScrollArea::vertical()
                                    .id_salt("startup_recent")
                                    .max_height(list_h)
                                    .auto_shrink([false, false])
                                    .show(ui, |ui| {
                                        ui.set_min_width(card_w - FibScale::XL);
                                        if recents.is_empty() {
                                            ui.add_space(FibScale::MD);
                                            ui.weak(
                                                "No recent projects — open or create one below.",
                                            );
                                            ui.add_space(FibScale::MD);
                                        } else {
                                            let mut open_path: Option<String> = None;
                                            for path in &recents {
                                                let name = Path::new(path)
                                                    .file_name()
                                                    .map(|s| s.to_string_lossy().into_owned())
                                                    .unwrap_or_else(|| path.clone());
                                                // IDE-style row: project name + path, full-width click
                                                let row_w = (card_w - FibScale::XL).max(d.field_std);
                                                let row_h = sized_button_height(&d) + FibScale::LG;
                                                let (rect, resp) = ui.allocate_exact_size(
                                                    egui::vec2(row_w, row_h),
                                                    egui::Sense::click(),
                                                );
                                                if resp.hovered() || resp.has_focus() {
                                                    ui.painter().rect_filled(
                                                        rect,
                                                        egui::CornerRadius::same(FibScale::SM as u8),
                                                        primary.gamma_multiply(0.15),
                                                    );
                                                }
                                                let mut child = ui.new_child(
                                                    egui::UiBuilder::new()
                                                        .max_rect(
                                                            rect.shrink2(egui::vec2(FibScale::LG, FibScale::SM)),
                                                        )
                                                        .layout(egui::Layout::top_down(
                                                            egui::Align::LEFT,
                                                        )),
                                                );
                                                child.label(
                                                    egui::RichText::new(&name)
                                                        .strong()
                                                        .color(primary)
                                                        .size(FibScale::LG),
                                                );
                                                child.label(
                                                    egui::RichText::new(path).small().color(muted),
                                                );
                                                if resp.clicked() {
                                                    open_path = Some(path.clone());
                                                }
                                                resp.on_hover_text(format!("Open project: {path}"));
                                            }
                                            if let Some(path) = open_path {
                                                self.project_dir_input = path;
                                                if let Err(e) = self.open_project() {
                                                    self.status = format!("error: {e}");
                                                    self.log(self.status.clone());
                                                    self.show_startup_picker = true;
                                                }
                                            }
                                        }
                                    });
                            });

                        ui.add_space(FibScale::LG);
                        ui.separator();
                        ui.add_space(FibScale::LG);

                        // Buttons fit card width only (no off-screen stretch)
                        let btn_w = card_w - d.space_md;
                        let btn_h = sized_button_height(&d);
                        if ui
                            .add_sized([btn_w, btn_h], egui::Button::new("Open existing project…"))
                            .clicked()
                        {
                            self.browse_and_open_project();
                            if self.project.is_none() {
                                self.show_startup_picker = true;
                            }
                        }
                        ui.add_space(FibScale::MD);
                        ui.horizontal(|ui| {
                            ui.label("Name:");
                            ui.add(
                                egui::TextEdit::singleline(&mut self.project_name_input)
                                    .desired_width(
                                        (btn_w - d.field_micro).max(FieldWidth::Compact.px(&d)),
                                    )
                                    .hint_text("MyProject"),
                            );
                        });
                        ui.add_space(FibScale::XS);
                        if ui
                            .add_sized([btn_w, btn_h], egui::Button::new("Create new project…"))
                            .clicked()
                        {
                            self.browse_and_create_project();
                            if self.project.is_none() {
                                self.show_startup_picker = true;
                            }
                        }
                        ui.add_space(FibScale::LG);
                        if ui.link("Continue without a project").clicked() {
                            self.show_startup_picker = false;
                            self.status =
                                "No project — File → Open / Load binary, or File → Open Project"
                                    .into();
                        }
                        ui.add_space(FibScale::XS);
                        ui.small(
                            egui::RichText::new(
 "Click a recent project name to open it. Analysis uses analysis.bin for fast load.",
                            )
                            .color(muted),
                        );
                    });
            });
        });
    }
    // draw_provider_panes + pane bodies → provider_panes.rs

    pub(crate) fn snapshot_current_layout(&self, name: impl Into<String>) -> crate::layouts::SavedLayout {
        let name = name.into();
        let mut open_panes = BTreeMap::new();
        for (k, v) in &self.pane_open {
            open_panes.insert(k.egui_id().to_string(), *v);
        }
        crate::debugger::snapshot_layout_flags(&self.debugger, &mut open_panes);
        crate::network::snapshot_layout_flags(&self.network, &mut open_panes);
        let mut docks = BTreeMap::new();
        docks.insert("project_tree".into(), self.show_project_tree);
        docks.insert("program_tree".into(), self.show_program_tree);
        docks.insert("symbol_tree".into(), self.show_symbol_tree);
        docks.insert("console".into(), self.show_console);
        let center = crate::dock_tabs::active_center_id(&self.center_dock).to_string();
        let dock_tree = serde_json::to_value(&self.center_dock).ok();
        let theme = match self.theme {
            ThemeMode::Dark => "dark",
            ThemeMode::Light => "light",
        }
        .to_string();
        crate::layouts::SavedLayout {
            name,
            open_panes,
            docks,
            center,
            dock_tree,
            theme,
            appearance: self.appearance.id().to_string(),
            comment: String::new(),
        }
    }

    pub(crate) fn apply_saved_layout(&mut self, layout: &crate::layouts::SavedLayout) {
        // Apply pane visibility.
        let ids: BTreeMap<&'static str, PaneKind> =
            PaneKind::ALL.iter().map(|k| (k.egui_id(), *k)).collect();
        for (id, open) in &layout.open_panes {
            if let Some(k) = ids.get(id.as_str()) {
                self.pane_open.insert(*k, *open);
            }
        }
        crate::debugger::apply_layout_flags(&mut self.debugger, &layout.open_panes);
        crate::network::apply_layout_flags(&mut self.network, &layout.open_panes);
        // Docks.
        if let Some(v) = layout.docks.get("project_tree") {
            self.show_project_tree = *v;
        }
        if let Some(v) = layout.docks.get("program_tree") {
            self.show_program_tree = *v;
        }
        if let Some(v) = layout.docks.get("symbol_tree") {
            self.show_symbol_tree = *v;
        }
        if let Some(v) = layout.docks.get("console") {
            self.show_console = *v;
        }
        if let Some(value) = &layout.dock_tree {
            match serde_json::from_value::<DockState<DockTab>>(value.clone()) {
                Ok(dock) => self.center_dock = dock,
                Err(_) => self.center_dock = crate::dock_tabs::from_legacy_center(&layout.center),
            }
        } else {
            self.center_dock = crate::dock_tabs::from_legacy_center(&layout.center);
        }
        self.sync_center_from_dock();
        self.theme = match layout.theme.as_str() {
            "light" => ThemeMode::Light,
            _ => ThemeMode::Dark,
        };
        self.appearance = AppearanceTheme::from_id(&layout.appearance);
        self.current_layout_name = layout.name.clone();
    }

    /// Save the current layout under `name`.
    pub fn save_layout_named(&mut self, name: impl Into<String>) -> std::io::Result<PathBuf> {
        let name = name.into();
        let l = self.snapshot_current_layout(name.clone());
        let p = crate::layouts::save_layout(&l)?;
        self.current_layout_name = name;
        self.layouts_cached = crate::layouts::list_layouts();
        Ok(p)
    }

    /// Restore a saved layout by name.
    pub fn restore_layout_named(&mut self, name: &str) -> std::io::Result<()> {
        let l = crate::layouts::load_layout(name)?;
        self.apply_saved_layout(&l);
        Ok(())
    }

    pub(crate) fn ui_bookmarks_pane(&mut self, ui: &mut egui::Ui, muted: Color32, primary: Color32) {
        ui.heading("Bookmarks");
        ui.small(egui::RichText::new("BookmarkPlugin analog · 5 standard kinds").color(muted));
        ui.separator();
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.bookmark_filter)
                    .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("category or description"),
            );
            if ui
                .button("Add at cursor…")
                .on_hover_text("Add a bookmark at the current Listing VA")
                .clicked()
            {
                if let Some(va) = self.listing_focus_va {
                    self.bookmark_dialog_kind = BookmarkKind::Note;
                    self.bookmark_dialog_category = String::new();
                    self.bookmark_dialog_description = format!("bookmark @ {va:#x}");
                    self.show_bookmark_dialog = true;
                } else {
                    self.status = "No cursor VA — click a Listing line first".into();
                    self.log(self.status.clone());
                }
            }
        });
        ui.separator();

        if self.bookmarks.is_empty() {
            ui.weak("No bookmarks yet — click Add at cursor to place one.");
            return;
        }

        let filt = self.bookmark_filter.to_ascii_lowercase();
        let rows: Vec<(usize, u64, BookmarkKind, String, String)> = self
            .bookmarks
            .iter()
            .enumerate()
            .filter(|(_, b)| {
                filt.is_empty()
                    || b.category.to_ascii_lowercase().contains(&filt)
                    || b.description.to_ascii_lowercase().contains(&filt)
                    || b.kind.label().to_ascii_lowercase().contains(&filt)
            })
            .map(|(i, b)| (i, b.va, b.kind, b.category.clone(), b.description.clone()))
            .collect();

        ui.small(format!(
            "{} / {} bookmarks",
            rows.len(),
            self.bookmarks.len()
        ));

        egui::ScrollArea::vertical()
            .id_salt("bookmarks_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("bookmarks_grid")
                    .num_columns(5)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Type");
                        ui.strong("Address");
                        ui.strong("Category");
                        ui.strong("Description");
                        ui.strong("");
                        ui.end_row();

                        let mut goto: Option<u64> = None;
                        let mut delete: Option<usize> = None;
                        for (idx, va, kind, cat, desc) in &rows {
                            ui.label(
                                egui::RichText::new(kind.label())
                                    .color(kind.color())
                                    .strong(),
                            );
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .on_hover_text("Go To this address")
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.label(cat);
                            ui.label(desc);
                            if ui.small_button("Delete").clicked() {
                                delete = Some(*idx);
                            }
                            ui.end_row();
                        }
                        let _ = primary; // reserved for future accent use
                        if let Some(va) = goto {
                            let _ = self.goto_address_str(&format!("{va:#x}"));
                        }
                        if let Some(i) = delete {
                            self.delete_bookmark(i);
                        }
                    });
            });
    }

    pub(crate) fn ui_memory_map_pane(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Memory Map");
        ui.small(
            egui::RichText::new(
                "MemoryMapPlugin · toggle RWX / add / delete session memory blocks",
            )
            .color(muted),
        );
        ui.separator();
        if self.program.is_none() {
            ui.weak("No program loaded.");
            return;
        }

        // Add-row form.
        ui.horizontal(|ui| {
            ui.label("Add block:");
            ui.add(
                egui::TextEdit::singleline(&mut self.memory_map_new_name)
                    .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("name"),
            );
            ui.add(
                egui::TextEdit::singleline(&mut self.memory_map_new_va)
                    .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("VA (0x…)"),
            );
            ui.add(
                egui::TextEdit::singleline(&mut self.memory_map_new_size)
                    .desired_width(FieldWidth::Narrow.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("size (0x…)"),
            );
            ui.checkbox(&mut self.memory_map_new_r, "R");
            ui.checkbox(&mut self.memory_map_new_w, "W");
            ui.checkbox(&mut self.memory_map_new_x, "X");
            let can_add = !self.memory_map_new_name.trim().is_empty()
                && !self.memory_map_new_va.trim().is_empty()
                && !self.memory_map_new_size.trim().is_empty();
            if ui.add_enabled(can_add, egui::Button::new("Add")).clicked() {
                let name = self.memory_map_new_name.clone();
                let va = parse_address(&self.memory_map_new_va).unwrap_or(0);
                let size = parse_address(&self.memory_map_new_size).unwrap_or(0);
                let r = self.memory_map_new_r;
                let w = self.memory_map_new_w;
                let x = self.memory_map_new_x;
                if size > 0 {
                    if let Some(prog) = self.program.as_mut() {
                        prog.blocks.push(ghidrust_core::MemoryBlock {
                            name,
                            va,
                            size,
                            bytes: vec![0u8; size.min(0x100_0000) as usize],
                            readable: r,
                            writable: w,
                            executable: x,
                        });
                    }
                    self.status = "Memory Map · added block".into();
                    self.log(self.status.clone());
                }
            }
        });
        ui.separator();

        let mut goto: Option<u64> = None;
        let mut delete: Option<usize> = None;
        let mut rename: Option<(usize, String)> = None;
        let mut toggle: Option<(usize, char)> = None;

        let notes_by_section: BTreeMap<String, Vec<String>> = self
            .program
            .as_ref()
            .map(|p| {
                let mut m: BTreeMap<String, Vec<String>> = BTreeMap::new();
                for n in ghidrust_core::section_notes_for(p) {
                    m.entry(n.section.clone()).or_default().push(n.message);
                }
                m
            })
            .unwrap_or_default();

        egui::ScrollArea::both()
            .id_salt("memmap_scroll")
            .show(ui, |ui| {
                egui::Grid::new("memory_map_grid")
                    .num_columns(9)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Name");
                        ui.strong("Start");
                        ui.strong("End");
                        ui.strong("Length");
                        ui.strong("R");
                        ui.strong("W");
                        ui.strong("X");
                        ui.strong("Notes");
                        ui.strong("");
                        ui.end_row();
                        let blocks: Vec<(String, u64, u64, bool, bool, bool)> = self
                            .program
                            .as_ref()
                            .map(|p| {
                                p.blocks
                                    .iter()
                                    .map(|b| {
                                        (
                                            b.name.clone(),
                                            b.va,
                                            b.size,
                                            b.readable,
                                            b.writable,
                                            b.executable,
                                        )
                                    })
                                    .collect()
                            })
                            .unwrap_or_default();
                        for (i, (name, va, size, r, w, x)) in blocks.iter().enumerate() {
                            let mut editable = name.clone();
                            if ui
                                .add(egui::TextEdit::singleline(&mut editable).desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP)))
                                .changed()
                            {
                                rename = Some((i, editable));
                            }
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.monospace(format!("{:#x}", va.saturating_add(*size)));
                            ui.monospace(format!("{size:#x}"));
                            let mut rb = *r;
                            let mut wb = *w;
                            let mut xb = *x;
                            if ui.checkbox(&mut rb, "").changed() {
                                toggle = Some((i, 'R'));
                            }
                            if ui.checkbox(&mut wb, "").changed() {
                                toggle = Some((i, 'W'));
                            }
                            if ui.checkbox(&mut xb, "").changed() {
                                toggle = Some((i, 'X'));
                            }
                            let notes = notes_by_section.get(name.trim_end_matches('\0'));
                            match notes {
                                Some(msgs) => {
                                    let joined = msgs.join(" · ");
                                    ui.small(egui::RichText::new("⚠ notes").color(muted))
                                        .on_hover_text(joined);
                                }
                                None => {
                                    ui.small(egui::RichText::new("—").color(muted));
                                }
                            }
                            if ui.small_button("Delete").clicked() {
                                delete = Some(i);
                            }
                            ui.end_row();
                        }
                    });
            });

        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some((i, newname)) = rename {
            if let Some(prog) = self.program.as_mut() {
                if let Some(b) = prog.blocks.get_mut(i) {
                    b.name = newname;
                }
            }
        }
        if let Some((i, ch)) = toggle {
            if let Some(prog) = self.program.as_mut() {
                if let Some(b) = prog.blocks.get_mut(i) {
                    match ch {
                        'R' => b.readable = !b.readable,
                        'W' => b.writable = !b.writable,
                        'X' => b.executable = !b.executable,
                        _ => {}
                    }
                }
            }
        }
        if let Some(i) = delete {
            if let Some(prog) = self.program.as_mut() {
                if i < prog.blocks.len() {
                    prog.blocks.remove(i);
                }
            }
        }
    }

    pub(crate) fn ui_functions_window(&mut self, ui: &mut egui::Ui, muted: Color32, primary: Color32) {
        ui.heading("Functions");
        ui.small(
            egui::RichText::new("FunctionWindowPlugin · flat table of Program::analysis.functions")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let n_total = prog.analysis.functions.len();
        if n_total == 0 {
            ui.weak("No functions — run Function Start Search.");
            return;
        }
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.functions_window_filter)
                    .desired_width(FieldWidth::Wide.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Function name…"),
            );
        });
        let q = self.functions_window_filter.to_ascii_lowercase();
        let rows: Vec<(u64, u64, String, usize)> = prog
            .analysis
            .functions
            .iter()
            .filter(|f| q.is_empty() || f.name.to_ascii_lowercase().contains(&q))
            .map(|f| (f.entry, f.end, f.name.clone(), f.parameters.len()))
            .collect();
        ui.small(format!("{} / {} functions", rows.len(), n_total));
        let focus = self.decomp_entry;
        egui::ScrollArea::vertical()
            .id_salt("fnwin_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("functions_window_grid")
                    .num_columns(4)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Entry");
                        ui.strong("Size");
                        ui.strong("Name");
                        ui.strong("Params");
                        ui.end_row();
                        let mut clicked: Option<u64> = None;
                        for (entry, end, name, params) in &rows {
                            let size = end.saturating_sub(*entry);
                            let addr_text = egui::RichText::new(format!("{entry:#x}"))
                                .monospace()
                                .color(if focus == Some(*entry) {
                                    primary
                                } else {
                                    ui.visuals().text_color()
                                });
                            if ui.link(addr_text).clicked() {
                                clicked = Some(*entry);
                            }
                            ui.monospace(format!("{size:#x}"));
                            ui.label(name);
                            ui.monospace(format!("{params}"));
                            ui.end_row();
                        }
                        if let Some(va) = clicked {
                            self.focus_function(va);
                        }
                    });
            });
    }

    pub(crate) fn ui_symbol_table(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Symbol Table");
        ui.small(
            egui::RichText::new(
                "SymbolTablePlugin · symbols + function entries · Refs → opens Symbol References",
            )
            .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.symbol_table_filter)
                    .desired_width(FieldWidth::Wide.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Symbol name…"),
            );
        });
        let q = self.symbol_table_filter.to_ascii_lowercase();
        // Merge analysis.symbols + function entries into one flat table.
        let mut rows: Vec<(u64, String, &'static str)> = Vec::new();
        for s in &prog.analysis.symbols {
            rows.push((s.va, s.name.clone(), "Symbol"));
        }
        for f in &prog.analysis.functions {
            rows.push((f.entry, f.name.clone(), "Function"));
        }
        rows.retain(|(_, name, _)| q.is_empty() || name.to_ascii_lowercase().contains(&q));
        rows.sort_by_key(|r| r.0);

        ui.small(format!("{} rows", rows.len()));
        let mut goto: Option<u64> = None;
        let mut show_refs: Option<u64> = None;
        egui::ScrollArea::vertical()
            .id_salt("symtable_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("symbol_table_grid")
                    .num_columns(4)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Address");
                        ui.strong("Name");
                        ui.strong("Type");
                        ui.strong("Refs");
                        ui.end_row();
                        for (va, name, ty) in &rows {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.label(name);
                            ui.monospace(*ty);
                            if ui
                                .small_button("Refs")
                                .on_hover_text("Open Symbol References for this VA")
                                .clicked()
                            {
                                show_refs = Some(*va);
                            }
                            ui.end_row();
                        }
                    });
            });
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some(va) = show_refs {
            self.symbol_refs_target = Some(va);
            self.pane_open.insert(PaneKind::SymbolReferences, true);
        }
    }

    pub(crate) fn open_decrypt_at(&mut self, va: u64, hint: Option<String>) {
        self.open_decrypt_at_len(va, 256, hint);
    }

    pub(crate) fn open_decrypt_at_len(&mut self, va: u64, len: usize, hint: Option<String>) {
        let bytes = self
            .program
            .as_ref()
            .and_then(|p| crate::decrypt_ui::bytes_at(p, va, len))
            .unwrap_or_default();
        self.decrypt_pane.load_bytes(Some(va), &bytes, hint);
        self.decrypt_pane.focus(DecryptTab::Bake);
        self.decrypt_pane.va_input = format!("{va:x}");
        self.decrypt_pane.va_len = len;
        self.pane_open.insert(PaneKind::Decrypt, true);
    }

    pub(crate) fn open_decrypt_nearby(&mut self, va: u64, hint: Option<String>) {
        let start = va.saturating_sub(32);
        let bytes = self
            .program
            .as_ref()
            .and_then(|p| crate::decrypt_ui::bytes_at(p, start, 256))
            .unwrap_or_default();
        self.decrypt_pane.load_bytes(Some(va), &bytes, hint);
        self.decrypt_pane.input_source = format!("Bytes near crypto result at {va:#x}");
        self.decrypt_pane.focus(DecryptTab::Bake);
        self.pane_open.insert(PaneKind::Decrypt, true);
    }

    pub(crate) fn recover_strings_at_function(&mut self, va: u64) {
        let Some(prog) = self.program.as_ref() else {
            self.status = "Recover strings requires a loaded program.".into();
            return;
        };
        let entry = prog
            .analysis
            .functions
            .iter()
            .find(|f| va >= f.entry && va < f.end)
            .map(|f| f.entry)
            .unwrap_or(va);
        let hits = recover_obfuscated_strings(
            prog,
            &RecoverStringsOpts {
                functions: Some(vec![entry]),
                ..Default::default()
            },
        );
        self.obfuscated_strings = hits;
        self.status = format!(
            "Recovered {} strings in containing function {entry:#x}",
            self.obfuscated_strings.len()
        );
    }

    pub(crate) fn ui_crypto_constants_pane(&mut self, ui: &mut egui::Ui, muted: Color32) {
        let hits: Vec<_> = if let Some(va) = self.crypto_constants_focus_va {
            let mut nearby: Vec<_> = self
                .crypt_constants
                .iter()
                .filter(|h| h.va.abs_diff(va) <= 0x1000)
                .cloned()
                .collect();
            nearby.sort_by_key(|h| h.va.abs_diff(va));
            nearby
        } else {
            self.crypt_constants.clone()
        };
        let mut goto = None;
        let mut decrypt = None;
        crate::decrypt_ui::ui_crypto_constants(
            ui,
            muted,
            &hits,
            |va| goto = Some(va),
            |va, algo| decrypt = Some((va, algo.to_string())),
        );
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some((va, algo)) = decrypt {
            self.open_decrypt_nearby(va, Some(algo));
        }
    }

    pub(crate) fn ui_recovered_strings_pane(&mut self, ui: &mut egui::Ui, muted: Color32) {
        let hits = self.obfuscated_strings.clone();
        let mut goto = None;
        let mut bake = None;
        let mut decoder = None;
        crate::decrypt_ui::ui_recovered_strings(
            ui,
            muted,
            &hits,
            |va| goto = Some(va),
            |va| bake = Some(va),
            |va| decoder = Some(va),
        );
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some(va) = bake {
            self.open_decrypt_at(va, None);
        }
        if let Some(va) = decoder {
            self.focus_function(va);
        }
    }

    pub(crate) fn ui_crypto_capabilities_pane(&mut self, ui: &mut egui::Ui, muted: Color32) {
        let hits = self.crypto_capabilities.clone();
        let mut goto = None;
        let mut decrypt = None;
        crate::decrypt_ui::ui_crypto_capabilities(
            ui,
            muted,
            &hits,
            |va| goto = Some(va),
            |va, hint| decrypt = Some((va, hint)),
        );
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some((va, hint)) = decrypt {
            self.open_decrypt_at(va, Some(hint));
        }
    }

    pub(crate) fn ui_defined_strings(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Defined Strings");
        ui.small(
            egui::RichText::new("ViewStringsPlugin · session strings from ASCII Strings analyzer")
                .color(muted),
        );
        ui.separator();
        if self.strings.is_empty() {
            ui.weak("No strings yet — run ASCII Strings analyzer.");
            return;
        }
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.defined_strings_filter)
                    .desired_width(FieldWidth::Wide.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Substring…"),
            );
            ui.label("Encoding:");
            egui::ComboBox::from_id_salt("defined_strings_encoding_combo")
                .selected_text(self.defined_strings_encoding.clone())
                .show_ui(ui, |ui| {
                    for enc in ["all", "ascii", "utf16le"] {
                        ui.selectable_value(&mut self.defined_strings_encoding, enc.into(), enc);
                    }
                });
        });
        let q = self.defined_strings_filter.to_ascii_lowercase();
        let enc_filter = self.defined_strings_encoding.clone();
        let rows: Vec<(u64, String, String)> = self
            .strings
            .iter()
            .filter(|s| q.is_empty() || s.value.to_ascii_lowercase().contains(&q))
            .filter(|s| enc_filter == "all" || s.encoding == enc_filter)
            .map(|s| (s.va, s.value.clone(), s.encoding.clone()))
            .collect();
        ui.small(format!("{} / {} strings", rows.len(), self.strings.len()));
        egui::ScrollArea::vertical()
            .id_salt("defstr_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("defined_strings_grid")
                    .num_columns(3)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Address");
                        ui.strong("Encoding");
                        ui.strong("String");
                        ui.end_row();
                        let mut goto: Option<u64> = None;
                        for (va, s, enc) in &rows {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.monospace(enc.clone());
                            let val: String = s.chars().take(80).collect();
                            ui.monospace(val);
                            ui.end_row();
                        }
                        if let Some(va) = goto {
                            let _ = self.goto_address_str(&format!("{va:#x}"));
                        }
                    });
            });
    }

    pub(crate) fn ui_relocation_table(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Relocation Table");
        ui.small(
            egui::RichText::new(
                "RelocationTablePlugin · PE base relocs / ELF RELA from Program::file_bytes",
            )
            .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let rows = crate::relocations::parse_relocations(prog);
        if rows.is_empty() {
            ui.small(
                egui::RichText::new(
                    "No PE base-reloc / ELF RELA entries parsed — showing section metadata.",
                )
                .color(muted)
                .italics(),
            );
            egui::Grid::new("relocs_sections_grid")
                .num_columns(3)
                .striped(true)
                .show(ui, |ui| {
                    ui.strong("Section");
                    ui.strong("VA");
                    ui.strong("Size");
                    ui.end_row();
                    for s in &prog.sections {
                        ui.label(&s.name);
                        ui.monospace(format!("{:#x}", s.va));
                        ui.monospace(format!("{:#x}", s.virtual_size));
                        ui.end_row();
                    }
                });
            return;
        }
        ui.small(format!("{} relocation(s)", rows.len()));
        let row_h = ui.text_style_height(&egui::TextStyle::Monospace) + 2.0;
        egui::ScrollArea::vertical()
            .id_salt("relocs_scroll")
            .auto_shrink([false, false])
            .show_rows(ui, row_h, rows.len(), |ui, range| {
                for i in range {
                    let r = &rows[i];
                    ui.monospace(format!("{:#x}  {}  {}", r.va, r.kind, r.detail));
                }
            });
    }

    pub(crate) fn ui_disassembled_view_pane(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Disassembled View");
        ui.small(egui::RichText::new("DisassembledViewPlugin · detail at cursor").color(muted));
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let va = match self.listing_focus_va.or(prog.entry) {
            Some(v) => v,
            None => {
                ui.weak("No cursor / entry.");
                return;
            }
        };
        let arch = self.listing_arch();
        match disassemble_at_opts(prog, va, Some(&self.decode_opts.to_engine_opts())) {
            Ok(insn) => {
                ui.monospace(insn.text());
                ui.separator();
                ui_detail_pane(ui, &insn, arch);
            }
            Err(e) => {
                ui.colored_label(Color32::from_rgb(0xE5, 0x39, 0x35), e.to_string());
            }
        }
    }

    pub(crate) fn ui_comment_window(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Comments");
        ui.small(
            egui::RichText::new(
                "CommentWindowPlugin · shows EOL/Pre/Post/Plate/Repeatable edits + bookmarks",
            )
            .color(muted),
        );
        ui.separator();
        // Filter row — CommentWindow provides both a text filter and
        // a per-kind toggle.
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.comment_window_filter)
                    .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Text / address / kind…"),
            );
            ui.label("Kind:");
            let cur = self
                .comment_window_kind_filter
                .map(|k| k.label())
                .unwrap_or("All");
            egui::ComboBox::from_id_salt("comment_window_kind_combo")
                .selected_text(cur)
                .show_ui(ui, |ui| {
                    ui.selectable_value(&mut self.comment_window_kind_filter, None, "All");
                    for k in CommentKind::ALL {
                        ui.selectable_value(
                            &mut self.comment_window_kind_filter,
                            Some(*k),
                            k.label(),
                        );
                    }
                });
        });
        ui.separator();
        // Real edited comments from ProgramEdits — one row per (va, kind).
        let mut rows: Vec<(&'static str, u64, String)> = Vec::new();
        if let Some(prog) = self.program.as_ref() {
            for ((va, kind), text) in &prog.edits.comments {
                rows.push((kind.label(), *va, text.clone()));
            }
        }
        // Also surface bookmarks as "Note-derived" comment rows.
        for b in &self.bookmarks {
            let text = if b.category.is_empty() {
                b.description.clone()
            } else {
                format!("[{}] {}", b.category, b.description)
            };
            rows.push(("Bookmark", b.va, text));
        }
        // Apply filters.
        let text_filter = self.comment_window_filter.to_ascii_lowercase();
        let kind_filter = self.comment_window_kind_filter;
        rows.retain(|(kind, va, text)| {
            if let Some(want) = kind_filter {
                if *kind != want.label() {
                    return false;
                }
            }
            if text_filter.is_empty() {
                return true;
            }
            let addr = format!("{va:#x}");
            text.to_ascii_lowercase().contains(&text_filter)
                || kind.to_ascii_lowercase().contains(&text_filter)
                || addr.contains(&text_filter)
        });
        if rows.is_empty() {
            ui.weak(
 "No comments/bookmarks match — set a comment with `;` on a Listing line, or add a Bookmark.",
            );
            return;
        }
        rows.sort_by_key(|(_, va, _)| *va);
        egui::ScrollArea::vertical()
            .id_salt("comment_window_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("comments_grid")
                    .num_columns(3)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Type");
                        ui.strong("Address");
                        ui.strong("Comment");
                        ui.end_row();
                        let mut goto: Option<u64> = None;
                        let mut delete: Option<(u64, CommentKind)> = None;
                        for (kind, va, text) in &rows {
                            let color = match *kind {
                                "EOL" => Color32::from_rgb(0x81, 0xC7, 0x84),
                                "Pre" => Color32::from_rgb(0x64, 0xB5, 0xF6),
                                "Post" => Color32::from_rgb(0xBA, 0x68, 0xC8),
                                "Plate" => Color32::from_rgb(0xFF, 0xB7, 0x4D),
                                "Repeatable" => Color32::from_rgb(0x4D, 0xD0, 0xE1),
                                _ => Color32::from_rgb(0x9C, 0x27, 0xB0),
                            };
                            ui.label(egui::RichText::new(*kind).color(color).strong());
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.horizontal(|ui| {
                                ui.label(text);
                                let matching_kind = match *kind {
                                    "EOL" => Some(CommentKind::Eol),
                                    "Pre" => Some(CommentKind::Pre),
                                    "Post" => Some(CommentKind::Post),
                                    "Plate" => Some(CommentKind::Plate),
                                    "Repeatable" => Some(CommentKind::Repeatable),
                                    _ => None,
                                };
                                if let Some(k) = matching_kind {
                                    if ui.small_button("Del").clicked() {
                                        delete = Some((*va, k));
                                    }
                                }
                            });
                            ui.end_row();
                        }
                        if let Some(va) = goto {
                            let _ = self.goto_address_str(&format!("{va:#x}"));
                        }
                        if let Some((va, k)) = delete {
                            let _ = self.set_comment_at(va, k, "");
                        }
                    });
            });
    }

    pub(crate) fn ui_defined_data(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Defined Data");
        ui.small(
            egui::RichText::new(
                "DataWindowPlugin · session data (Program::data_items when available)",
            )
            .color(muted),
        );
        ui.separator();
        let rtti_rows: Vec<(u64, String)> = match self.program.as_ref() {
            Some(prog) => prog
                .rtti
                .classes
                .iter()
                .take(2000)
                .filter_map(|c| c.type_info_va.map(|va| (va, c.name.clone())))
                .collect(),
            None => {
                ui.weak("No program loaded.");
                return;
            }
        };
        if self.strings.is_empty() && rtti_rows.is_empty() {
            ui.weak("No defined data (strings/RTTI) available yet — run ASCII Strings / RTTI analyzers.");
            return;
        }
        let str_rows: Vec<(u64, String)> = self
            .strings
            .iter()
            .take(2000)
            .map(|s| (s.va, s.value.chars().take(48).collect()))
            .collect();
        let mut goto: Option<u64> = None;
        egui::ScrollArea::vertical()
            .id_salt("defined_data_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("defined_data_grid")
                    .num_columns(3)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Address");
                        ui.strong("Type");
                        ui.strong("Preview");
                        ui.end_row();
                        for (va, val) in &str_rows {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.monospace("string");
                            ui.label(val);
                            ui.end_row();
                        }
                        for (va, name) in &rtti_rows {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.monospace("rtti");
                            ui.label(name);
                            ui.end_row();
                        }
                    });
            });
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
    }

    // ── Byte Viewer / Symbol References / Equates / Tags ─

    /// ByteViewerPluginue — split hex / ASCII view of the
    /// program's memory around the current cursor. Bytes-per-line combo,
    /// programmable offset override, and click-to-navigate address column.
    pub(crate) fn ui_bytes_pane(&mut self, ui: &mut egui::Ui, muted: Color32, primary: Color32) {
        ui.heading("Bytes");
        ui.small(
            egui::RichText::new("ByteViewerPlugin · split hex / ASCII, follows Listing cursor")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        // Cursor tracking — default to Listing focus, editable via combo.
        if self.bytes_pane_va.is_none() {
            self.bytes_pane_va = self
                .listing_focus_va
                .or(prog.entry)
                .or_else(|| prog.blocks.first().map(|b| b.va));
        }
        let base_va = self.bytes_pane_va.unwrap_or(prog.image_base);
        ui.horizontal(|ui| {
            ui.label("VA:");
            let mut input = format!("{base_va:#x}");
            let resp = ui.add(egui::TextEdit::singleline(&mut input).desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP)));
            if resp.lost_focus() {
                if let Ok(v) = parse_address(&input) {
                    self.bytes_pane_va = Some(v);
                }
            }
            ui.label("Bytes/line:");
            egui::ComboBox::from_id_salt("bytes_pane_bpr")
                .selected_text(format!("{}", self.bytes_pane_bpr))
                .show_ui(ui, |ui| {
                    for w in [8usize, 12, 16, 24, 32] {
                        ui.selectable_value(&mut self.bytes_pane_bpr, w, format!("{w}"));
                    }
                });
            ui.label("Rows:");
            egui::ComboBox::from_id_salt("bytes_pane_rows")
                .selected_text(format!("{}", self.bytes_pane_rows))
                .show_ui(ui, |ui| {
                    for r in [8usize, 16, 24, 32, 48, 64] {
                        ui.selectable_value(&mut self.bytes_pane_rows, r, format!("{r}"));
                    }
                });
            if ui
                .button("Follow cursor")
                .on_hover_text("Snap to Listing cursor")
                .clicked()
            {
                self.bytes_pane_va = self.listing_focus_va;
            }
        });
        ui.separator();
        let bpr = self.bytes_pane_bpr.max(1);
        let total = bpr.saturating_mul(self.bytes_pane_rows);
        let mut bytes: Vec<Option<u8>> = Vec::with_capacity(total);
        for i in 0..total {
            bytes.push(prog.byte_at(base_va.wrapping_add(i as u64)));
        }
        let focus_va = self.listing_focus_va;
        let mut nav: Option<u64> = None;
        egui::ScrollArea::vertical()
            .id_salt("bytes_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                for row in 0..self.bytes_pane_rows {
                    let row_va = base_va.wrapping_add((row * bpr) as u64);
                    ui.horizontal(|ui| {
                        let addr = egui::RichText::new(format!("{row_va:016x}"))
                            .monospace()
                            .color(if Some(row_va) == focus_va {
                                primary
                            } else {
                                ui.visuals().text_color()
                            });
                        if ui.link(addr).on_hover_text("Go To in Listing").clicked() {
                            nav = Some(row_va);
                        }
                        ui.label("│");
                        let mut hex_line = String::new();
                        let mut ascii_line = String::new();
                        for col in 0..bpr {
                            let idx = row * bpr + col;
                            match bytes.get(idx).and_then(|b| *b) {
                                Some(b) => {
                                    hex_line.push_str(&format!("{b:02x} "));
                                    let c = if (0x20..=0x7f).contains(&b) {
                                        b as char
                                    } else {
                                        '.'
                                    };
                                    ascii_line.push(c);
                                }
                                None => {
                                    hex_line.push_str("?? ");
                                    ascii_line.push(' ');
                                }
                            }
                        }
                        ui.monospace(hex_line.trim_end());
                        ui.label("│");
                        ui.monospace(ascii_line);
                    });
                }
            });
        if let Some(va) = nav {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
    }

    /// `Symbol References` provider — a table of every xref pointing
    /// at the currently selected symbol (or the cursor VA).
    pub(crate) fn ui_symbol_references(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Symbol References");
        ui.small(
            egui::RichText::new("SymbolTablePlugin · every reference TO the current symbol")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let target = self
            .symbol_refs_target
            .or(self.listing_focus_va)
            .or(prog.entry);
        ui.horizontal(|ui| {
            let mut input = target.map(|v| format!("{v:#x}")).unwrap_or_default();
            ui.label("Target:");
            let resp = ui.add(
                egui::TextEdit::singleline(&mut input)
                    .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("VA…"),
            );
            if resp.lost_focus() {
                self.symbol_refs_target = parse_address(&input).ok();
            }
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.symbol_refs_filter)
                    .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Substring…"),
            );
            if ui.button("Use cursor").clicked() {
                self.symbol_refs_target = self.listing_focus_va;
            }
            ui.checkbox(&mut self.symbol_refs_hide_stubs, "Hide resolve stubs")
                .on_hover_text(
                    "ghidrust_il2cpp::is_resolve_stub_va — hide IL2CPP lazy resolve thunks",
                );
        });
        ui.separator();
        let Some(target) = target else {
            ui.weak("No target — set cursor or type a VA above.");
            return;
        };
        let refs = self.xrefs_to_va(target);
        let q = self.symbol_refs_filter.to_ascii_lowercase();
        let hide_stubs = self.symbol_refs_hide_stubs;
        let classify = |prog: &Program, va: u64| -> Option<String> {
            ghidrust_il2cpp::classify_at(prog, va).map(|stub| {
                stub.icall_name
                    .clone()
                    .map(|n| format!("il2cpp_stub: {n}"))
                    .unwrap_or_else(|| "il2cpp_stub".into())
            })
        };
        let prog_ref = self.program.as_ref();
        let rows: Vec<(XRef, Option<String>)> = refs
            .into_iter()
            .filter(|r| {
                if q.is_empty() {
                    return true;
                }
                r.preview.to_ascii_lowercase().contains(&q)
                    || format!("{:#x}", r.from).contains(&q)
                    || r.kind.contains(&q)
            })
            .filter_map(|r| {
                let cls = prog_ref.and_then(|p| classify(p, r.from));
                let is_stub = cls.is_some()
                    || prog_ref
                        .map(|p| ghidrust_il2cpp::is_resolve_stub_va(p, r.from))
                        .unwrap_or(false);
                if hide_stubs && is_stub {
                    None
                } else {
                    Some((r, cls))
                }
            })
            .collect();
        let label_at = |va: u64| {
            self.program
                .as_ref()
                .and_then(|p| p.display_name_at(va))
                .map(|s| s.to_string())
                .unwrap_or_default()
        };
        ui.small(format!(
            "{} reference(s) to {target:#x} · {}",
            rows.len(),
            label_at(target)
        ));
        let mut goto: Option<u64> = None;
        egui::ScrollArea::vertical()
            .id_salt("symrefs_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                egui::Grid::new("symbol_refs_grid")
                    .num_columns(5)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("From");
                        ui.strong("Label");
                        ui.strong("Kind");
                        ui.strong("Classify");
                        ui.strong("Preview");
                        ui.end_row();
                        for (r, cls) in &rows {
                            if ui
                                .link(egui::RichText::new(format!("{:#x}", r.from)).monospace())
                                .clicked()
                            {
                                goto = Some(r.from);
                            }
                            ui.label(label_at(r.from));
                            ui.monospace(r.kind);
                            ui.small(cls.as_deref().unwrap_or("—"));
                            ui.label(&r.preview);
                            ui.end_row();
                        }
                    });
            });
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
    }

    /// `EquateTablePlugin` — two-pane: equate groups + per-equate refs.
    pub(crate) fn ui_equates_table(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Equates Table");
        ui.small(
            egui::RichText::new("EquateTablePlugin · symbolic names bound to scalar operands")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let groups = prog.edits.equate_groups();
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.equates_filter)
                    .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Name / value…"),
            );
            if ui.button("Add equate at cursor…").clicked() {
                self.equate_dialog_va = self.listing_focus_va;
                self.equate_dialog_op = 1;
                self.equate_dialog_name.clear();
                self.equate_dialog_value.clear();
                self.show_equate_dialog = true;
            }
        });
        ui.separator();
        let q = self.equates_filter.to_ascii_lowercase();
        let filtered: Vec<(String, i64, usize)> = groups
            .into_iter()
            .filter(|(name, val, _)| {
                if q.is_empty() {
                    return true;
                }
                name.to_ascii_lowercase().contains(&q) || format!("{val:#x}").contains(&q)
            })
            .collect();
        if filtered.is_empty() {
            ui.weak("No equates — use \"Add equate at cursor\" over a scalar operand.");
            return;
        }
        let mut clear: Option<(u64, u8)> = None;
        let mut goto: Option<u64> = None;
        ui.columns(2, |cols| {
            cols[0].strong("Equate");
            cols[0].separator();
            egui::ScrollArea::vertical()
                .id_salt("equates_left_scroll")
                .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
                .show(&mut cols[0], |ui| {
                    egui::Grid::new("equates_groups_grid")
                        .num_columns(3)
                        .striped(true)
                        .show(ui, |ui| {
                            ui.strong("Name");
                            ui.strong("Value");
                            ui.strong("# Refs");
                            ui.end_row();
                            for (name, value, n) in &filtered {
                                let is_sel = self
                                    .equates_selected
                                    .as_ref()
                                    .map(|(sn, sv)| sn == name && *sv == *value)
                                    .unwrap_or(false);
                                let text = if is_sel {
                                    egui::RichText::new(name).strong()
                                } else {
                                    egui::RichText::new(name)
                                };
                                if ui.selectable_label(is_sel, text).clicked() {
                                    self.equates_selected = Some((name.clone(), *value));
                                }
                                ui.monospace(format!("{value:#x}"));
                                ui.monospace(format!("{n}"));
                                ui.end_row();
                            }
                        });
                });
            cols[1].strong("References");
            cols[1].separator();
            let sel = self.equates_selected.clone();
            let refs: Vec<(u64, u8, i64)> = match sel {
                Some((name, _)) => prog.edits.equate_references(&name),
                None => Vec::new(),
            };
            egui::ScrollArea::vertical()
                .id_salt("equates_right_scroll")
                .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
                .show(&mut cols[1], |ui| {
                    if refs.is_empty() {
                        ui.weak("Select an equate on the left to see its references.");
                    } else {
                        egui::Grid::new("equate_refs_grid")
                            .num_columns(4)
                            .striped(true)
                            .show(ui, |ui| {
                                ui.strong("Ref Addr");
                                ui.strong("Op");
                                ui.strong("Value");
                                ui.strong("Del");
                                ui.end_row();
                                for (va, op, value) in refs {
                                    if ui
                                        .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                        .clicked()
                                    {
                                        goto = Some(va);
                                    }
                                    ui.monospace(format!("{op}"));
                                    ui.monospace(format!("{value:#x}"));
                                    if ui.small_button("Del").clicked() {
                                        clear = Some((va, op));
                                    }
                                    ui.end_row();
                                }
                            });
                    }
                });
        });
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
        if let Some((va, op)) = clear {
            let _ = self.set_equate(va, op, "", 0);
        }
    }

    /// `FunctionTagPlugin` — two-pane: assigned tags for current fn,
    /// All Tags with counts.
    pub(crate) fn ui_function_tags(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Function Tags");
        ui.small(
            egui::RichText::new("FunctionTagPlugin · per-function labels + universe of tags")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let entry = self.focused_function_entry.or_else(|| {
            self.listing_focus_va
                .and_then(|va| Some(decompile_entry_for_va(prog, va)))
        });
        let entry_label = entry
            .and_then(|va| self.program.as_ref()?.display_function_name_at(va))
            .unwrap_or_else(|| "<no function>".into());
        ui.horizontal(|ui| {
            ui.label("Function:");
            ui.monospace(&entry_label);
            if let Some(e) = entry {
                ui.monospace(format!("@ {e:#x}"));
            }
        });
        ui.separator();
        // Left = assigned tags (with remove); right = all tags (add / delete).
        let assigned: Vec<String> = entry
            .map(|e| prog.edits.function_tags_for(e))
            .unwrap_or_default();
        let all_tags: Vec<(String, usize)> = prog.edits.all_tag_counts();
        let mut remove_from_entry: Option<String> = None;
        let mut add_to_entry: Option<String> = None;
        let mut delete_globally: Option<String> = None;
        ui.columns(2, |cols| {
            cols[0].strong("Assigned to this function");
            cols[0].separator();
            if assigned.is_empty() {
                cols[0].weak("No tags — add one from the right pane, or type a new tag.");
            } else {
                for t in &assigned {
                    cols[0].horizontal(|ui| {
                        ui.monospace(t);
                        if ui.small_button("Remove").clicked() {
                            remove_from_entry = Some(t.clone());
                        }
                    });
                }
            }

            cols[1].strong("All Tags");
            cols[1].separator();
            cols[1].horizontal(|ui| {
                ui.label("New:");
                ui.add(
                    egui::TextEdit::singleline(&mut self.function_tags_new_input)
                        .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                        .hint_text("Tag name…"),
                );
                if ui.button("Add").clicked() {
                    let name = self.function_tags_new_input.trim().to_string();
                    if !name.is_empty() {
                        if entry.is_some() {
                            add_to_entry = Some(name);
                        } else {
                            let _ = self.create_tag(name);
                        }
                        self.function_tags_new_input.clear();
                    }
                }
            });
            cols[1].horizontal(|ui| {
                ui.label("Filter:");
                ui.add(
                    egui::TextEdit::singleline(&mut self.function_tags_filter)
                        .desired_width(FieldWidth::Compact.px(&ThemeDensity::FIB_DESKTOP))
                        .hint_text("Substring…"),
                );
            });
            cols[1].separator();
            let q = self.function_tags_filter.to_ascii_lowercase();
            egui::ScrollArea::vertical()
                .id_salt("all_tags_scroll")
                .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
                .show(&mut cols[1], |ui| {
                    egui::Grid::new("all_tags_grid")
                        .num_columns(3)
                        .striped(true)
                        .show(ui, |ui| {
                            ui.strong("Tag");
                            ui.strong("Uses");
                            ui.strong("Actions");
                            ui.end_row();
                            for (tag, n) in &all_tags {
                                if !q.is_empty() && !tag.to_ascii_lowercase().contains(&q) {
                                    continue;
                                }
                                ui.monospace(tag);
                                ui.monospace(format!("{n}"));
                                ui.horizontal(|ui| {
                                    if entry.is_some() && ui.small_button("Add").clicked() {
                                        add_to_entry = Some(tag.clone());
                                    }
                                    if ui.small_button("Delete").clicked() {
                                        delete_globally = Some(tag.clone());
                                    }
                                });
                                ui.end_row();
                            }
                        });
                });
        });
        if let (Some(tag), Some(e)) = (remove_from_entry, entry) {
            let _ = self.remove_function_tag(e, &tag);
        }
        if let (Some(tag), Some(e)) = (add_to_entry, entry) {
            let _ = self.add_function_tag(e, tag);
        }
        if let Some(tag) = delete_globally {
            let _ = self.delete_tag_everywhere(&tag);
        }
    }

    /// `ReferencesPlugin` — External Programs table. Rendered from
    /// analyzer-driven `imports_exports` output (PDB symbols, `idata`
    /// sections, demangled `dllexport` symbols) — never fabricated.
    pub(crate) fn ui_external_programs(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("External Programs");
        ui.small(
            egui::RichText::new("ReferencesPlugin · analyzer-derived imports + exports")
                .color(muted),
        );
        ui.separator();
        if self.program.is_none() {
            ui.weak("No program loaded.");
            return;
        }
        let (imports, exports) = self.imports_exports();
        ui.horizontal(|ui| {
            ui.label("Filter:");
            ui.add(
                egui::TextEdit::singleline(&mut self.external_programs_filter)
                    .desired_width(FieldWidth::Std.px(&ThemeDensity::FIB_DESKTOP))
                    .hint_text("Name / VA…"),
            );
        });
        ui.separator();
        let q = self.external_programs_filter.to_ascii_lowercase();
        let matches = |name: &str, va: u64| {
            if q.is_empty() {
                return true;
            }
            name.to_ascii_lowercase().contains(&q) || format!("{va:#x}").contains(&q)
        };
        let mut goto: Option<u64> = None;
        egui::ScrollArea::vertical()
            .id_salt("ext_progs_scroll")
            .max_height(ThemeDensity::FIB_DESKTOP.scroll_md)
            .show(ui, |ui| {
                ui.strong("Imports");
                egui::Grid::new("ext_imports_grid")
                    .num_columns(3)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Address");
                        ui.strong("Name");
                        ui.strong("Source");
                        ui.end_row();
                        for (va, name) in imports.iter().filter(|(va, n)| matches(n, *va)) {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.label(name);
                            ui.monospace(if name.starts_with('.') {
                                "section"
                            } else {
                                "pdb"
                            });
                            ui.end_row();
                        }
                    });
                ui.add_space(FibScale::MD);
                ui.strong("Exports");
                egui::Grid::new("ext_exports_grid")
                    .num_columns(3)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Address");
                        ui.strong("Name");
                        ui.strong("Source");
                        ui.end_row();
                        for (va, name) in exports.iter().filter(|(va, n)| matches(n, *va)) {
                            if ui
                                .link(egui::RichText::new(format!("{va:#x}")).monospace())
                                .clicked()
                            {
                                goto = Some(*va);
                            }
                            ui.label(name);
                            ui.monospace(if name.starts_with('.') {
                                "section"
                            } else {
                                "demangle"
                            });
                            ui.end_row();
                        }
                        if imports.is_empty() && exports.is_empty() {
                            ui.weak("No imports/exports — analyzer did not populate any.");
                            ui.end_row();
                        }
                    });
            });
        if let Some(va) = goto {
            let _ = self.goto_address_str(&format!("{va:#x}"));
        }
    }

    /// `DataTypePreviewPlugin` — preview interpretation of bytes at
    /// the current cursor under the chosen built-in type.
    pub(crate) fn ui_data_type_preview(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Data Type Preview");
        ui.small(
            egui::RichText::new("DataTypePreviewPlugin · byte interpretation @ cursor")
                .color(muted),
        );
        ui.separator();
        let Some(prog) = self.program.as_ref() else {
            ui.weak("No program loaded.");
            return;
        };
        let va = match self.listing_focus_va.or(prog.entry) {
            Some(v) => v,
            None => {
                ui.weak("No cursor / entry.");
                return;
            }
        };
        ui.horizontal(|ui| {
            ui.label("Cursor VA:");
            ui.monospace(format!("{va:#x}"));
            ui.label("Type:");
            let sel = self.data_type_preview_selected.clone();
            egui::ComboBox::from_id_salt("dtp_type_combo")
                .selected_text(&sel)
                .show_ui(ui, |ui| {
                    for name in BUILTIN_TYPES {
                        if ui.selectable_label(sel.as_str() == *name, *name).clicked() {
                            self.data_type_preview_selected = (*name).into();
                        }
                    }
                });
        });
        ui.separator();
        let bytes = prog.read_va(va, 16).unwrap_or_default();
        let hex: String = bytes.iter().map(|b| format!("{b:02x} ")).collect();
        ui.monospace(format!("bytes: {}", hex.trim_end()));
        ui.separator();
        egui::Grid::new("dtp_grid")
            .num_columns(2)
            .striped(true)
            .show(ui, |ui| {
                ui.strong("Interpretation");
                ui.strong("Preview");
                ui.end_row();
                for (name, preview) in preview_all(&bytes) {
                    ui.monospace(name);
                    ui.monospace(preview);
                    ui.end_row();
                }
            });
    }

    /// `ComputeChecksumsPlugin` — CRC-32 / Adler-32 / Fletcher / raw
    /// sum panels over the loaded image or a chosen block.
    pub(crate) fn ui_checksum_generator(&mut self, ui: &mut egui::Ui, muted: Color32) {
        ui.heading("Checksum Generator");
        ui.small(
            egui::RichText::new("ComputeChecksumsPlugin · CRC-32 / Adler-32 / Fletcher / sums")
                .color(muted),
        );
        ui.separator();
        let block_names: Vec<String> = self
            .program
            .as_ref()
            .map(|p| p.blocks.iter().map(|b| b.name.clone()).collect())
            .unwrap_or_default();
        let mut run: Option<ChecksumMode> = None;
        ui.horizontal(|ui| {
            if ui.button("Whole image").clicked() {
                run = Some(ChecksumMode::WholeImage);
            }
            ui.label(egui::RichText::new("or block:").color(muted));
            for name in &block_names {
                if ui.small_button(name).clicked() {
                    run = Some(ChecksumMode::Section(name.clone()));
                }
            }
        });
        if let Some(mode) = run {
            let _ = self.compute_checksums(mode);
        }
        ui.separator();
        match &self.checksum_last {
            None => {
                ui.weak("No checksum computed yet — click Whole image or a block above.");
            }
            Some(r) => {
                egui::Grid::new("checksum_grid")
                    .num_columns(2)
                    .striped(true)
                    .show(ui, |ui| {
                        ui.strong("Target");
                        ui.label(&r.target);
                        ui.end_row();
                        ui.strong("Length");
                        ui.monospace(format!("{}", r.len));
                        ui.end_row();
                        ui.strong("CRC-32 (IEEE)");
                        ui.monospace(format!("{:#010x}", r.crc32));
                        ui.end_row();
                        ui.strong("Adler-32");
                        ui.monospace(format!("{:#010x}", r.adler32));
                        ui.end_row();
                        ui.strong("Sum-8");
                        ui.monospace(format!("{:#x}", r.sum8));
                        ui.end_row();
                        ui.strong("Sum-16");
                        ui.monospace(format!("{:#x}", r.sum16));
                        ui.end_row();
                        ui.strong("Sum-32");
                        ui.monospace(format!("{:#x}", r.sum32));
                        ui.end_row();
                        ui.strong("Fletcher-16");
                        ui.monospace(format!("{:#010x}", r.fletcher16));
                        ui.end_row();
                        ui.strong("Fletcher-32");
                        ui.monospace(format!("{:#018x}", r.fletcher32));
                        ui.end_row();
                    });
            }
        }
    }
}