log: Add tracing events through core for future debugability.

crates/pikl-core/src/runtime/menu.rs

@@ -6,6 +6,7 @@
 use std::sync::Arc;
 
 use tokio::sync::{broadcast, mpsc};
+use tracing::{debug, info, trace};
 
 use crate::debounce::{hook_response_to_action, DebouncedDispatcher};
 use crate::error::PiklError;
@@ -101,8 +102,19 @@ impl<M: MutableMenu> MenuRunner<M> {
     /// Re-run the filter against all items with the current
     /// filter text. Updates the viewport with the new count.
     fn run_filter(&mut self) {
+        let start = std::time::Instant::now();
         self.menu.apply_filter(&self.filter_text);
-        self.viewport.set_filtered_count(self.menu.filtered_count());
+        let matched = self.menu.filtered_count();
+        let total = self.menu.total();
+        let duration_us = start.elapsed().as_micros() as u64;
+        debug!(
+            filter = %self.filter_text,
+            matched,
+            total,
+            duration_us,
+            "filter applied"
+        );
+        self.viewport.set_filtered_count(matched);
     }
 
     /// Build a [`ViewState`] snapshot from the current filter
@@ -144,12 +156,18 @@ impl<M: MutableMenu> MenuRunner<M> {
     /// Send the current view state to all subscribers.
     fn broadcast_state(&mut self) {
         let vs = self.build_view_state();
+        trace!(
+            generation = vs.generation,
+            filtered = vs.total_filtered,
+            "state broadcast"
+        );
         let _ = self.event_tx.send(MenuEvent::StateChanged(vs));
     }
 
     /// Emit a hook event through the dispatcher, if one is set.
     fn emit_hook(&mut self, event: HookEvent) {
         if let Some(dispatcher) = &mut self.dispatcher {
+            debug!(hook_event = ?event.kind(), "hook dispatched");
             dispatcher.dispatch(event);
         }
     }
@@ -168,6 +186,7 @@ impl<M: MutableMenu> MenuRunner<M> {
             if let Some(value) = self.menu.serialize_filtered(current).cloned()
                 && let Some(orig_idx) = current_orig
             {
+                trace!(cursor = current, original_index = orig_idx, "hover changed");
                 self.emit_hook(HookEvent::Hover {
                     item: value,
                     index: orig_idx,
@@ -181,6 +200,7 @@ impl<M: MutableMenu> MenuRunner<M> {
     pub fn apply_action(&mut self, action: Action) -> ActionOutcome {
         match action {
             Action::UpdateFilter(text) => {
+                debug!(filter = %text, "filter updated");
                 self.filter_text = Arc::from(text);
                 self.run_filter();
                 ActionOutcome::Broadcast
@@ -237,6 +257,7 @@ impl<M: MutableMenu> MenuRunner<M> {
             }
             Action::Cancel => ActionOutcome::Cancelled,
             Action::Resize { height } => {
+                trace!(height, "viewport resized");
                 self.viewport.set_height(height as usize);
                 ActionOutcome::Broadcast
             }
@@ -249,15 +270,18 @@ impl<M: MutableMenu> MenuRunner<M> {
                 ActionOutcome::Broadcast
             }
             Action::SetMode(m) => {
+                debug!(mode = ?m, "mode changed");
                 self.mode = m;
                 ActionOutcome::Broadcast
             }
             Action::AddItems(values) => {
+                debug!(count = values.len(), "items added");
                 self.menu.add_raw(values);
                 self.run_filter();
                 ActionOutcome::Broadcast
             }
             Action::ReplaceItems(values) => {
+                debug!(count = values.len(), "items replaced");
                 // Smart cursor: try to keep selection on the same original item.
                 let cursor = self.viewport.cursor();
                 let old_value = self.menu.serialize_filtered(cursor).cloned();
@@ -282,6 +306,7 @@ impl<M: MutableMenu> MenuRunner<M> {
                 ActionOutcome::Broadcast
             }
             Action::RemoveItems(indices) => {
+                debug!(count = indices.len(), "items removed");
                 self.menu.remove_by_indices(indices);
                 self.run_filter();
                 self.viewport.clamp();
@@ -319,6 +344,10 @@ impl<M: MutableMenu> MenuRunner<M> {
         self.run_filter();
         self.broadcast_state();
 
+        let total_items = self.menu.total();
+        let filtered = self.menu.filtered_count();
+        info!(total_items, filtered, "menu opened");
+
         // Emit Open event
         self.emit_hook(HookEvent::Open);
 
@@ -339,6 +368,7 @@ impl<M: MutableMenu> MenuRunner<M> {
                     self.check_cursor_hover();
                 }
                 ActionOutcome::Selected { value, index } => {
+                    info!(index, "item selected");
                     // Emit Select event
                     self.emit_hook(HookEvent::Select {
                         item: value.clone(),
@@ -354,6 +384,7 @@ impl<M: MutableMenu> MenuRunner<M> {
                     let values: Vec<Value> =
                         items.iter().map(|(v, _)| v.clone()).collect();
                     let count = values.len();
+                    info!(count, "quicklist returned");
                     self.emit_hook(HookEvent::Quicklist {
                         items: values.clone(),
                         count,
@@ -366,6 +397,7 @@ impl<M: MutableMenu> MenuRunner<M> {
                     return Ok(MenuResult::Quicklist { items });
                 }
                 ActionOutcome::Cancelled => {
+                    info!("menu cancelled");
                     self.emit_hook(HookEvent::Cancel);
                     self.emit_hook(HookEvent::Close);
 
@@ -373,6 +405,7 @@ impl<M: MutableMenu> MenuRunner<M> {
                     return Ok(MenuResult::Cancelled);
                 }
                 ActionOutcome::Closed => {
+                    info!("menu closed by hook");
                     self.emit_hook(HookEvent::Close);
 
                     let _ = self.event_tx.send(MenuEvent::Cancelled);