Add xenia-ui crate; switch analysis store to DuckDB

Workspace gains a new xenia-ui member that owns the winit/wgpu
window, the Xenos display pipeline (xenos_pipeline + render +
texture_cache_host), HUD font/blit shaders, and the input-bridge
plumbing the app uses to surface guest framebuffers and overlays.

Workspace dependencies grow accordingly: rusqlite is replaced with
duckdb (analysis pipeline now writes DuckDB stores), and tracing /
metrics / pprof / winit / wgpu / gilrs / pollster / crossbeam /
bytemuck are added at workspace level so xenia-ui and xenia-app
share versions. Cargo.lock regenerated.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/xenia-ui/src/bridge.rs

@@ -0,0 +1,167 @@
+//! UI/kernel bridge construction.
+//!
+//! The UI side owns:
+//!   - a gamepad snapshot cell (writer) + connected flag (writer),
+//!   - a shared staging buffer that the CPU thread fills with the guest's
+//!     frontbuffer bytes on each `VdSwap`,
+//!   - an `EventLoopProxy<SwapEvent>` to wake winit with a redraw request,
+//!   - a shutdown atomic the UI flips on window close.
+//!
+//! The kernel side gets a [`xenia_kernel::UiBridge`] made from closures over
+//! the same shared state, so it can read gamepad + post swaps from the CPU
+//! thread without knowing about winit.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::Mutex;
+
+use crossbeam_utils::atomic::AtomicCell;
+use winit::event_loop::EventLoopProxy;
+use xenia_gpu::texture_cache::TextureKey;
+use xenia_gpu::xenos_constants::XenosConstantsBlock;
+use xenia_hid::GamepadState;
+use xenia_kernel::{SwapInfo, UiBridge};
+use xenia_memory::MemoryAccess;
+
+/// Snapshot of the guest frontbuffer, copied out of guest memory on each
+/// `VdSwap` so the UI thread can upload it without touching the CPU thread's
+/// [`xenia_memory::GuestMemory`].
+#[derive(Default)]
+pub struct FrontbufferSnapshot {
+    /// Width of the most-recently-swapped frontbuffer, in pixels.
+    pub width: u32,
+    /// Height in pixels.
+    pub height: u32,
+    /// Tightly-packed RGBA8 bytes (`width * height * 4`). Decoded from the
+    /// raw guest bytes by the kernel-side closure (see [`build`]).
+    pub rgba: Vec<u8>,
+    /// Monotonic counter so the UI can tell new frames apart from stale
+    /// re-reads.
+    pub revision: u64,
+    /// The most recent swap metadata. Kept alongside the bytes for HUD use.
+    pub info: Option<SwapInfo>,
+}
+
+/// The UI-side half of the bridge. Installed into the [`App`](crate::app)
+/// that runs on the main thread.
+pub struct UiHandles {
+    pub gamepad: Arc<AtomicCell<GamepadState>>,
+    pub gamepad_connected: Arc<AtomicBool>,
+    pub shutdown: Arc<AtomicBool>,
+    pub frontbuffer: Arc<Mutex<FrontbufferSnapshot>>,
+    /// Live-updated summed CPU instruction counter. The `xenia-app` run
+    /// loop stores `cycle_count` into this every ~10k instructions so the
+    /// HUD keeps animating even before the first `VdSwap` fires. Authoritative
+    /// counter comes from scheduler HW-thread contexts; this atomic is just
+    /// a cross-thread cache.
+    pub instructions_counter: Arc<AtomicU64>,
+    /// P3b assets: cloned by `vd_swap` via `UiBridge::publish_assets`.
+    /// The UI redraw path reads them (mutex-guarded) alongside the
+    /// corresponding `SwapInfo` and passes them to the Xenos pipeline.
+    pub shader_blobs: Arc<Mutex<HashMap<u32, Vec<u32>>>>,
+    pub xenos_constants: Arc<Mutex<XenosConstantsBlock>>,
+    /// P5 primary texture — `None` means "no texture this frame, use
+    /// the magenta stub"; `Some((key, bytes))` means the kernel decoded
+    /// fetch-constant slot 0 into linear bytes that the UI should
+    /// upload into the host cache and bind at `@group(1) @binding(0)`.
+    pub primary_texture: Arc<Mutex<Option<(TextureKey, Vec<u8>)>>>,
+}
+
+/// Swap event posted by the CPU-side `VdSwap` handler via
+/// [`EventLoopProxy::send_event`] after the frontbuffer bytes have been
+/// copied into [`UiHandles::frontbuffer`].
+#[derive(Clone, Copy, Debug)]
+pub struct SwapEvent(pub SwapInfo);
+
+/// Build a paired ([`UiHandles`], [`UiBridge`]).
+///
+/// The proxy is the winit user-event injector for a freshly-constructed
+/// `EventLoop<SwapEvent>`; `xenia-app` owns the event loop and keeps the
+/// `UiHandles` alongside it.
+pub fn build(proxy: EventLoopProxy<SwapEvent>) -> (UiHandles, UiBridge) {
+    let gamepad = Arc::new(AtomicCell::new(GamepadState::default()));
+    let gamepad_connected = Arc::new(AtomicBool::new(false));
+    let shutdown = Arc::new(AtomicBool::new(false));
+    let frontbuffer = Arc::new(Mutex::new(FrontbufferSnapshot::default()));
+    let instructions_counter = Arc::new(AtomicU64::new(0));
+    let shader_blobs = Arc::new(Mutex::new(HashMap::<u32, Vec<u32>>::new()));
+    let xenos_constants = Arc::new(Mutex::new(XenosConstantsBlock::default()));
+    let primary_texture: Arc<Mutex<Option<(TextureKey, Vec<u8>)>>> =
+        Arc::new(Mutex::new(None));
+
+    let kernel_bridge = UiBridge {
+        gamepad: {
+            let gp = Arc::clone(&gamepad);
+            Arc::new(move || gp.load())
+        },
+        // `post_swap` now only bumps the SwapInfo + revision; the RGBA
+        // bytes arrive via `publish_frontbuffer` earlier in the same
+        // `VdSwap` (P4 replaced the raw-scrape path with a CPU-side
+        // detile). Posting the swap event after the bytes land guarantees
+        // the UI's redraw path sees the latest pixels.
+        post_swap: {
+            let proxy = proxy.clone();
+            let fb = Arc::clone(&frontbuffer);
+            Arc::new(move |info: SwapInfo, _mem: &dyn MemoryAccess| {
+                if let Ok(mut lock) = fb.lock() {
+                    lock.info = Some(info);
+                    lock.revision = lock.revision.wrapping_add(1);
+                }
+                let _ = proxy.send_event(SwapEvent(info));
+            })
+        },
+        shutdown: Arc::clone(&shutdown),
+        gamepad_connected: Arc::clone(&gamepad_connected),
+        instructions_counter: Arc::clone(&instructions_counter),
+        publish_xenos_assets: {
+            let blobs = Arc::clone(&shader_blobs);
+            let consts = Arc::clone(&xenos_constants);
+            Arc::new(move |new_blobs, new_consts| {
+                if let Ok(mut g) = blobs.lock() {
+                    *g = new_blobs;
+                }
+                if let Ok(mut g) = consts.lock() {
+                    *g = new_consts;
+                }
+            })
+        },
+        publish_frontbuffer: {
+            let fb = Arc::clone(&frontbuffer);
+            Arc::new(move |w, h, bytes| {
+                if let Ok(mut lock) = fb.lock() {
+                    lock.width = w;
+                    lock.height = h;
+                    lock.rgba = bytes;
+                }
+            })
+        },
+        publish_texture: {
+            let tex = Arc::clone(&primary_texture);
+            Arc::new(move |payload| {
+                if let Ok(mut lock) = tex.lock() {
+                    *lock = payload;
+                }
+            })
+        },
+    };
+
+    let handles = UiHandles {
+        gamepad,
+        gamepad_connected,
+        shutdown,
+        frontbuffer,
+        instructions_counter,
+        shader_blobs,
+        xenos_constants,
+        primary_texture,
+    };
+    (handles, kernel_bridge)
+}
+
+
+impl UiHandles {
+    pub fn request_shutdown(&self) {
+        self.shutdown.store(true, Ordering::Relaxed);
+    }
+}