Skip to main content

ftui_widgets/command_palette/
mod.rs

1#![forbid(unsafe_code)]
2
3//! Command Palette widget for instant action search.
4//!
5//! This module provides a fuzzy-search command palette with:
6//! - Bayesian match scoring with evidence ledger
7//! - Incremental scoring with query-prefix pruning
8//! - Word-start, prefix, substring, and fuzzy matching
9//! - Conformal rank confidence for tie-break stability
10//! - Match position tracking for highlighting
11//!
12//! # Usage
13//!
14//! ```ignore
15//! let mut palette = CommandPalette::new();
16//! palette.register("Open File", Some("Open a file from disk"), &["file", "open"]);
17//! palette.register("Save File", Some("Save current file"), &["file", "save"]);
18//! palette.open(); // Show the palette
19//!
20//! // In your update loop, handle events:
21//! if let Some(action) = palette.handle_event(event) {
22//!     match action {
23//!         PaletteAction::Execute(id) => { /* run the action */ }
24//!         PaletteAction::Dismiss => { /* palette was closed */ }
25//!     }
26//! }
27//!
28//! // Render as a Widget
29//! palette.render(area, &mut frame);
30//! ```
31//!
32//! # Submodules
33//!
34//! - [`scorer`]: Bayesian fuzzy matcher with explainable scoring
35
36pub mod scorer;
37
38#[cfg(feature = "experimental")]
39pub use scorer::ConformalRanker;
40pub use scorer::{
41    BayesianScorer, EvidenceKind, EvidenceLedger, IncrementalScorer, IncrementalStats, MatchResult,
42    MatchType, RankConfidence, RankStability, RankedItem, RankedResults, RankingSummary,
43};
44
45use ftui_core::event::{Event, KeyCode, KeyEvent, KeyEventKind, Modifiers};
46use ftui_core::geometry::Rect;
47use ftui_render::cell::{Cell, CellAttrs, CellContent, PackedRgba, StyleFlags as CellStyleFlags};
48use ftui_render::frame::Frame;
49use ftui_style::Style;
50use ftui_text::{display_width, grapheme_width, graphemes};
51
52use crate::Widget;
53use crate::adaptive_radix::AdaptiveRadixTree;
54
55#[cfg(feature = "tracing")]
56use tracing::{debug, info};
57#[cfg(feature = "tracing")]
58use web_time::Instant;
59
60#[cfg(feature = "tracing")]
61const TELEMETRY_TARGET: &str = "ftui_widgets::command_palette";
62
63#[cfg(feature = "tracing")]
64fn emit_palette_opened(action_count: usize, result_count: usize) {
65    info!(
66        target: TELEMETRY_TARGET,
67        event = "palette_opened",
68        action_count,
69        result_count
70    );
71}
72
73#[cfg(feature = "tracing")]
74fn emit_palette_query_updated(query: &str, match_count: usize, latency_ms: u128) {
75    info!(
76        target: TELEMETRY_TARGET,
77        event = "palette_query_updated",
78        query_len = query.len(),
79        match_count,
80        latency_ms
81    );
82    if tracing::enabled!(target: TELEMETRY_TARGET, tracing::Level::DEBUG) {
83        debug!(
84            target: TELEMETRY_TARGET,
85            event = "palette_query_text",
86            query
87        );
88    }
89}
90
91#[cfg(feature = "tracing")]
92fn emit_palette_action_executed(action_id: &str, latency_ms: Option<u128>) {
93    if let Some(latency_ms) = latency_ms {
94        info!(
95            target: TELEMETRY_TARGET,
96            event = "palette_action_executed",
97            action_id,
98            latency_ms
99        );
100    } else {
101        info!(
102            target: TELEMETRY_TARGET,
103            event = "palette_action_executed",
104            action_id
105        );
106    }
107}
108
109#[cfg(feature = "tracing")]
110fn emit_palette_closed(reason: PaletteCloseReason) {
111    info!(
112        target: TELEMETRY_TARGET,
113        event = "palette_closed",
114        reason = reason.as_str()
115    );
116}
117
118// ---------------------------------------------------------------------------
119// Action Item
120// ---------------------------------------------------------------------------
121
122/// A single action that can be invoked from the command palette.
123#[derive(Debug, Clone)]
124pub struct ActionItem {
125    /// Unique identifier for this action.
126    pub id: String,
127    /// Display title (searched by the scorer).
128    pub title: String,
129    /// Optional description shown below the title.
130    pub description: Option<String>,
131    /// Tags for boosting search relevance.
132    pub tags: Vec<String>,
133    /// Category for visual grouping (e.g., "Git", "File", "View").
134    pub category: Option<String>,
135}
136
137impl ActionItem {
138    /// Create a new action item.
139    pub fn new(id: impl Into<String>, title: impl Into<String>) -> Self {
140        Self {
141            id: id.into(),
142            title: title.into(),
143            description: None,
144            tags: Vec::new(),
145            category: None,
146        }
147    }
148
149    /// Set description (builder).
150    #[must_use]
151    pub fn with_description(mut self, desc: impl Into<String>) -> Self {
152        self.description = Some(desc.into());
153        self
154    }
155
156    /// Set tags (builder).
157    #[must_use]
158    pub fn with_tags(mut self, tags: &[&str]) -> Self {
159        self.tags = tags.iter().map(|s| (*s).to_string()).collect();
160        self
161    }
162
163    /// Set category (builder).
164    #[must_use]
165    pub fn with_category(mut self, cat: impl Into<String>) -> Self {
166        self.category = Some(cat.into());
167        self
168    }
169}
170
171// ---------------------------------------------------------------------------
172// Palette Action
173// ---------------------------------------------------------------------------
174
175/// Action returned from event handling.
176#[derive(Debug, Clone, PartialEq, Eq)]
177pub enum PaletteAction {
178    /// User selected an action to execute (contains the action ID).
179    Execute(String),
180    /// User dismissed the palette (Esc).
181    Dismiss,
182}
183
184#[derive(Debug, Clone, Copy, PartialEq, Eq)]
185enum PaletteCloseReason {
186    Dismiss,
187    Execute,
188    Toggle,
189    Programmatic,
190}
191
192impl PaletteCloseReason {
193    #[cfg(feature = "tracing")]
194    const fn as_str(self) -> &'static str {
195        match self {
196            Self::Dismiss => "dismiss",
197            Self::Execute => "execute",
198            Self::Toggle => "toggle",
199            Self::Programmatic => "programmatic",
200        }
201    }
202}
203
204fn compute_word_starts(title_lower: &str) -> Vec<usize> {
205    let bytes = title_lower.as_bytes();
206    title_lower
207        .char_indices()
208        .filter_map(|(i, _)| {
209            let is_word_start = i == 0 || {
210                let prev = bytes.get(i.saturating_sub(1)).copied().unwrap_or(b' ');
211                prev == b' ' || prev == b'-' || prev == b'_'
212            };
213            is_word_start.then_some(i)
214        })
215        .collect()
216}
217
218// ---------------------------------------------------------------------------
219// Palette Style
220// ---------------------------------------------------------------------------
221
222/// Visual styling for the command palette.
223#[derive(Debug, Clone)]
224pub struct PaletteStyle {
225    /// Border style.
226    pub border: Style,
227    /// Query input style.
228    pub input: Style,
229    /// Normal result item style.
230    pub item: Style,
231    /// Selected/highlighted result item style.
232    pub item_selected: Style,
233    /// Match highlight style (for matched characters).
234    pub match_highlight: Style,
235    /// Description text style.
236    pub description: Style,
237    /// Category badge style.
238    pub category: Style,
239    /// Empty state / hint text style.
240    pub hint: Style,
241}
242
243impl Default for PaletteStyle {
244    fn default() -> Self {
245        // Colors chosen for WCAG AA contrast ratios against bg(30,30,40):
246        // - item (190,190,200) on bg(30,30,40) ≈ 9.5:1 (AAA)
247        // - selected (255,255,255) on bg(50,50,75) ≈ 8.8:1 (AAA)
248        // - highlight (255,210,60) on bg(30,30,40) ≈ 11:1 (AAA)
249        // - description (140,140,160) on bg(30,30,40) ≈ 5.2:1 (AA)
250        Self {
251            border: Style::new().fg(PackedRgba::rgb(100, 100, 120)),
252            input: Style::new().fg(PackedRgba::rgb(220, 220, 230)),
253            item: Style::new().fg(PackedRgba::rgb(190, 190, 200)),
254            item_selected: Style::new()
255                .fg(PackedRgba::rgb(255, 255, 255))
256                .bg(PackedRgba::rgb(50, 50, 75)),
257            match_highlight: Style::new().fg(PackedRgba::rgb(255, 210, 60)),
258            description: Style::new().fg(PackedRgba::rgb(140, 140, 160)),
259            category: Style::new().fg(PackedRgba::rgb(100, 180, 255)),
260            hint: Style::new().fg(PackedRgba::rgb(100, 100, 120)),
261        }
262    }
263}
264
265// ---------------------------------------------------------------------------
266// Scored Item (internal)
267// ---------------------------------------------------------------------------
268
269/// Internal: a scored result with corpus index.
270#[derive(Debug)]
271struct ScoredItem {
272    /// Index into the actions vec.
273    action_index: usize,
274    /// Match result from scorer.
275    result: MatchResult,
276}
277
278// ---------------------------------------------------------------------------
279// Public Result View
280// ---------------------------------------------------------------------------
281
282/// Read-only view of a scored palette item.
283#[derive(Debug, Clone, Copy)]
284pub struct PaletteMatch<'a> {
285    /// Action metadata.
286    pub action: &'a ActionItem,
287    /// Match result (score, match type, evidence).
288    pub result: &'a MatchResult,
289}
290
291// ---------------------------------------------------------------------------
292// Match Filter
293// ---------------------------------------------------------------------------
294
295/// Optional match-type filter for palette results.
296#[derive(Debug, Clone, Copy, PartialEq, Eq)]
297pub enum MatchFilter {
298    /// Show all matches.
299    All,
300    /// Exact match only.
301    Exact,
302    /// Prefix match only.
303    Prefix,
304    /// Word-start match only.
305    WordStart,
306    /// Substring match only.
307    Substring,
308    /// Fuzzy match only.
309    Fuzzy,
310}
311
312impl MatchFilter {
313    fn allows(self, match_type: MatchType) -> bool {
314        matches!(
315            (self, match_type),
316            (Self::All, _)
317                | (Self::Exact, MatchType::Exact)
318                | (Self::Prefix, MatchType::Prefix)
319                | (Self::WordStart, MatchType::WordStart)
320                | (Self::Substring, MatchType::Substring)
321                | (Self::Fuzzy, MatchType::Fuzzy)
322        )
323    }
324}
325
326// ---------------------------------------------------------------------------
327// Command Palette Widget
328// ---------------------------------------------------------------------------
329
330/// Command palette widget for instant action search.
331///
332/// Provides a fuzzy-search overlay with keyboard navigation, match highlighting,
333/// and incremental scoring for responsive keystroke handling.
334///
335/// # Invariants
336///
337/// 1. `selected` is always < `filtered.len()` (or 0 when empty).
338/// 2. Results are sorted by descending score with stable tie-breaking.
339/// 3. Query changes trigger incremental re-scoring (not full rescan)
340///    when the query extends the previous one.
341#[derive(Debug)]
342pub struct CommandPalette {
343    /// Registered actions.
344    actions: Vec<ActionItem>,
345    /// Cached titles for scoring (avoids per-keystroke Vec allocation).
346    titles_cache: Vec<String>,
347    /// Cached lowercased titles for scoring.
348    titles_lower: Vec<String>,
349    /// Cached word-start positions for each lowercased title.
350    titles_word_starts: Vec<Vec<usize>>,
351    /// Adaptive radix index over lowercased titles for prefix-only searches.
352    prefix_index: AdaptiveRadixTree<usize>,
353    /// Current query text.
354    query: String,
355    /// Cursor position in the query (byte offset for simplicity).
356    cursor: usize,
357    /// Currently selected index in filtered results.
358    selected: usize,
359    /// Scroll offset for visible window.
360    scroll_offset: usize,
361    /// Whether the palette is visible.
362    visible: bool,
363    /// Visual styling.
364    style: PaletteStyle,
365    /// Incremental scorer for fast keystroke handling.
366    scorer: IncrementalScorer,
367    /// Current filtered results.
368    filtered: Vec<ScoredItem>,
369    /// Optional match-type filter.
370    match_filter: MatchFilter,
371    /// Generation counter for corpus invalidation.
372    generation: u64,
373    /// Maximum visible results.
374    max_visible: usize,
375    /// Custom title for the palette border (default: " Command Palette ").
376    title: String,
377    /// When true, use the full `Rect` passed to `render()` instead of
378    /// computing a centered sub-area.
379    fill_area: bool,
380    /// Telemetry timing anchor (only when tracing feature is enabled).
381    #[cfg(feature = "tracing")]
382    opened_at: Option<Instant>,
383}
384
385impl Default for CommandPalette {
386    fn default() -> Self {
387        Self::new()
388    }
389}
390
391impl CommandPalette {
392    /// Create a new empty command palette.
393    pub fn new() -> Self {
394        Self {
395            actions: Vec::new(),
396            titles_cache: Vec::new(),
397            titles_lower: Vec::new(),
398            titles_word_starts: Vec::new(),
399            prefix_index: AdaptiveRadixTree::new(),
400            query: String::new(),
401            cursor: 0,
402            selected: 0,
403            scroll_offset: 0,
404            visible: false,
405            style: PaletteStyle::default(),
406            scorer: IncrementalScorer::new(),
407            filtered: Vec::new(),
408            match_filter: MatchFilter::All,
409            generation: 0,
410            max_visible: 10,
411            title: " Command Palette ".to_string(),
412            fill_area: false,
413            #[cfg(feature = "tracing")]
414            opened_at: None,
415        }
416    }
417
418    /// Set the visual style (builder).
419    #[must_use]
420    pub fn with_style(mut self, style: PaletteStyle) -> Self {
421        self.style = style;
422        self
423    }
424
425    /// Set the visual style.
426    pub fn set_style(&mut self, style: PaletteStyle) {
427        self.style = style;
428    }
429
430    /// Set max visible results (builder).
431    #[must_use]
432    pub fn with_max_visible(mut self, n: usize) -> Self {
433        self.max_visible = n;
434        self
435    }
436
437    /// Set a custom title for the palette border (builder).
438    ///
439    /// Defaults to `" Command Palette "`. The title is rendered centered in the
440    /// top border. Surrounding spaces are the caller's responsibility.
441    #[must_use]
442    pub fn with_title(mut self, title: impl Into<String>) -> Self {
443        self.title = title.into();
444        self
445    }
446
447    /// Set a custom title for the palette border.
448    pub fn set_title(&mut self, title: impl Into<String>) {
449        self.title = title.into();
450    }
451
452    /// Use the full area passed to `render()` instead of computing a centered
453    /// sub-area (builder).
454    ///
455    /// When `true`, the palette fills the entire `Rect` handed to
456    /// [`Widget::render`], letting the caller control position and size
457    /// externally. When `false` (the default), the palette computes its own
458    /// dimensions (~60 % width, centered, 1/6 from top).
459    #[must_use]
460    pub fn with_fill_area(mut self, fill: bool) -> Self {
461        self.fill_area = fill;
462        self
463    }
464
465    /// Set whether the palette should fill the entire render area.
466    pub fn set_fill_area(&mut self, fill: bool) {
467        self.fill_area = fill;
468    }
469
470    /// Enable or disable evidence tracking for match results.
471    pub fn enable_evidence_tracking(&mut self, enabled: bool) {
472        self.scorer = if enabled {
473            IncrementalScorer::with_scorer(BayesianScorer::new())
474        } else {
475            IncrementalScorer::new()
476        };
477        self.update_filtered(false);
478    }
479
480    // --- Action Registration ---
481
482    fn push_title_cache_into(
483        titles_cache: &mut Vec<String>,
484        titles_lower: &mut Vec<String>,
485        titles_word_starts: &mut Vec<Vec<usize>>,
486        title: &str,
487    ) {
488        titles_cache.push(title.to_string());
489        let lower = title.to_lowercase();
490        titles_word_starts.push(compute_word_starts(&lower));
491        titles_lower.push(lower);
492    }
493
494    fn push_title_cache(&mut self, title: &str) {
495        Self::push_title_cache_into(
496            &mut self.titles_cache,
497            &mut self.titles_lower,
498            &mut self.titles_word_starts,
499            title,
500        );
501    }
502
503    fn prefix_index_key(title_lower: &str, action_index: usize) -> String {
504        format!("{title_lower}\u{1f}{action_index:020}")
505    }
506
507    fn insert_prefix_index_entry(&mut self, action_index: usize) {
508        let key = self
509            .titles_lower
510            .get(action_index)
511            .map(|title_lower| Self::prefix_index_key(title_lower, action_index));
512        if let Some(key) = key {
513            self.prefix_index.insert(&key, action_index);
514        }
515    }
516
517    fn rebuild_prefix_index(&mut self) {
518        let mut prefix_index = AdaptiveRadixTree::new();
519        for (action_index, title_lower) in self.titles_lower.iter().enumerate() {
520            let key = Self::prefix_index_key(title_lower, action_index);
521            prefix_index.insert(&key, action_index);
522        }
523        self.prefix_index = prefix_index;
524    }
525
526    fn rebuild_title_cache(&mut self) {
527        self.titles_cache.clear();
528        self.titles_lower.clear();
529        self.titles_word_starts.clear();
530
531        self.titles_cache.reserve(self.actions.len());
532        self.titles_lower.reserve(self.actions.len());
533        self.titles_word_starts.reserve(self.actions.len());
534
535        let titles_cache = &mut self.titles_cache;
536        let titles_lower = &mut self.titles_lower;
537        let titles_word_starts = &mut self.titles_word_starts;
538        for action in &self.actions {
539            Self::push_title_cache_into(
540                titles_cache,
541                titles_lower,
542                titles_word_starts,
543                &action.title,
544            );
545        }
546    }
547
548    fn rebuild_search_cache(&mut self) {
549        self.rebuild_title_cache();
550        self.rebuild_prefix_index();
551    }
552
553    /// Register a new action.
554    pub fn register(
555        &mut self,
556        title: impl Into<String>,
557        description: Option<&str>,
558        tags: &[&str],
559    ) -> &mut Self {
560        let title = title.into();
561        let id = title.to_lowercase().replace(' ', "_");
562        let mut item = ActionItem::new(id, title);
563        if let Some(desc) = description {
564            item.description = Some(desc.to_string());
565        }
566        item.tags = tags.iter().map(|s| (*s).to_string()).collect();
567        let action_index = self.actions.len();
568        self.push_title_cache(&item.title);
569        self.insert_prefix_index_entry(action_index);
570        self.actions.push(item);
571        self.generation = self.generation.wrapping_add(1);
572        self.refresh_filtered_after_action_change();
573        self
574    }
575
576    /// Register an action item directly.
577    pub fn register_action(&mut self, action: ActionItem) -> &mut Self {
578        let action_index = self.actions.len();
579        self.push_title_cache(&action.title);
580        self.insert_prefix_index_entry(action_index);
581        self.actions.push(action);
582        self.generation = self.generation.wrapping_add(1);
583        self.refresh_filtered_after_action_change();
584        self
585    }
586
587    /// Replace all actions with a new list.
588    ///
589    /// This resets caches and refreshes the filtered results.
590    pub fn replace_actions(&mut self, actions: Vec<ActionItem>) {
591        self.actions = actions;
592        self.rebuild_search_cache();
593        self.generation = self.generation.wrapping_add(1);
594        self.scorer.invalidate();
595        self.selected = 0;
596        self.scroll_offset = 0;
597        self.update_filtered(false);
598    }
599
600    /// Clear all registered actions.
601    pub fn clear_actions(&mut self) {
602        self.replace_actions(Vec::new());
603    }
604
605    /// Number of registered actions.
606    pub fn action_count(&self) -> usize {
607        self.actions.len()
608    }
609
610    fn refresh_filtered_after_action_change(&mut self) {
611        if self.visible
612            || !self.query.is_empty()
613            || !self.filtered.is_empty()
614            || self.match_filter != MatchFilter::All
615        {
616            self.update_filtered(false);
617        }
618    }
619
620    // --- Visibility ---
621
622    /// Open the palette (show it and focus the query input).
623    pub fn open(&mut self) {
624        self.visible = true;
625        self.query.clear();
626        self.cursor = 0;
627        self.selected = 0;
628        self.scroll_offset = 0;
629        self.scorer.invalidate();
630        #[cfg(feature = "tracing")]
631        {
632            self.opened_at = Some(Instant::now());
633        }
634        self.update_filtered(false);
635        #[cfg(feature = "tracing")]
636        emit_palette_opened(self.actions.len(), self.filtered.len());
637    }
638
639    /// Close the palette.
640    pub fn close(&mut self) {
641        self.close_with_reason(PaletteCloseReason::Programmatic);
642    }
643
644    /// Toggle visibility.
645    pub fn toggle(&mut self) {
646        if self.visible {
647            self.close_with_reason(PaletteCloseReason::Toggle);
648        } else {
649            self.open();
650        }
651    }
652
653    /// Whether the palette is currently visible.
654    #[inline]
655    pub fn is_visible(&self) -> bool {
656        self.visible
657    }
658
659    // --- Query Access ---
660
661    /// Current query string.
662    pub fn query(&self) -> &str {
663        &self.query
664    }
665
666    /// Replace the query string and re-run filtering.
667    pub fn set_query(&mut self, query: impl Into<String>) {
668        self.query = query.into();
669        self.cursor = self.query.len();
670        self.selected = 0;
671        self.scroll_offset = 0;
672        self.scorer.invalidate();
673        self.update_filtered(false);
674    }
675
676    /// Number of filtered results.
677    pub fn result_count(&self) -> usize {
678        self.filtered.len()
679    }
680
681    /// Currently selected index.
682    #[inline]
683    pub fn selected_index(&self) -> usize {
684        self.selected
685    }
686
687    /// Get the currently selected action, if any.
688    #[must_use = "use the selected action (if any)"]
689    pub fn selected_action(&self) -> Option<&ActionItem> {
690        self.filtered
691            .get(self.selected)
692            .map(|si| &self.actions[si.action_index])
693    }
694
695    /// Read-only access to the selected match (action + result).
696    #[must_use = "use the selected match (if any)"]
697    pub fn selected_match(&self) -> Option<PaletteMatch<'_>> {
698        self.filtered.get(self.selected).map(|si| PaletteMatch {
699            action: &self.actions[si.action_index],
700            result: &si.result,
701        })
702    }
703
704    /// Iterate over the current filtered results.
705    pub fn results(&self) -> impl Iterator<Item = PaletteMatch<'_>> {
706        self.filtered.iter().map(|si| PaletteMatch {
707            action: &self.actions[si.action_index],
708            result: &si.result,
709        })
710    }
711
712    /// Set a match-type filter and refresh results.
713    pub fn set_match_filter(&mut self, filter: MatchFilter) {
714        if self.match_filter == filter {
715            return;
716        }
717        self.match_filter = filter;
718        self.selected = 0;
719        self.scroll_offset = 0;
720        self.update_filtered(false);
721    }
722
723    /// Get scorer statistics for diagnostics.
724    pub fn scorer_stats(&self) -> &IncrementalStats {
725        self.scorer.stats()
726    }
727
728    // --- Event Handling ---
729
730    /// Handle an input event. Returns a `PaletteAction` if the user executed
731    /// or dismissed the palette.
732    ///
733    /// Returns `None` if the event was consumed but no action was triggered,
734    /// or if the palette is not visible.
735    #[must_use = "use the returned action (if any) to execute or dismiss"]
736    pub fn handle_event(&mut self, event: &Event) -> Option<PaletteAction> {
737        if !self.visible {
738            // Check for open shortcut (Ctrl+P)
739            if let Event::Key(KeyEvent {
740                code: KeyCode::Char('p'),
741                modifiers,
742                kind: KeyEventKind::Press,
743            }) = event
744                && modifiers.contains(Modifiers::CTRL)
745            {
746                self.open();
747            }
748            return None;
749        }
750
751        match event {
752            Event::Key(KeyEvent {
753                code,
754                modifiers,
755                kind: KeyEventKind::Press,
756            }) => self.handle_key(*code, *modifiers),
757            _ => None,
758        }
759    }
760
761    /// Handle a key press while the palette is open.
762    fn handle_key(&mut self, code: KeyCode, modifiers: Modifiers) -> Option<PaletteAction> {
763        match code {
764            KeyCode::Escape => {
765                self.close_with_reason(PaletteCloseReason::Dismiss);
766                return Some(PaletteAction::Dismiss);
767            }
768
769            KeyCode::Enter => {
770                if let Some(si) = self.filtered.get(self.selected) {
771                    let id = self.actions[si.action_index].id.clone();
772                    #[cfg(feature = "tracing")]
773                    {
774                        let latency_ms = self.opened_at.map(|start| start.elapsed().as_millis());
775                        emit_palette_action_executed(&id, latency_ms);
776                    }
777                    self.close_with_reason(PaletteCloseReason::Execute);
778                    return Some(PaletteAction::Execute(id));
779                }
780            }
781
782            KeyCode::Up if self.selected > 0 => {
783                self.selected -= 1;
784                self.adjust_scroll();
785            }
786
787            KeyCode::Down
788                if !self.filtered.is_empty() && self.selected < self.filtered.len() - 1 =>
789            {
790                self.selected += 1;
791                self.adjust_scroll();
792            }
793
794            KeyCode::PageUp => {
795                self.selected = self.selected.saturating_sub(self.max_visible);
796                self.adjust_scroll();
797            }
798
799            KeyCode::PageDown if !self.filtered.is_empty() => {
800                self.selected = (self.selected + self.max_visible).min(self.filtered.len() - 1);
801                self.adjust_scroll();
802            }
803
804            KeyCode::Home => {
805                self.selected = 0;
806                self.scroll_offset = 0;
807            }
808
809            KeyCode::End if !self.filtered.is_empty() => {
810                self.selected = self.filtered.len() - 1;
811                self.adjust_scroll();
812            }
813
814            KeyCode::Backspace if self.cursor > 0 => {
815                // Find the previous char boundary before the cursor and remove that char.
816                let prev = self.query[..self.cursor]
817                    .char_indices()
818                    .next_back()
819                    .map(|(i, _)| i)
820                    .unwrap_or(0);
821                self.query.drain(prev..self.cursor);
822                self.cursor = prev;
823                self.selected = 0;
824                self.scroll_offset = 0;
825                self.update_filtered(true);
826            }
827
828            KeyCode::Delete if self.cursor < self.query.len() => {
829                // Find the next char boundary after the cursor and remove that char.
830                let next = self.query[self.cursor..]
831                    .char_indices()
832                    .nth(1)
833                    .map(|(i, _)| self.cursor + i)
834                    .unwrap_or(self.query.len());
835                self.query.drain(self.cursor..next);
836                self.selected = 0;
837                self.scroll_offset = 0;
838                self.update_filtered(true);
839            }
840
841            KeyCode::Left if self.cursor > 0 => {
842                // Move cursor to previous char boundary.
843                self.cursor = self.query[..self.cursor]
844                    .char_indices()
845                    .next_back()
846                    .map(|(i, _)| i)
847                    .unwrap_or(0);
848            }
849
850            KeyCode::Right if self.cursor < self.query.len() => {
851                // Move cursor to next char boundary.
852                self.cursor = self.query[self.cursor..]
853                    .char_indices()
854                    .nth(1)
855                    .map(|(i, _)| self.cursor + i)
856                    .unwrap_or(self.query.len());
857            }
858
859            KeyCode::Char(c) => {
860                if modifiers.contains(Modifiers::CTRL) {
861                    // Ctrl+A: move cursor to start
862                    if c == 'a' {
863                        self.cursor = 0;
864                    }
865                    // Ctrl+E: move cursor to end
866                    if c == 'e' {
867                        self.cursor = self.query.len();
868                    }
869                    // Ctrl+U: clear query
870                    if c == 'u' {
871                        self.query.clear();
872                        self.cursor = 0;
873                        self.selected = 0;
874                        self.scroll_offset = 0;
875                        self.update_filtered(true);
876                    }
877                } else {
878                    // Insert character at cursor position.
879                    self.query.insert(self.cursor, c);
880                    self.cursor += c.len_utf8();
881                    self.selected = 0;
882                    self.scroll_offset = 0;
883                    self.update_filtered(true);
884                }
885            }
886
887            _ => {}
888        }
889
890        None
891    }
892
893    /// Re-score the corpus against the current query.
894    fn update_filtered(&mut self, _emit_telemetry: bool) {
895        #[cfg(feature = "tracing")]
896        // Don't gate on `tracing::enabled!` here: callsite interest can be cached across
897        // dynamic subscribers (tests), which may suppress telemetry unexpectedly.
898        // Emitting the event is already cheap when disabled.
899        let start = _emit_telemetry.then(Instant::now);
900
901        if self.titles_cache.len() != self.actions.len()
902            || self.titles_lower.len() != self.actions.len()
903            || self.titles_word_starts.len() != self.actions.len()
904            || self.prefix_index.len() != self.actions.len()
905        {
906            self.rebuild_search_cache();
907        }
908
909        let results = if self.match_filter == MatchFilter::Prefix && !self.query.is_empty() {
910            let query_lower = self.query.to_lowercase();
911            let candidate_indices: Vec<usize> = self
912                .prefix_index
913                .prefix_scan(&query_lower)
914                .into_iter()
915                .map(|(_, action_index)| *action_index)
916                .collect();
917            self.scorer.score_candidate_indices_with_lowered_and_words(
918                &self.query,
919                &self.titles_cache,
920                &self.titles_lower,
921                &self.titles_word_starts,
922                &candidate_indices,
923                Some(self.generation),
924            )
925        } else {
926            self.scorer.score_corpus_with_lowered_and_words(
927                &self.query,
928                &self.titles_cache,
929                &self.titles_lower,
930                &self.titles_word_starts,
931                Some(self.generation),
932            )
933        };
934
935        self.filtered = results
936            .into_iter()
937            .filter(|(_, result)| self.match_filter.allows(result.match_type))
938            .map(|(idx, result)| ScoredItem {
939                action_index: idx,
940                result,
941            })
942            .collect();
943
944        // Clamp selection.
945        if !self.filtered.is_empty() {
946            self.selected = self.selected.min(self.filtered.len() - 1);
947            self.adjust_scroll();
948        } else {
949            self.selected = 0;
950            self.scroll_offset = 0;
951        }
952
953        #[cfg(feature = "tracing")]
954        if let Some(start) = start {
955            emit_palette_query_updated(
956                &self.query,
957                self.filtered.len(),
958                start.elapsed().as_millis(),
959            );
960        }
961    }
962
963    fn close_with_reason(&mut self, _reason: PaletteCloseReason) {
964        self.visible = false;
965        self.query.clear();
966        self.cursor = 0;
967        self.filtered.clear();
968        #[cfg(feature = "tracing")]
969        {
970            self.opened_at = None;
971            emit_palette_closed(_reason);
972        }
973    }
974
975    /// Adjust scroll_offset to keep selected item visible.
976    fn adjust_scroll(&mut self) {
977        if self.selected < self.scroll_offset {
978            self.scroll_offset = self.selected;
979        } else if self.selected >= self.scroll_offset.saturating_add(self.max_visible) {
980            self.scroll_offset = self
981                .selected
982                .saturating_sub(self.max_visible.saturating_sub(1));
983        }
984    }
985}
986
987// ---------------------------------------------------------------------------
988// Widget Implementation
989// ---------------------------------------------------------------------------
990
991impl Widget for CommandPalette {
992    fn render(&self, area: Rect, frame: &mut Frame) {
993        if !self.visible || area.width < 10 || area.height < 5 {
994            return;
995        }
996
997        let palette_area = if self.fill_area {
998            // Caller controls layout — use the full area as-is.
999            area
1000        } else {
1001            // Calculate palette dimensions: centered, ~60% width, height based on results.
1002            let palette_width = (area.width * 3 / 5).max(30).min(area.width - 2);
1003            let result_rows = self.filtered.len().min(self.max_visible);
1004            // +3 for: border top, query line, border bottom. +1 if empty hint.
1005            let palette_height = (result_rows as u16 + 3)
1006                .max(5)
1007                .min(area.height.saturating_sub(2));
1008            let palette_x = area.x + (area.width.saturating_sub(palette_width)) / 2;
1009            let palette_y = area.y + area.height / 6; // ~1/6 from top
1010            Rect::new(palette_x, palette_y, palette_width, palette_height)
1011        };
1012
1013        // Clear the palette area.
1014        self.clear_area(palette_area, frame);
1015
1016        // Draw border.
1017        self.draw_border(palette_area, frame);
1018
1019        // Draw query input line.
1020        let input_area = Rect::new(
1021            palette_area.x + 2,
1022            palette_area.y + 1,
1023            palette_area.width.saturating_sub(4),
1024            1,
1025        );
1026        self.draw_query_input(input_area, frame);
1027
1028        // Draw results list.
1029        let results_y = palette_area.y + 2;
1030        let results_height = palette_area.height.saturating_sub(3);
1031        let results_area = Rect::new(
1032            palette_area.x + 1,
1033            results_y,
1034            palette_area.width.saturating_sub(2),
1035            results_height,
1036        );
1037        self.draw_results(results_area, frame);
1038
1039        // Position cursor in query input.
1040        // Calculate visual cursor position from byte offset by computing display width
1041        // of the text up to the cursor position.
1042        let cursor_visual_pos = display_width(&self.query[..self.cursor.min(self.query.len())]);
1043        let cursor_x = input_area.x + cursor_visual_pos.min(input_area.width as usize) as u16;
1044        frame.cursor_position = Some((cursor_x, input_area.y));
1045        frame.cursor_visible = true;
1046    }
1047
1048    fn is_essential(&self) -> bool {
1049        true
1050    }
1051}
1052
1053impl CommandPalette {
1054    /// Resolve the palette surface background.
1055    ///
1056    /// Prefer explicit style backgrounds when provided so host apps can
1057    /// theme the overlay; otherwise fall back to the historical dark surface.
1058    fn palette_background(&self) -> PackedRgba {
1059        self.style
1060            .border
1061            .bg
1062            .or(self.style.input.bg)
1063            .or(self.style.item.bg)
1064            .or(self.style.hint.bg)
1065            .or(self.style.item_selected.bg)
1066            .unwrap_or(PackedRgba::rgb(30, 30, 40))
1067    }
1068
1069    /// Clear the palette area with a background color.
1070    fn clear_area(&self, area: Rect, frame: &mut Frame) {
1071        let bg = self.palette_background();
1072        for y in area.y..area.bottom() {
1073            for x in area.x..area.right() {
1074                if let Some(cell) = frame.buffer.get_mut(x, y) {
1075                    *cell = Cell::from_char(' ');
1076                    cell.bg = bg;
1077                }
1078            }
1079        }
1080    }
1081
1082    /// Draw a rounded border around the palette.
1083    fn draw_border(&self, area: Rect, frame: &mut Frame) {
1084        let border_fg = self
1085            .style
1086            .border
1087            .fg
1088            .unwrap_or(PackedRgba::rgb(100, 100, 120));
1089        let bg = self.palette_background();
1090
1091        // Top border with title.
1092        let mut cell = Cell::from_char('╭');
1093        cell.fg = border_fg;
1094        cell.bg = bg;
1095        frame.buffer.set_fast(area.x, area.y, cell);
1096
1097        for x in (area.x + 1)..area.right().saturating_sub(1) {
1098            let mut cell = Cell::from_char('─');
1099            cell.fg = border_fg;
1100            cell.bg = bg;
1101            frame.buffer.set_fast(x, area.y, cell);
1102        }
1103        if area.width > 1 {
1104            let mut cell = Cell::from_char('╮');
1105            cell.fg = border_fg;
1106            cell.bg = bg;
1107            frame.buffer.set_fast(area.right() - 1, area.y, cell);
1108        }
1109
1110        // Title in top border.
1111        let title = &self.title;
1112        let title_width = display_width(title).min(area.width as usize);
1113        let title_x = area.x + (area.width.saturating_sub(title_width as u16)) / 2;
1114        let title_style = Style::new().fg(PackedRgba::rgb(200, 200, 220)).bg(bg);
1115        crate::draw_text_span(frame, title_x, area.y, title, title_style, area.right());
1116
1117        // Side borders.
1118        for y in (area.y + 1)..area.bottom().saturating_sub(1) {
1119            let mut cell_l = Cell::from_char('│');
1120            cell_l.fg = border_fg;
1121            cell_l.bg = bg;
1122            frame.buffer.set_fast(area.x, y, cell_l);
1123
1124            if area.width > 1 {
1125                let mut cell_r = Cell::from_char('│');
1126                cell_r.fg = border_fg;
1127                cell_r.bg = bg;
1128                frame.buffer.set_fast(area.right() - 1, y, cell_r);
1129            }
1130        }
1131
1132        // Bottom border.
1133        if area.height > 1 {
1134            let by = area.bottom() - 1;
1135            let mut cell_bl = Cell::from_char('╰');
1136            cell_bl.fg = border_fg;
1137            cell_bl.bg = bg;
1138            frame.buffer.set_fast(area.x, by, cell_bl);
1139
1140            for x in (area.x + 1)..area.right().saturating_sub(1) {
1141                let mut cell = Cell::from_char('─');
1142                cell.fg = border_fg;
1143                cell.bg = bg;
1144                frame.buffer.set_fast(x, by, cell);
1145            }
1146            if area.width > 1 {
1147                let mut cell_br = Cell::from_char('╯');
1148                cell_br.fg = border_fg;
1149                cell_br.bg = bg;
1150                frame.buffer.set_fast(area.right() - 1, by, cell_br);
1151            }
1152        }
1153    }
1154
1155    /// Draw the query input line with prompt.
1156    fn draw_query_input(&self, area: Rect, frame: &mut Frame) {
1157        let input_fg = self
1158            .style
1159            .input
1160            .fg
1161            .unwrap_or(PackedRgba::rgb(220, 220, 230));
1162        let bg = self.palette_background();
1163        let prompt_fg = PackedRgba::rgb(100, 180, 255);
1164
1165        // Draw ">" prompt.
1166        if let Some(cell) = frame.buffer.get_mut(area.x.saturating_sub(1), area.y) {
1167            cell.content = CellContent::from_char('>');
1168            cell.fg = prompt_fg;
1169            cell.bg = bg;
1170        }
1171
1172        // Draw query text.
1173        if self.query.is_empty() {
1174            // Placeholder.
1175            let hint = "Type to search...";
1176            let hint_fg = self.style.hint.fg.unwrap_or(PackedRgba::rgb(100, 100, 120));
1177            for (i, ch) in hint.chars().enumerate() {
1178                let x = area.x + i as u16;
1179                if x >= area.right() {
1180                    break;
1181                }
1182                if let Some(cell) = frame.buffer.get_mut(x, area.y) {
1183                    cell.content = CellContent::from_char(ch);
1184                    cell.fg = hint_fg;
1185                    cell.bg = bg;
1186                }
1187            }
1188        } else {
1189            // Render query text with proper grapheme/width handling.
1190            let mut col = area.x;
1191            for grapheme in graphemes(&self.query) {
1192                let w = grapheme_width(grapheme);
1193                if w == 0 {
1194                    continue;
1195                }
1196                if col >= area.right() {
1197                    break;
1198                }
1199                if col.saturating_add(w as u16) > area.right() {
1200                    break;
1201                }
1202                let content = if w > 1 || grapheme.chars().count() > 1 {
1203                    let id = frame.intern_with_width(grapheme, w as u8);
1204                    CellContent::from_grapheme(id)
1205                } else if let Some(ch) = grapheme.chars().next() {
1206                    CellContent::from_char(ch)
1207                } else {
1208                    continue;
1209                };
1210                let mut cell = Cell::new(content);
1211                cell.fg = input_fg;
1212                cell.bg = bg;
1213                frame.buffer.set_fast(col, area.y, cell);
1214                col = col.saturating_add(w as u16);
1215            }
1216        }
1217    }
1218
1219    /// Draw the filtered results list.
1220    fn draw_results(&self, area: Rect, frame: &mut Frame) {
1221        if self.filtered.is_empty() {
1222            // Empty state.
1223            let msg = if self.query.is_empty() {
1224                "No actions registered"
1225            } else {
1226                "No results"
1227            };
1228            let hint_fg = self.style.hint.fg.unwrap_or(PackedRgba::rgb(100, 100, 120));
1229            let bg = self.palette_background();
1230            for (i, ch) in msg.chars().enumerate() {
1231                let x = area.x + 1 + i as u16;
1232                if x >= area.right() {
1233                    break;
1234                }
1235                if let Some(cell) = frame.buffer.get_mut(x, area.y) {
1236                    cell.content = CellContent::from_char(ch);
1237                    cell.fg = hint_fg;
1238                    cell.bg = bg;
1239                }
1240            }
1241            return;
1242        }
1243
1244        let item_fg = self.style.item.fg.unwrap_or(PackedRgba::rgb(180, 180, 190));
1245        let selected_fg = self
1246            .style
1247            .item_selected
1248            .fg
1249            .unwrap_or(PackedRgba::rgb(255, 255, 255));
1250        let selected_bg = self
1251            .style
1252            .item_selected
1253            .bg
1254            .unwrap_or(PackedRgba::rgb(60, 60, 80));
1255        let highlight_fg = self
1256            .style
1257            .match_highlight
1258            .fg
1259            .unwrap_or(PackedRgba::rgb(255, 200, 50));
1260        let desc_fg = self
1261            .style
1262            .description
1263            .fg
1264            .unwrap_or(PackedRgba::rgb(120, 120, 140));
1265        let cat_fg = self
1266            .style
1267            .category
1268            .fg
1269            .unwrap_or(PackedRgba::rgb(100, 180, 255));
1270        let bg = self.palette_background();
1271
1272        let visible_end = (self.scroll_offset + area.height as usize).min(self.filtered.len());
1273
1274        for (row_idx, si) in self.filtered[self.scroll_offset..visible_end]
1275            .iter()
1276            .enumerate()
1277        {
1278            let y = area.y + row_idx as u16;
1279            if y >= area.bottom() {
1280                break;
1281            }
1282
1283            let action = &self.actions[si.action_index];
1284            let is_selected = (self.scroll_offset + row_idx) == self.selected;
1285
1286            let row_fg = if is_selected { selected_fg } else { item_fg };
1287            let row_bg = if is_selected { selected_bg } else { bg };
1288
1289            // Bold attribute for selected row (accessible without color).
1290            let row_attrs = if is_selected {
1291                CellAttrs::new(CellStyleFlags::BOLD, 0)
1292            } else {
1293                CellAttrs::default()
1294            };
1295
1296            // Clear row.
1297            for x in area.x..area.right() {
1298                if let Some(cell) = frame.buffer.get_mut(x, y) {
1299                    cell.content = CellContent::from_char(' ');
1300                    cell.fg = row_fg;
1301                    cell.bg = row_bg;
1302                    cell.attrs = row_attrs;
1303                }
1304            }
1305
1306            // Selection marker (visible without color — structural indicator).
1307            let mut col = area.x;
1308            if is_selected && let Some(cell) = frame.buffer.get_mut(col, y) {
1309                cell.content = CellContent::from_char('>');
1310                cell.fg = highlight_fg;
1311                cell.bg = row_bg;
1312                cell.attrs = CellAttrs::new(CellStyleFlags::BOLD, 0);
1313            }
1314            col += 2;
1315
1316            // Category badge (if present).
1317            if let Some(ref cat) = action.category {
1318                let badge = format!("[{}] ", cat);
1319                for grapheme in graphemes(&badge) {
1320                    let w = grapheme_width(grapheme);
1321                    if w == 0 {
1322                        continue;
1323                    }
1324                    if col >= area.right() || col.saturating_add(w as u16) > area.right() {
1325                        break;
1326                    }
1327                    let content = if w > 1 || grapheme.chars().count() > 1 {
1328                        let id = frame.intern_with_width(grapheme, w as u8);
1329                        CellContent::from_grapheme(id)
1330                    } else if let Some(ch) = grapheme.chars().next() {
1331                        CellContent::from_char(ch)
1332                    } else {
1333                        continue;
1334                    };
1335                    let mut cell = Cell::new(content);
1336                    cell.fg = cat_fg;
1337                    cell.bg = row_bg;
1338                    cell.attrs = row_attrs;
1339                    frame.buffer.set_fast(col, y, cell);
1340                    col = col.saturating_add(w as u16);
1341                }
1342            }
1343
1344            // Title with match highlighting and ellipsis truncation.
1345            let title_max_width = area.right().saturating_sub(col) as usize;
1346            let title_width = display_width(action.title.as_str());
1347            let needs_ellipsis = title_width > title_max_width && title_max_width > 3;
1348            let title_display_width = if needs_ellipsis {
1349                title_max_width.saturating_sub(1) // leave room for '…'
1350            } else {
1351                title_max_width
1352            };
1353
1354            let mut title_used_width = 0usize;
1355            let mut char_idx = 0usize;
1356            let mut match_cursor = 0usize;
1357            let match_positions = &si.result.match_positions;
1358            for grapheme in graphemes(action.title.as_str()) {
1359                let g_chars = grapheme.chars().count();
1360                let char_end = char_idx + g_chars;
1361                while match_cursor < match_positions.len()
1362                    && match_positions[match_cursor] < char_idx
1363                {
1364                    match_cursor += 1;
1365                }
1366                let is_match = match_cursor < match_positions.len()
1367                    && match_positions[match_cursor] < char_end;
1368
1369                let w = grapheme_width(grapheme);
1370                if w == 0 {
1371                    char_idx = char_end;
1372                    continue;
1373                }
1374                if title_used_width + w > title_display_width || col >= area.right() {
1375                    break;
1376                }
1377                if col.saturating_add(w as u16) > area.right() {
1378                    break;
1379                }
1380
1381                let content = if w > 1 || grapheme.chars().count() > 1 {
1382                    let id = frame.intern_with_width(grapheme, w as u8);
1383                    CellContent::from_grapheme(id)
1384                } else if let Some(ch) = grapheme.chars().next() {
1385                    CellContent::from_char(ch)
1386                } else {
1387                    char_idx = char_end;
1388                    continue;
1389                };
1390
1391                let mut cell = Cell::new(content);
1392                cell.fg = if is_match { highlight_fg } else { row_fg };
1393                cell.bg = row_bg;
1394                cell.attrs = row_attrs;
1395                frame.buffer.set_fast(col, y, cell);
1396
1397                col = col.saturating_add(w as u16);
1398                title_used_width += w;
1399                char_idx = char_end;
1400            }
1401
1402            // Ellipsis for truncated titles.
1403            if needs_ellipsis && col < area.right() {
1404                if let Some(cell) = frame.buffer.get_mut(col, y) {
1405                    cell.content = CellContent::from_char('\u{2026}'); // …
1406                    cell.fg = row_fg;
1407                    cell.bg = row_bg;
1408                    cell.attrs = row_attrs;
1409                }
1410                col += 1;
1411            }
1412
1413            // Description (if space allows, with ellipsis truncation).
1414            if let Some(ref desc) = action.description {
1415                col += 2; // gap
1416                let max_desc_width = area.right().saturating_sub(col) as usize;
1417                if max_desc_width > 5 {
1418                    let desc_width = display_width(desc.as_str());
1419                    let desc_needs_ellipsis = desc_width > max_desc_width && max_desc_width > 3;
1420                    let desc_display_width = if desc_needs_ellipsis {
1421                        max_desc_width.saturating_sub(1)
1422                    } else {
1423                        max_desc_width
1424                    };
1425
1426                    let mut desc_used_width = 0usize;
1427                    for grapheme in graphemes(desc.as_str()) {
1428                        let w = grapheme_width(grapheme);
1429                        if w == 0 {
1430                            continue;
1431                        }
1432                        if desc_used_width + w > desc_display_width || col >= area.right() {
1433                            break;
1434                        }
1435                        if col.saturating_add(w as u16) > area.right() {
1436                            break;
1437                        }
1438                        let content = if w > 1 || grapheme.chars().count() > 1 {
1439                            let id = frame.intern_with_width(grapheme, w as u8);
1440                            CellContent::from_grapheme(id)
1441                        } else if let Some(ch) = grapheme.chars().next() {
1442                            CellContent::from_char(ch)
1443                        } else {
1444                            continue;
1445                        };
1446                        let mut cell = Cell::new(content);
1447                        cell.fg = desc_fg;
1448                        cell.bg = row_bg;
1449                        cell.attrs = row_attrs;
1450                        frame.buffer.set_fast(col, y, cell);
1451                        col = col.saturating_add(w as u16);
1452                        desc_used_width += w;
1453                    }
1454
1455                    if desc_needs_ellipsis
1456                        && col < area.right()
1457                        && let Some(cell) = frame.buffer.get_mut(col, y)
1458                    {
1459                        cell.content = CellContent::from_char('\u{2026}');
1460                        cell.fg = desc_fg;
1461                        cell.bg = row_bg;
1462                        cell.attrs = row_attrs;
1463                    }
1464                }
1465            }
1466        }
1467    }
1468}
1469
1470// ---------------------------------------------------------------------------
1471// Tests
1472// ---------------------------------------------------------------------------
1473
1474#[cfg(test)]
1475mod widget_tests {
1476    use super::*;
1477
1478    #[test]
1479    fn new_palette_is_hidden() {
1480        let palette = CommandPalette::new();
1481        assert!(!palette.is_visible());
1482        assert_eq!(palette.action_count(), 0);
1483    }
1484
1485    #[test]
1486    fn register_actions() {
1487        let mut palette = CommandPalette::new();
1488        palette.register("Open File", Some("Open a file"), &["file"]);
1489        palette.register("Save File", None, &[]);
1490        assert_eq!(palette.action_count(), 2);
1491    }
1492
1493    #[test]
1494    fn open_shows_all_actions() {
1495        let mut palette = CommandPalette::new();
1496        palette.register("Open File", None, &[]);
1497        palette.register("Save File", None, &[]);
1498        palette.register("Close Tab", None, &[]);
1499        palette.open();
1500        assert!(palette.is_visible());
1501        assert_eq!(palette.result_count(), 3);
1502    }
1503
1504    #[test]
1505    fn close_hides_palette() {
1506        let mut palette = CommandPalette::new();
1507        palette.open();
1508        assert!(palette.is_visible());
1509        palette.close();
1510        assert!(!palette.is_visible());
1511    }
1512
1513    #[test]
1514    fn toggle_visibility() {
1515        let mut palette = CommandPalette::new();
1516        palette.toggle();
1517        assert!(palette.is_visible());
1518        palette.toggle();
1519        assert!(!palette.is_visible());
1520    }
1521
1522    #[test]
1523    fn typing_filters_results() {
1524        let mut palette = CommandPalette::new();
1525        palette.register("Open File", None, &[]);
1526        palette.register("Save File", None, &[]);
1527        palette.register("Git: Commit", None, &[]);
1528        palette.open();
1529        assert_eq!(palette.result_count(), 3);
1530
1531        // Type "git"
1532        let g = Event::Key(KeyEvent {
1533            code: KeyCode::Char('g'),
1534            modifiers: Modifiers::empty(),
1535            kind: KeyEventKind::Press,
1536        });
1537        let i = Event::Key(KeyEvent {
1538            code: KeyCode::Char('i'),
1539            modifiers: Modifiers::empty(),
1540            kind: KeyEventKind::Press,
1541        });
1542        let t = Event::Key(KeyEvent {
1543            code: KeyCode::Char('t'),
1544            modifiers: Modifiers::empty(),
1545            kind: KeyEventKind::Press,
1546        });
1547
1548        let _ = palette.handle_event(&g);
1549        let _ = palette.handle_event(&i);
1550        let _ = palette.handle_event(&t);
1551
1552        assert_eq!(palette.query(), "git");
1553        // Only "Git: Commit" should match well
1554        assert!(palette.result_count() >= 1);
1555    }
1556
1557    #[test]
1558    fn backspace_removes_character() {
1559        let mut palette = CommandPalette::new();
1560        palette.register("Open File", None, &[]);
1561        palette.open();
1562
1563        let o = Event::Key(KeyEvent {
1564            code: KeyCode::Char('o'),
1565            modifiers: Modifiers::empty(),
1566            kind: KeyEventKind::Press,
1567        });
1568        let bs = Event::Key(KeyEvent {
1569            code: KeyCode::Backspace,
1570            modifiers: Modifiers::empty(),
1571            kind: KeyEventKind::Press,
1572        });
1573
1574        let _ = palette.handle_event(&o);
1575        assert_eq!(palette.query(), "o");
1576        let _ = palette.handle_event(&bs);
1577        assert_eq!(palette.query(), "");
1578    }
1579
1580    #[test]
1581    fn esc_dismisses_palette() {
1582        let mut palette = CommandPalette::new();
1583        palette.open();
1584
1585        let esc = Event::Key(KeyEvent {
1586            code: KeyCode::Escape,
1587            modifiers: Modifiers::empty(),
1588            kind: KeyEventKind::Press,
1589        });
1590
1591        let result = palette.handle_event(&esc);
1592        assert_eq!(result, Some(PaletteAction::Dismiss));
1593        assert!(!palette.is_visible());
1594    }
1595
1596    #[test]
1597    fn enter_executes_selected() {
1598        let mut palette = CommandPalette::new();
1599        palette.register("Open File", None, &[]);
1600        palette.open();
1601
1602        let enter = Event::Key(KeyEvent {
1603            code: KeyCode::Enter,
1604            modifiers: Modifiers::empty(),
1605            kind: KeyEventKind::Press,
1606        });
1607
1608        let result = palette.handle_event(&enter);
1609        assert_eq!(result, Some(PaletteAction::Execute("open_file".into())));
1610    }
1611
1612    #[test]
1613    fn arrow_keys_navigate() {
1614        let mut palette = CommandPalette::new();
1615        palette.register("A", None, &[]);
1616        palette.register("B", None, &[]);
1617        palette.register("C", None, &[]);
1618        palette.open();
1619
1620        assert_eq!(palette.selected_index(), 0);
1621
1622        let down = Event::Key(KeyEvent {
1623            code: KeyCode::Down,
1624            modifiers: Modifiers::empty(),
1625            kind: KeyEventKind::Press,
1626        });
1627        let up = Event::Key(KeyEvent {
1628            code: KeyCode::Up,
1629            modifiers: Modifiers::empty(),
1630            kind: KeyEventKind::Press,
1631        });
1632
1633        let _ = palette.handle_event(&down);
1634        assert_eq!(palette.selected_index(), 1);
1635        let _ = palette.handle_event(&down);
1636        assert_eq!(palette.selected_index(), 2);
1637        // Can't go past end
1638        let _ = palette.handle_event(&down);
1639        assert_eq!(palette.selected_index(), 2);
1640
1641        let _ = palette.handle_event(&up);
1642        assert_eq!(palette.selected_index(), 1);
1643        let _ = palette.handle_event(&up);
1644        assert_eq!(palette.selected_index(), 0);
1645        // Can't go below 0
1646        let _ = palette.handle_event(&up);
1647        assert_eq!(palette.selected_index(), 0);
1648    }
1649
1650    #[test]
1651    fn home_end_navigation() {
1652        let mut palette = CommandPalette::new();
1653        for i in 0..20 {
1654            palette.register(format!("Action {}", i), None, &[]);
1655        }
1656        palette.open();
1657
1658        let end = Event::Key(KeyEvent {
1659            code: KeyCode::End,
1660            modifiers: Modifiers::empty(),
1661            kind: KeyEventKind::Press,
1662        });
1663        let home = Event::Key(KeyEvent {
1664            code: KeyCode::Home,
1665            modifiers: Modifiers::empty(),
1666            kind: KeyEventKind::Press,
1667        });
1668
1669        let _ = palette.handle_event(&end);
1670        assert_eq!(palette.selected_index(), 19);
1671
1672        let _ = palette.handle_event(&home);
1673        assert_eq!(palette.selected_index(), 0);
1674    }
1675
1676    #[test]
1677    fn ctrl_u_clears_query() {
1678        let mut palette = CommandPalette::new();
1679        palette.register("Open File", None, &[]);
1680        palette.open();
1681
1682        let o = Event::Key(KeyEvent {
1683            code: KeyCode::Char('o'),
1684            modifiers: Modifiers::empty(),
1685            kind: KeyEventKind::Press,
1686        });
1687        let _ = palette.handle_event(&o);
1688        assert_eq!(palette.query(), "o");
1689
1690        let ctrl_u = Event::Key(KeyEvent {
1691            code: KeyCode::Char('u'),
1692            modifiers: Modifiers::CTRL,
1693            kind: KeyEventKind::Press,
1694        });
1695        let _ = palette.handle_event(&ctrl_u);
1696        assert_eq!(palette.query(), "");
1697    }
1698
1699    #[test]
1700    fn ctrl_p_opens_palette() {
1701        let mut palette = CommandPalette::new();
1702        assert!(!palette.is_visible());
1703
1704        let ctrl_p = Event::Key(KeyEvent {
1705            code: KeyCode::Char('p'),
1706            modifiers: Modifiers::CTRL,
1707            kind: KeyEventKind::Press,
1708        });
1709        let _ = palette.handle_event(&ctrl_p);
1710        assert!(palette.is_visible());
1711    }
1712
1713    #[test]
1714    fn selected_action_returns_correct_item() {
1715        let mut palette = CommandPalette::new();
1716        palette.register("Alpha", None, &[]);
1717        palette.register("Beta", None, &[]);
1718        palette.open();
1719
1720        let action = palette.selected_action().unwrap();
1721        // With empty query, all items shown — first by score (neutral, so first registered)
1722        assert!(!action.title.is_empty());
1723    }
1724
1725    #[test]
1726    fn register_action_item_directly() {
1727        let mut palette = CommandPalette::new();
1728        let item = ActionItem::new("custom_id", "Custom Action")
1729            .with_description("A custom action")
1730            .with_tags(&["custom", "test"])
1731            .with_category("Testing");
1732
1733        palette.register_action(item);
1734        assert_eq!(palette.action_count(), 1);
1735    }
1736
1737    #[test]
1738    fn register_refreshes_visible_filtered_results() {
1739        let mut palette = CommandPalette::new();
1740        palette.register("Alpha", None, &[]);
1741        palette.open();
1742        palette.set_query("Beta");
1743        assert!(palette.selected_action().is_none());
1744
1745        palette.register("Beta", None, &[]);
1746
1747        assert_eq!(palette.result_count(), 1);
1748        assert_eq!(
1749            palette
1750                .selected_action()
1751                .map(|action| action.title.as_str()),
1752            Some("Beta")
1753        );
1754    }
1755
1756    #[test]
1757    fn register_action_refreshes_visible_filtered_results() {
1758        let mut palette = CommandPalette::new();
1759        palette.register("Alpha", None, &[]);
1760        palette.open();
1761        palette.set_query("Beta");
1762        assert!(palette.selected_action().is_none());
1763
1764        palette.register_action(ActionItem::new("beta", "Beta"));
1765
1766        assert_eq!(palette.result_count(), 1);
1767        assert_eq!(
1768            palette
1769                .selected_action()
1770                .map(|action| action.title.as_str()),
1771            Some("Beta")
1772        );
1773    }
1774
1775    #[test]
1776    fn replace_actions_refreshes_results() {
1777        let mut palette = CommandPalette::new();
1778        palette.register("Alpha", None, &[]);
1779        palette.register("Beta", None, &[]);
1780        palette.open();
1781        palette.set_query("Beta");
1782        assert_eq!(
1783            palette.selected_action().map(|a| a.title.as_str()),
1784            Some("Beta")
1785        );
1786
1787        let actions = vec![
1788            ActionItem::new("gamma", "Gamma"),
1789            ActionItem::new("delta", "Delta"),
1790        ];
1791        palette.replace_actions(actions);
1792        palette.set_query("Delta");
1793        assert_eq!(
1794            palette.selected_action().map(|a| a.title.as_str()),
1795            Some("Delta")
1796        );
1797    }
1798
1799    #[test]
1800    fn clear_actions_resets_results() {
1801        let mut palette = CommandPalette::new();
1802        palette.register("Alpha", None, &[]);
1803        palette.register("Beta", None, &[]);
1804        palette.open();
1805        palette.set_query("Alpha");
1806        assert!(palette.selected_action().is_some());
1807
1808        palette.clear_actions();
1809        assert_eq!(palette.action_count(), 0);
1810        assert!(palette.selected_action().is_none());
1811    }
1812
1813    #[test]
1814    fn set_query_refilters() {
1815        let mut palette = CommandPalette::new();
1816        palette.register("Alpha", None, &[]);
1817        palette.register("Beta", None, &[]);
1818        palette.open();
1819        palette.set_query("Alpha");
1820        assert_eq!(palette.query(), "Alpha");
1821        assert_eq!(
1822            palette.selected_action().map(|a| a.title.as_str()),
1823            Some("Alpha")
1824        );
1825        palette.set_query("Beta");
1826        assert_eq!(palette.query(), "Beta");
1827        assert_eq!(
1828            palette.selected_action().map(|a| a.title.as_str()),
1829            Some("Beta")
1830        );
1831    }
1832
1833    #[test]
1834    fn events_ignored_when_hidden() {
1835        let mut palette = CommandPalette::new();
1836        // Not Ctrl+P, so should be ignored
1837        let a = Event::Key(KeyEvent {
1838            code: KeyCode::Char('a'),
1839            modifiers: Modifiers::empty(),
1840            kind: KeyEventKind::Press,
1841        });
1842        assert!(palette.handle_event(&a).is_none());
1843        assert!(!palette.is_visible());
1844    }
1845
1846    // -----------------------------------------------------------------------
1847    // Accessibility / UX tests (bd-39y4.10)
1848    // -----------------------------------------------------------------------
1849
1850    #[test]
1851    fn selected_row_has_bold_attribute() {
1852        use ftui_render::grapheme_pool::GraphemePool;
1853
1854        let mut palette = CommandPalette::new();
1855        palette.register("Alpha", None, &[]);
1856        palette.register("Beta", None, &[]);
1857        palette.open();
1858
1859        let area = Rect::from_size(60, 10);
1860        let mut pool = GraphemePool::new();
1861        let mut frame = Frame::new(60, 10, &mut pool);
1862        palette.render(area, &mut frame);
1863
1864        // The selected row (first result) should have bold cells.
1865        // Results start at y=2 inside the palette (after border + query).
1866        let palette_y = area.y + area.height / 6;
1867        let result_y = palette_y + 2;
1868
1869        // Check that at least one cell in the first result row is bold
1870        let mut found_bold = false;
1871        for x in 0..60u16 {
1872            if let Some(cell) = frame.buffer.get(x, result_y)
1873                && cell.attrs.flags().contains(CellStyleFlags::BOLD)
1874            {
1875                found_bold = true;
1876                break;
1877            }
1878        }
1879        assert!(
1880            found_bold,
1881            "Selected row should have bold attribute for accessibility"
1882        );
1883    }
1884
1885    #[test]
1886    fn selection_marker_visible() {
1887        use ftui_render::grapheme_pool::GraphemePool;
1888
1889        let mut palette = CommandPalette::new();
1890        palette.register("Alpha", None, &[]);
1891        palette.open();
1892
1893        let area = Rect::from_size(60, 10);
1894        let mut pool = GraphemePool::new();
1895        let mut frame = Frame::new(60, 10, &mut pool);
1896        palette.render(area, &mut frame);
1897
1898        // Find the '>' selection marker in the results area
1899        let palette_y = area.y + area.height / 6;
1900        let result_y = palette_y + 2;
1901        let mut found_marker = false;
1902        for x in 0..60u16 {
1903            if let Some(cell) = frame.buffer.get(x, result_y)
1904                && cell.content.as_char() == Some('>')
1905            {
1906                found_marker = true;
1907                break;
1908            }
1909        }
1910        assert!(
1911            found_marker,
1912            "Selection marker '>' should be visible (color-independent indicator)"
1913        );
1914    }
1915
1916    #[test]
1917    fn long_title_truncated_with_ellipsis() {
1918        use ftui_render::grapheme_pool::GraphemePool;
1919
1920        let mut palette = CommandPalette::new().with_max_visible(5);
1921        palette.register(
1922            "This Is A Very Long Action Title That Should Be Truncated With Ellipsis",
1923            None,
1924            &[],
1925        );
1926        palette.open();
1927
1928        // Render in a narrow area
1929        let area = Rect::from_size(40, 10);
1930        let mut pool = GraphemePool::new();
1931        let mut frame = Frame::new(40, 10, &mut pool);
1932        palette.render(area, &mut frame);
1933
1934        // Find the ellipsis character '…' in the results area
1935        let palette_y = area.y + area.height / 6;
1936        let result_y = palette_y + 2;
1937        let mut found_ellipsis = false;
1938        for x in 0..40u16 {
1939            if let Some(cell) = frame.buffer.get(x, result_y)
1940                && cell.content.as_char() == Some('\u{2026}')
1941            {
1942                found_ellipsis = true;
1943                break;
1944            }
1945        }
1946        assert!(
1947            found_ellipsis,
1948            "Long titles should be truncated with '…' ellipsis"
1949        );
1950    }
1951
1952    #[test]
1953    fn keyboard_only_flow_end_to_end() {
1954        let mut palette = CommandPalette::new();
1955        palette.register("Open File", Some("Open a file from disk"), &["file"]);
1956        palette.register("Save File", Some("Save current file"), &["file"]);
1957        palette.register("Git: Commit", Some("Commit changes"), &["git"]);
1958
1959        // Step 1: Open with Ctrl+P
1960        let ctrl_p = Event::Key(KeyEvent {
1961            code: KeyCode::Char('p'),
1962            modifiers: Modifiers::CTRL,
1963            kind: KeyEventKind::Press,
1964        });
1965        let _ = palette.handle_event(&ctrl_p);
1966        assert!(palette.is_visible());
1967        assert_eq!(palette.result_count(), 3);
1968
1969        // Step 2: Type query to filter
1970        for ch in "git".chars() {
1971            let event = Event::Key(KeyEvent {
1972                code: KeyCode::Char(ch),
1973                modifiers: Modifiers::empty(),
1974                kind: KeyEventKind::Press,
1975            });
1976            let _ = palette.handle_event(&event);
1977        }
1978        assert!(palette.result_count() >= 1);
1979
1980        // Step 3: Navigate down (in case selected isn't the right one)
1981        let down = Event::Key(KeyEvent {
1982            code: KeyCode::Down,
1983            modifiers: Modifiers::empty(),
1984            kind: KeyEventKind::Press,
1985        });
1986        let _ = palette.handle_event(&down);
1987
1988        // Step 4: Navigate back up
1989        let up = Event::Key(KeyEvent {
1990            code: KeyCode::Up,
1991            modifiers: Modifiers::empty(),
1992            kind: KeyEventKind::Press,
1993        });
1994        let _ = palette.handle_event(&up);
1995        assert_eq!(palette.selected_index(), 0);
1996
1997        // Step 5: Execute with Enter
1998        let enter = Event::Key(KeyEvent {
1999            code: KeyCode::Enter,
2000            modifiers: Modifiers::empty(),
2001            kind: KeyEventKind::Press,
2002        });
2003        let result = palette.handle_event(&enter);
2004        assert!(matches!(result, Some(PaletteAction::Execute(_))));
2005        assert!(!palette.is_visible());
2006    }
2007
2008    #[test]
2009    fn no_focus_trap_esc_always_dismisses() {
2010        let mut palette = CommandPalette::new();
2011        palette.register("Alpha", None, &[]);
2012        palette.open();
2013
2014        // Type some query
2015        for ch in "xyz".chars() {
2016            let event = Event::Key(KeyEvent {
2017                code: KeyCode::Char(ch),
2018                modifiers: Modifiers::empty(),
2019                kind: KeyEventKind::Press,
2020            });
2021            let _ = palette.handle_event(&event);
2022        }
2023        assert_eq!(palette.result_count(), 0); // no matches
2024
2025        // Esc should still dismiss even with no results
2026        let esc = Event::Key(KeyEvent {
2027            code: KeyCode::Escape,
2028            modifiers: Modifiers::empty(),
2029            kind: KeyEventKind::Press,
2030        });
2031        let result = palette.handle_event(&esc);
2032        assert_eq!(result, Some(PaletteAction::Dismiss));
2033        assert!(!palette.is_visible());
2034    }
2035
2036    #[test]
2037    fn unicode_query_renders_correctly() {
2038        use ftui_render::grapheme_pool::GraphemePool;
2039
2040        let mut palette = CommandPalette::new();
2041        palette.register("Café Menu", None, &["food"]);
2042        palette.open();
2043        palette.set_query("café");
2044
2045        assert_eq!(palette.query(), "café");
2046
2047        let area = Rect::from_size(60, 10);
2048        let mut pool = GraphemePool::new();
2049        let mut frame = Frame::new(60, 10, &mut pool);
2050        palette.render(area, &mut frame);
2051
2052        // The query "café" should be visible in the input area
2053        // palette_y ≈ 1 (10/6), query line is at palette_y + 1 = 2
2054        let palette_y = area.y + area.height / 6;
2055        let input_y = palette_y + 1;
2056
2057        // Find the query characters in the input row
2058        let mut found_query_chars = 0;
2059        for x in 0..60u16 {
2060            if let Some(cell) = frame.buffer.get(x, input_y)
2061                && let Some(ch) = cell.content.as_char()
2062                && "café".contains(ch)
2063            {
2064                found_query_chars += 1;
2065            }
2066        }
2067        // Should find at least 3 of the 4 characters (c, a, f, é may be grapheme)
2068        assert!(
2069            found_query_chars >= 3,
2070            "Unicode query should render (found {} chars)",
2071            found_query_chars
2072        );
2073    }
2074
2075    #[test]
2076    fn wide_char_query_renders_correctly() {
2077        use ftui_render::grapheme_pool::GraphemePool;
2078
2079        let mut palette = CommandPalette::new();
2080        palette.register("日本語メニュー", None, &["japanese"]);
2081        palette.open();
2082        palette.set_query("日本");
2083
2084        assert_eq!(palette.query(), "日本");
2085
2086        let area = Rect::from_size(60, 10);
2087        let mut pool = GraphemePool::new();
2088        let mut frame = Frame::new(60, 10, &mut pool);
2089        palette.render(area, &mut frame);
2090
2091        // Wide characters should be rendered (each takes 2 columns)
2092        let palette_y = area.y + area.height / 6;
2093        let input_y = palette_y + 1;
2094
2095        // Find grapheme cells in the input row
2096        let mut found_grapheme = false;
2097        for x in 0..60u16 {
2098            if let Some(cell) = frame.buffer.get(x, input_y)
2099                && cell.content.is_grapheme()
2100            {
2101                found_grapheme = true;
2102                break;
2103            }
2104        }
2105        assert!(
2106            found_grapheme,
2107            "Wide character query should render as graphemes"
2108        );
2109    }
2110
2111    #[test]
2112    fn wcag_aa_contrast_ratios() {
2113        // Verify the default style colors meet WCAG AA contrast requirements.
2114        // WCAG AA requires >= 4.5:1 for normal text.
2115        let style = PaletteStyle::default();
2116        let bg = PackedRgba::rgb(30, 30, 40);
2117
2118        // Helper: relative luminance per WCAG 2.0
2119        fn relative_luminance(color: PackedRgba) -> f64 {
2120            fn linearize(c: u8) -> f64 {
2121                let v = c as f64 / 255.0;
2122                if v <= 0.04045 {
2123                    v / 12.92
2124                } else {
2125                    ((v + 0.055) / 1.055).powf(2.4)
2126                }
2127            }
2128            let r = linearize(color.r());
2129            let g = linearize(color.g());
2130            let b = linearize(color.b());
2131            0.2126 * r + 0.7152 * g + 0.0722 * b
2132        }
2133
2134        fn contrast_ratio(fg: PackedRgba, bg: PackedRgba) -> f64 {
2135            let l1 = relative_luminance(fg);
2136            let l2 = relative_luminance(bg);
2137            let (lighter, darker) = if l1 > l2 { (l1, l2) } else { (l2, l1) };
2138            (lighter + 0.05) / (darker + 0.05)
2139        }
2140
2141        // Item text on palette background
2142        let item_fg = style.item.fg.unwrap();
2143        let item_ratio = contrast_ratio(item_fg, bg);
2144        assert!(
2145            item_ratio >= 4.5,
2146            "Item text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2147            item_ratio
2148        );
2149
2150        // Selected text on selected background
2151        let sel_fg = style.item_selected.fg.unwrap();
2152        let sel_bg = style.item_selected.bg.unwrap();
2153        let sel_ratio = contrast_ratio(sel_fg, sel_bg);
2154        assert!(
2155            sel_ratio >= 4.5,
2156            "Selected text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2157            sel_ratio
2158        );
2159
2160        // Match highlight on palette background
2161        let hl_fg = style.match_highlight.fg.unwrap();
2162        let hl_ratio = contrast_ratio(hl_fg, bg);
2163        assert!(
2164            hl_ratio >= 4.5,
2165            "Highlight text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2166            hl_ratio
2167        );
2168
2169        // Description text on palette background
2170        let desc_fg = style.description.fg.unwrap();
2171        let desc_ratio = contrast_ratio(desc_fg, bg);
2172        assert!(
2173            desc_ratio >= 4.5,
2174            "Description text contrast {:.1}:1 < 4.5:1 (WCAG AA)",
2175            desc_ratio
2176        );
2177    }
2178
2179    #[test]
2180    fn action_item_builder_fields() {
2181        let item = ActionItem::new("my_id", "My Action")
2182            .with_description("A description")
2183            .with_tags(&["tag1", "tag2"])
2184            .with_category("Category");
2185
2186        assert_eq!(item.id, "my_id");
2187        assert_eq!(item.title, "My Action");
2188        assert_eq!(item.description.as_deref(), Some("A description"));
2189        assert_eq!(item.tags, vec!["tag1", "tag2"]);
2190        assert_eq!(item.category.as_deref(), Some("Category"));
2191    }
2192
2193    #[test]
2194    fn action_item_defaults_none() {
2195        let item = ActionItem::new("id", "title");
2196        assert!(item.description.is_none());
2197        assert!(item.tags.is_empty());
2198        assert!(item.category.is_none());
2199    }
2200
2201    #[test]
2202    fn palette_action_equality() {
2203        assert_eq!(PaletteAction::Dismiss, PaletteAction::Dismiss);
2204        assert_eq!(
2205            PaletteAction::Execute("x".into()),
2206            PaletteAction::Execute("x".into())
2207        );
2208        assert_ne!(PaletteAction::Dismiss, PaletteAction::Execute("x".into()));
2209    }
2210
2211    #[test]
2212    fn match_filter_allows_all() {
2213        assert!(MatchFilter::All.allows(MatchType::Exact));
2214        assert!(MatchFilter::All.allows(MatchType::Prefix));
2215        assert!(MatchFilter::All.allows(MatchType::WordStart));
2216        assert!(MatchFilter::All.allows(MatchType::Substring));
2217        assert!(MatchFilter::All.allows(MatchType::Fuzzy));
2218    }
2219
2220    #[test]
2221    fn match_filter_specific_types() {
2222        assert!(MatchFilter::Exact.allows(MatchType::Exact));
2223        assert!(!MatchFilter::Exact.allows(MatchType::Fuzzy));
2224        assert!(MatchFilter::Fuzzy.allows(MatchType::Fuzzy));
2225        assert!(!MatchFilter::Fuzzy.allows(MatchType::Exact));
2226    }
2227
2228    #[test]
2229    fn palette_default_trait() {
2230        let palette = CommandPalette::default();
2231        assert!(!palette.is_visible());
2232        assert_eq!(palette.action_count(), 0);
2233        assert_eq!(palette.query(), "");
2234    }
2235
2236    #[test]
2237    fn with_max_visible_builder() {
2238        let palette = CommandPalette::new().with_max_visible(5);
2239        // Verify by registering more than 5 items and checking rendering doesn't panic
2240        let mut palette = palette;
2241        for i in 0..10 {
2242            palette.register(format!("Action {i}"), None, &[]);
2243        }
2244        palette.open();
2245        assert_eq!(palette.result_count(), 10);
2246    }
2247
2248    #[test]
2249    fn scorer_stats_accessible() {
2250        let mut palette = CommandPalette::new();
2251        palette.register("Alpha", None, &[]);
2252        palette.open();
2253        palette.set_query("a");
2254        let stats = palette.scorer_stats();
2255        assert!(stats.full_scans + stats.incremental_scans >= 1);
2256    }
2257
2258    #[test]
2259    fn selected_match_returns_match() {
2260        let mut palette = CommandPalette::new();
2261        palette.register("Hello World", None, &[]);
2262        palette.open();
2263        palette.set_query("hello");
2264        let m = palette.selected_match();
2265        assert!(m.is_some());
2266        assert_eq!(m.unwrap().action.title, "Hello World");
2267    }
2268
2269    #[test]
2270    fn results_iterator_returns_matches() {
2271        let mut palette = CommandPalette::new();
2272        palette.register("Alpha", None, &[]);
2273        palette.register("Beta", None, &[]);
2274        palette.open();
2275        let count = palette.results().count();
2276        assert_eq!(count, 2);
2277    }
2278
2279    #[test]
2280    fn set_match_filter_narrows_results() {
2281        let mut palette = CommandPalette::new();
2282        palette.register("Open File", None, &[]);
2283        palette.register("Save File", None, &[]);
2284        palette.open();
2285        palette.set_query("open");
2286        let before = palette.result_count();
2287
2288        // Setting to Exact should narrow or keep results
2289        palette.set_match_filter(MatchFilter::Exact);
2290        let after = palette.result_count();
2291        assert!(after <= before);
2292    }
2293
2294    #[test]
2295    fn prefix_filter_uses_art_candidate_set() {
2296        let mut palette = CommandPalette::new();
2297        for idx in 0..40 {
2298            palette.register_action(ActionItem::new(
2299                format!("file-{idx:02}"),
2300                format!("File Command {idx:02}"),
2301            ));
2302        }
2303        for idx in 0..80 {
2304            palette.register_action(ActionItem::new(
2305                format!("edit-{idx:02}"),
2306                format!("Edit Command {idx:02}"),
2307            ));
2308        }
2309
2310        palette.open();
2311        palette.set_match_filter(MatchFilter::Prefix);
2312
2313        let before = palette.scorer_stats().total_evaluated;
2314        palette.set_query("file");
2315        let evaluated_for_query = palette.scorer_stats().total_evaluated - before;
2316
2317        assert_eq!(palette.result_count(), 40);
2318        assert_eq!(evaluated_for_query, 40);
2319    }
2320
2321    #[test]
2322    fn prefix_filter_preserves_duplicate_titles() {
2323        let mut palette = CommandPalette::new();
2324        palette.register_action(ActionItem::new("open-file-a", "Open File"));
2325        palette.register_action(ActionItem::new("open-file-b", "Open File"));
2326        palette.register_action(ActionItem::new("open-folder", "Open Folder"));
2327
2328        palette.open();
2329        palette.set_match_filter(MatchFilter::Prefix);
2330        palette.set_query("open f");
2331
2332        let ids: Vec<&str> = palette.results().map(|m| m.action.id.as_str()).collect();
2333        assert_eq!(ids.len(), 3);
2334        assert!(ids.contains(&"open-file-a"));
2335        assert!(ids.contains(&"open-file-b"));
2336        assert!(ids.contains(&"open-folder"));
2337    }
2338
2339    #[test]
2340    fn prefix_filter_does_not_poison_all_match_cache() {
2341        let mut palette = CommandPalette::new();
2342        palette.register("Open Preferences", None, &[]);
2343        palette.register("Preferences: Open", None, &[]);
2344
2345        palette.open();
2346        palette.set_match_filter(MatchFilter::Prefix);
2347        palette.set_query("pref");
2348        assert_eq!(palette.result_count(), 1);
2349
2350        palette.set_match_filter(MatchFilter::All);
2351        let titles: Vec<&str> = palette.results().map(|m| m.action.title.as_str()).collect();
2352        assert!(titles.contains(&"Open Preferences"));
2353        assert!(titles.contains(&"Preferences: Open"));
2354    }
2355
2356    #[test]
2357    fn replace_actions_rebuilds_prefix_index() {
2358        let mut palette = CommandPalette::new();
2359        palette.register_action(ActionItem::new("open-file", "Open File"));
2360
2361        palette.open();
2362        palette.set_match_filter(MatchFilter::Prefix);
2363        palette.set_query("open");
2364        assert_eq!(palette.result_count(), 1);
2365
2366        palette.replace_actions(vec![ActionItem::new("save-file", "Save File")]);
2367        assert_eq!(palette.result_count(), 0);
2368
2369        palette.set_query("save");
2370        assert_eq!(palette.result_count(), 1);
2371        assert_eq!(
2372            palette.selected_action().map(|action| action.id.as_str()),
2373            Some("save-file")
2374        );
2375    }
2376
2377    #[test]
2378    fn enter_with_no_results_returns_none() {
2379        let mut palette = CommandPalette::new();
2380        palette.register("Alpha", None, &[]);
2381        palette.open();
2382        palette.set_query("zzzznotfound");
2383        assert_eq!(palette.result_count(), 0);
2384
2385        let enter = Event::Key(KeyEvent {
2386            code: KeyCode::Enter,
2387            modifiers: Modifiers::empty(),
2388            kind: KeyEventKind::Press,
2389        });
2390        let result = palette.handle_event(&enter);
2391        assert!(result.is_none());
2392    }
2393
2394    #[cfg(feature = "tracing")]
2395    #[test]
2396    fn telemetry_emits_in_order() {
2397        use std::sync::{Arc, Mutex};
2398        use tracing::Subscriber;
2399        use tracing_subscriber::Layer;
2400        use tracing_subscriber::filter::Targets;
2401        use tracing_subscriber::layer::{Context, SubscriberExt};
2402
2403        #[derive(Default)]
2404        struct EventCapture {
2405            events: Arc<Mutex<Vec<String>>>,
2406        }
2407
2408        impl<S> Layer<S> for EventCapture
2409        where
2410            S: Subscriber,
2411        {
2412            fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
2413                use tracing::field::{Field, Visit};
2414
2415                struct EventVisitor {
2416                    name: Option<String>,
2417                }
2418
2419                impl Visit for EventVisitor {
2420                    fn record_str(&mut self, field: &Field, value: &str) {
2421                        if field.name() == "event" {
2422                            self.name = Some(value.to_string());
2423                        }
2424                    }
2425
2426                    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
2427                        if field.name() == "event" {
2428                            let raw = format!("{value:?}");
2429                            let normalized = raw.trim_matches('\"').to_string();
2430                            self.name = Some(normalized);
2431                        }
2432                    }
2433                }
2434
2435                let mut visitor = EventVisitor { name: None };
2436                event.record(&mut visitor);
2437                if let Some(name) = visitor.name {
2438                    self.events
2439                        .lock()
2440                        .expect("lock telemetry events")
2441                        .push(name);
2442                }
2443            }
2444        }
2445
2446        let events = Arc::new(Mutex::new(Vec::new()));
2447        let capture = EventCapture {
2448            events: Arc::clone(&events),
2449        };
2450        let _trace_test_guard = crate::tracing_test_support::acquire();
2451
2452        let subscriber = tracing_subscriber::registry()
2453            .with(capture)
2454            .with(Targets::new().with_target(TELEMETRY_TARGET, tracing::Level::INFO));
2455        let _guard = tracing::subscriber::set_default(subscriber);
2456
2457        // Rebuild interest cache before each step that emits tracing events.
2458        // Parallel workspace tests can poison the global callsite interest
2459        // cache between our operations, causing `info!` macros to short-circuit.
2460        let mut palette = CommandPalette::new();
2461        palette.register("Alpha", None, &[]);
2462        tracing::callsite::rebuild_interest_cache();
2463        palette.open();
2464
2465        let a = Event::Key(KeyEvent {
2466            code: KeyCode::Char('a'),
2467            modifiers: Modifiers::empty(),
2468            kind: KeyEventKind::Press,
2469        });
2470        tracing::callsite::rebuild_interest_cache();
2471        let _ = palette.handle_event(&a);
2472
2473        let enter = Event::Key(KeyEvent {
2474            code: KeyCode::Enter,
2475            modifiers: Modifiers::empty(),
2476            kind: KeyEventKind::Press,
2477        });
2478        tracing::callsite::rebuild_interest_cache();
2479        let _ = palette.handle_event(&enter);
2480        tracing::callsite::rebuild_interest_cache();
2481        palette.close();
2482
2483        let events = events.lock().expect("lock telemetry events");
2484        let open_idx = events
2485            .iter()
2486            .position(|e| e == "palette_opened")
2487            .expect("palette_opened missing");
2488        let query_idx = events
2489            .iter()
2490            .position(|e| e == "palette_query_updated")
2491            .expect("palette_query_updated missing");
2492        let exec_idx = events
2493            .iter()
2494            .position(|e| e == "palette_action_executed")
2495            .expect("palette_action_executed missing");
2496        let close_idx = events
2497            .iter()
2498            .position(|e| e == "palette_closed")
2499            .expect("palette_closed missing");
2500
2501        assert!(open_idx < query_idx);
2502        assert!(query_idx < exec_idx);
2503        assert!(exec_idx < close_idx);
2504    }
2505
2506    // -----------------------------------------------------------------------
2507    // Edge-case tests (bd-2svld)
2508    // -----------------------------------------------------------------------
2509
2510    #[test]
2511    fn compute_word_starts_empty() {
2512        let starts = compute_word_starts("");
2513        assert!(starts.is_empty());
2514    }
2515
2516    #[test]
2517    fn compute_word_starts_single_word() {
2518        let starts = compute_word_starts("hello");
2519        assert_eq!(starts, vec![0]);
2520    }
2521
2522    #[test]
2523    fn compute_word_starts_spaces() {
2524        let starts = compute_word_starts("open file now");
2525        assert_eq!(starts, vec![0, 5, 10]);
2526    }
2527
2528    #[test]
2529    fn compute_word_starts_hyphen_underscore() {
2530        let starts = compute_word_starts("git-commit_push");
2531        // Positions: g=0, c=4, p=11
2532        assert_eq!(starts, vec![0, 4, 11]);
2533    }
2534
2535    #[test]
2536    fn compute_word_starts_all_separators() {
2537        let starts = compute_word_starts("- _");
2538        // '-' at 0 is word start (i==0), ' ' at 1 follows '-' so word start,
2539        // '_' at 2 follows ' ' so word start
2540        assert_eq!(starts, vec![0, 1, 2]);
2541    }
2542
2543    #[test]
2544    fn backspace_on_empty_query_is_noop() {
2545        let mut palette = CommandPalette::new();
2546        palette.register("Alpha", None, &[]);
2547        palette.open();
2548        assert_eq!(palette.query(), "");
2549
2550        let bs = Event::Key(KeyEvent {
2551            code: KeyCode::Backspace,
2552            modifiers: Modifiers::empty(),
2553            kind: KeyEventKind::Press,
2554        });
2555        let _ = palette.handle_event(&bs);
2556        assert_eq!(palette.query(), "");
2557        // Results should still show all items
2558        assert_eq!(palette.result_count(), 1);
2559    }
2560
2561    #[test]
2562    fn ctrl_a_moves_cursor_to_start() {
2563        let mut palette = CommandPalette::new();
2564        palette.register("Alpha", None, &[]);
2565        palette.open();
2566
2567        // Type "abc"
2568        for ch in "abc".chars() {
2569            let event = Event::Key(KeyEvent {
2570                code: KeyCode::Char(ch),
2571                modifiers: Modifiers::empty(),
2572                kind: KeyEventKind::Press,
2573            });
2574            let _ = palette.handle_event(&event);
2575        }
2576        assert_eq!(palette.query(), "abc");
2577
2578        let ctrl_a = Event::Key(KeyEvent {
2579            code: KeyCode::Char('a'),
2580            modifiers: Modifiers::CTRL,
2581            kind: KeyEventKind::Press,
2582        });
2583        let _ = palette.handle_event(&ctrl_a);
2584        // Cursor should move to 0 but query unchanged
2585        assert_eq!(palette.query(), "abc");
2586    }
2587
2588    #[test]
2589    fn key_release_events_ignored() {
2590        let mut palette = CommandPalette::new();
2591        palette.register("Alpha", None, &[]);
2592        palette.open();
2593
2594        let release = Event::Key(KeyEvent {
2595            code: KeyCode::Char('x'),
2596            modifiers: Modifiers::empty(),
2597            kind: KeyEventKind::Release,
2598        });
2599        let result = palette.handle_event(&release);
2600        assert!(result.is_none());
2601        assert_eq!(palette.query(), "");
2602    }
2603
2604    #[test]
2605    fn resize_event_ignored() {
2606        let mut palette = CommandPalette::new();
2607        palette.open();
2608
2609        let resize = Event::Resize {
2610            width: 80,
2611            height: 24,
2612        };
2613        let result = palette.handle_event(&resize);
2614        assert!(result.is_none());
2615    }
2616
2617    #[test]
2618    fn is_essential_returns_true() {
2619        let palette = CommandPalette::new();
2620        assert!(palette.is_essential());
2621    }
2622
2623    #[test]
2624    fn render_too_small_area_noop() {
2625        use ftui_render::grapheme_pool::GraphemePool;
2626
2627        let mut palette = CommandPalette::new();
2628        palette.register("Alpha", None, &[]);
2629        palette.open();
2630
2631        // Width < 10
2632        let area = Rect::new(0, 0, 9, 10);
2633        let mut pool = GraphemePool::new();
2634        let mut frame = Frame::new(20, 20, &mut pool);
2635        palette.render(area, &mut frame);
2636        // Should not panic, cursor not set
2637        assert!(frame.cursor_position.is_none());
2638    }
2639
2640    #[test]
2641    fn render_too_short_area_noop() {
2642        use ftui_render::grapheme_pool::GraphemePool;
2643
2644        let mut palette = CommandPalette::new();
2645        palette.register("Alpha", None, &[]);
2646        palette.open();
2647
2648        // Height < 5
2649        let area = Rect::new(0, 0, 60, 4);
2650        let mut pool = GraphemePool::new();
2651        let mut frame = Frame::new(60, 10, &mut pool);
2652        palette.render(area, &mut frame);
2653        assert!(frame.cursor_position.is_none());
2654    }
2655
2656    #[test]
2657    fn render_hidden_palette_noop() {
2658        use ftui_render::grapheme_pool::GraphemePool;
2659
2660        let palette = CommandPalette::new();
2661        assert!(!palette.is_visible());
2662
2663        let area = Rect::from_size(60, 10);
2664        let mut pool = GraphemePool::new();
2665        let mut frame = Frame::new(60, 10, &mut pool);
2666        palette.render(area, &mut frame);
2667        assert!(frame.cursor_position.is_none());
2668    }
2669
2670    #[test]
2671    fn render_empty_palette_shows_no_actions_hint() {
2672        use ftui_render::grapheme_pool::GraphemePool;
2673
2674        let mut palette = CommandPalette::new();
2675        // No actions registered
2676        palette.open();
2677
2678        let area = Rect::from_size(60, 15);
2679        let mut pool = GraphemePool::new();
2680        let mut frame = Frame::new(60, 15, &mut pool);
2681        palette.render(area, &mut frame);
2682
2683        // Should show "No actions registered" somewhere in the results area
2684        let palette_y = area.y + area.height / 6;
2685        let result_y = palette_y + 2;
2686        let mut found_n = false;
2687        for x in 0..60u16 {
2688            if let Some(cell) = frame.buffer.get(x, result_y)
2689                && cell.content.as_char() == Some('N')
2690            {
2691                found_n = true;
2692                break;
2693            }
2694        }
2695        assert!(found_n, "Should render 'No actions registered' hint");
2696    }
2697
2698    #[test]
2699    fn render_query_no_results_shows_hint() {
2700        use ftui_render::grapheme_pool::GraphemePool;
2701
2702        let mut palette = CommandPalette::new();
2703        palette.register("Alpha", None, &[]);
2704        palette.open();
2705        palette.set_query("zzzznotfound");
2706        assert_eq!(palette.result_count(), 0);
2707
2708        let area = Rect::from_size(60, 15);
2709        let mut pool = GraphemePool::new();
2710        let mut frame = Frame::new(60, 15, &mut pool);
2711        palette.render(area, &mut frame);
2712
2713        // Should show "No results"
2714        let palette_y = area.y + area.height / 6;
2715        let result_y = palette_y + 2;
2716        let mut found_n = false;
2717        for x in 0..60u16 {
2718            if let Some(cell) = frame.buffer.get(x, result_y)
2719                && cell.content.as_char() == Some('N')
2720            {
2721                found_n = true;
2722                break;
2723            }
2724        }
2725        assert!(found_n, "Should render 'No results' hint");
2726    }
2727
2728    #[test]
2729    fn render_with_category_badge() {
2730        use ftui_render::grapheme_pool::GraphemePool;
2731
2732        let mut palette = CommandPalette::new();
2733        let item = ActionItem::new("git_commit", "Commit Changes").with_category("Git");
2734        palette.register_action(item);
2735        palette.open();
2736
2737        let area = Rect::from_size(80, 15);
2738        let mut pool = GraphemePool::new();
2739        let mut frame = Frame::new(80, 15, &mut pool);
2740        palette.render(area, &mut frame);
2741
2742        // Should render "[Git] " badge - look for '[' in results area
2743        let palette_y = area.y + area.height / 6;
2744        let result_y = palette_y + 2;
2745        let mut found_bracket = false;
2746        for x in 0..80u16 {
2747            if let Some(cell) = frame.buffer.get(x, result_y)
2748                && cell.content.as_char() == Some('[')
2749            {
2750                found_bracket = true;
2751                break;
2752            }
2753        }
2754        assert!(found_bracket, "Should render category badge '[Git]'");
2755    }
2756
2757    #[test]
2758    fn render_with_description_text() {
2759        use ftui_render::grapheme_pool::GraphemePool;
2760
2761        let mut palette = CommandPalette::new();
2762        palette.register("Open File", Some("Opens a file from disk"), &[]);
2763        palette.open();
2764
2765        let area = Rect::from_size(80, 15);
2766        let mut pool = GraphemePool::new();
2767        let mut frame = Frame::new(80, 15, &mut pool);
2768        palette.render(area, &mut frame);
2769
2770        // Description text should appear after the title
2771        let palette_y = area.y + area.height / 6;
2772        let result_y = palette_y + 2;
2773        let mut found_desc_char = false;
2774        // Description starts with 'O' in "Opens..."
2775        for x in 20..80u16 {
2776            if let Some(cell) = frame.buffer.get(x, result_y)
2777                && cell.content.as_char() == Some('O')
2778            {
2779                found_desc_char = true;
2780                break;
2781            }
2782        }
2783        assert!(found_desc_char, "Description text should be rendered");
2784    }
2785
2786    #[test]
2787    fn open_resets_previous_state() {
2788        let mut palette = CommandPalette::new();
2789        palette.register("Alpha", None, &[]);
2790        palette.register("Beta", None, &[]);
2791        palette.open();
2792        palette.set_query("Alpha");
2793
2794        // Navigate down
2795        let down = Event::Key(KeyEvent {
2796            code: KeyCode::Down,
2797            modifiers: Modifiers::empty(),
2798            kind: KeyEventKind::Press,
2799        });
2800        let _ = palette.handle_event(&down);
2801
2802        // Re-open should reset everything
2803        palette.open();
2804        assert_eq!(palette.query(), "");
2805        assert_eq!(palette.selected_index(), 0);
2806        assert_eq!(palette.result_count(), 2);
2807    }
2808
2809    #[test]
2810    fn set_match_filter_same_value_is_noop() {
2811        let mut palette = CommandPalette::new();
2812        palette.register("Alpha", None, &[]);
2813        palette.open();
2814        palette.set_query("alpha");
2815
2816        palette.set_match_filter(MatchFilter::All);
2817        let count1 = palette.result_count();
2818        // Setting same filter again — should not change anything
2819        palette.set_match_filter(MatchFilter::All);
2820        assert_eq!(palette.result_count(), count1);
2821    }
2822
2823    #[test]
2824    fn generation_increments_on_register() {
2825        let mut palette = CommandPalette::new();
2826        palette.register("A", None, &[]);
2827        palette.register("B", None, &[]);
2828        // Can't read generation directly, but replace_actions also bumps it
2829        // and invalidates scorer — verify it doesn't panic
2830        palette.replace_actions(vec![ActionItem::new("c", "C")]);
2831        palette.open();
2832        assert_eq!(palette.action_count(), 1);
2833    }
2834
2835    #[test]
2836    fn enable_evidence_tracking_toggle() {
2837        let mut palette = CommandPalette::new();
2838        palette.register("Alpha", None, &[]);
2839        palette.open();
2840
2841        palette.enable_evidence_tracking(true);
2842        palette.set_query("alpha");
2843        assert!(palette.result_count() >= 1);
2844
2845        palette.enable_evidence_tracking(false);
2846        palette.set_query("alpha");
2847        assert!(palette.result_count() >= 1);
2848    }
2849
2850    #[test]
2851    fn register_chaining() {
2852        let mut palette = CommandPalette::new();
2853        palette
2854            .register("A", None, &[])
2855            .register("B", None, &[])
2856            .register("C", Some("desc"), &["tag"]);
2857        assert_eq!(palette.action_count(), 3);
2858    }
2859
2860    #[test]
2861    fn register_action_chaining() {
2862        let mut palette = CommandPalette::new();
2863        palette
2864            .register_action(ActionItem::new("a", "A"))
2865            .register_action(ActionItem::new("b", "B"));
2866        assert_eq!(palette.action_count(), 2);
2867    }
2868
2869    #[test]
2870    fn page_up_down_navigation() {
2871        let mut palette = CommandPalette::new().with_max_visible(3);
2872        for i in 0..10 {
2873            palette.register(format!("Action {i}"), None, &[]);
2874        }
2875        palette.open();
2876        assert_eq!(palette.selected_index(), 0);
2877
2878        let pgdn = Event::Key(KeyEvent {
2879            code: KeyCode::PageDown,
2880            modifiers: Modifiers::empty(),
2881            kind: KeyEventKind::Press,
2882        });
2883        let _ = palette.handle_event(&pgdn);
2884        assert_eq!(palette.selected_index(), 3); // 0 + max_visible
2885
2886        let _ = palette.handle_event(&pgdn);
2887        assert_eq!(palette.selected_index(), 6);
2888
2889        let _ = palette.handle_event(&pgdn);
2890        assert_eq!(palette.selected_index(), 9); // clamped to last
2891
2892        let pgup = Event::Key(KeyEvent {
2893            code: KeyCode::PageUp,
2894            modifiers: Modifiers::empty(),
2895            kind: KeyEventKind::Press,
2896        });
2897        let _ = palette.handle_event(&pgup);
2898        assert_eq!(palette.selected_index(), 6); // 9 - 3
2899
2900        let _ = palette.handle_event(&pgup);
2901        assert_eq!(palette.selected_index(), 3);
2902
2903        let _ = palette.handle_event(&pgup);
2904        assert_eq!(palette.selected_index(), 0);
2905    }
2906
2907    #[test]
2908    fn page_down_empty_results_is_noop() {
2909        let mut palette = CommandPalette::new();
2910        palette.open();
2911        assert_eq!(palette.result_count(), 0);
2912
2913        let pgdn = Event::Key(KeyEvent {
2914            code: KeyCode::PageDown,
2915            modifiers: Modifiers::empty(),
2916            kind: KeyEventKind::Press,
2917        });
2918        let _ = palette.handle_event(&pgdn);
2919        assert_eq!(palette.selected_index(), 0);
2920    }
2921
2922    #[test]
2923    fn end_empty_results_is_noop() {
2924        let mut palette = CommandPalette::new();
2925        palette.open();
2926        assert_eq!(palette.result_count(), 0);
2927
2928        let end = Event::Key(KeyEvent {
2929            code: KeyCode::End,
2930            modifiers: Modifiers::empty(),
2931            kind: KeyEventKind::Press,
2932        });
2933        let _ = palette.handle_event(&end);
2934        assert_eq!(palette.selected_index(), 0);
2935    }
2936
2937    #[test]
2938    fn down_empty_results_is_noop() {
2939        let mut palette = CommandPalette::new();
2940        palette.open();
2941        assert_eq!(palette.result_count(), 0);
2942
2943        let down = Event::Key(KeyEvent {
2944            code: KeyCode::Down,
2945            modifiers: Modifiers::empty(),
2946            kind: KeyEventKind::Press,
2947        });
2948        let _ = palette.handle_event(&down);
2949        assert_eq!(palette.selected_index(), 0);
2950    }
2951
2952    #[test]
2953    fn selected_action_none_when_empty() {
2954        let mut palette = CommandPalette::new();
2955        palette.open();
2956        assert!(palette.selected_action().is_none());
2957        assert!(palette.selected_match().is_none());
2958    }
2959
2960    #[test]
2961    fn results_iterator_empty() {
2962        let mut palette = CommandPalette::new();
2963        palette.open();
2964        assert_eq!(palette.results().count(), 0);
2965    }
2966
2967    #[test]
2968    fn scroll_adjust_keeps_selection_visible() {
2969        let mut palette = CommandPalette::new().with_max_visible(3);
2970        for i in 0..10 {
2971            palette.register(format!("Action {i}"), None, &[]);
2972        }
2973        palette.open();
2974
2975        let end = Event::Key(KeyEvent {
2976            code: KeyCode::End,
2977            modifiers: Modifiers::empty(),
2978            kind: KeyEventKind::Press,
2979        });
2980        let _ = palette.handle_event(&end);
2981        assert_eq!(palette.selected_index(), 9);
2982        // scroll_offset should have adjusted so item 9 is visible
2983        // (scroll_offset = selected + 1 - max_visible = 9 + 1 - 3 = 7)
2984
2985        let home = Event::Key(KeyEvent {
2986            code: KeyCode::Home,
2987            modifiers: Modifiers::empty(),
2988            kind: KeyEventKind::Press,
2989        });
2990        let _ = palette.handle_event(&home);
2991        assert_eq!(palette.selected_index(), 0);
2992    }
2993
2994    #[test]
2995    fn update_filtered_clamps_scroll_offset_after_results_shrink() {
2996        let mut palette = CommandPalette::new().with_max_visible(3);
2997        for i in 0..10 {
2998            palette.register(format!("Action {i}"), None, &[]);
2999        }
3000        palette.open();
3001
3002        let end = Event::Key(KeyEvent {
3003            code: KeyCode::End,
3004            modifiers: Modifiers::empty(),
3005            kind: KeyEventKind::Press,
3006        });
3007        let _ = palette.handle_event(&end);
3008        assert!(palette.scroll_offset > 0);
3009
3010        palette.actions.truncate(1);
3011        palette.rebuild_title_cache();
3012        palette.generation = palette.generation.wrapping_add(1);
3013        palette.update_filtered(false);
3014
3015        assert_eq!(palette.result_count(), 1);
3016        assert_eq!(palette.selected, 0);
3017        assert_eq!(palette.scroll_offset, 0);
3018        assert_eq!(
3019            palette
3020                .selected_action()
3021                .map(|action| action.title.as_str()),
3022            Some("Action 0")
3023        );
3024    }
3025
3026    #[test]
3027    fn action_item_clone() {
3028        let item = ActionItem::new("id", "Title")
3029            .with_description("Desc")
3030            .with_tags(&["a", "b"])
3031            .with_category("Cat");
3032        let cloned = item.clone();
3033        assert_eq!(cloned.id, "id");
3034        assert_eq!(cloned.title, "Title");
3035        assert_eq!(cloned.description.as_deref(), Some("Desc"));
3036        assert_eq!(cloned.tags, vec!["a", "b"]);
3037        assert_eq!(cloned.category.as_deref(), Some("Cat"));
3038    }
3039
3040    #[test]
3041    fn action_item_debug() {
3042        let item = ActionItem::new("id", "Title");
3043        let debug = format!("{:?}", item);
3044        assert!(debug.contains("ActionItem"));
3045        assert!(debug.contains("Title"));
3046    }
3047
3048    #[test]
3049    fn palette_action_clone_and_debug() {
3050        let exec = PaletteAction::Execute("test".into());
3051        let cloned = exec.clone();
3052        assert_eq!(exec, cloned);
3053
3054        let dismiss = PaletteAction::Dismiss;
3055        let debug = format!("{:?}", dismiss);
3056        assert!(debug.contains("Dismiss"));
3057    }
3058
3059    #[test]
3060    fn match_filter_traits() {
3061        // Debug
3062        let f = MatchFilter::Fuzzy;
3063        let debug = format!("{:?}", f);
3064        assert!(debug.contains("Fuzzy"));
3065
3066        // Clone + Copy
3067        let f2 = f;
3068        assert_eq!(f, f2);
3069
3070        // PartialEq
3071        assert_eq!(MatchFilter::All, MatchFilter::All);
3072        assert_ne!(MatchFilter::Exact, MatchFilter::Prefix);
3073    }
3074
3075    #[test]
3076    fn match_filter_specific_allows() {
3077        assert!(MatchFilter::Prefix.allows(MatchType::Prefix));
3078        assert!(!MatchFilter::Prefix.allows(MatchType::Exact));
3079        assert!(!MatchFilter::Prefix.allows(MatchType::Substring));
3080
3081        assert!(MatchFilter::WordStart.allows(MatchType::WordStart));
3082        assert!(!MatchFilter::WordStart.allows(MatchType::Fuzzy));
3083
3084        assert!(MatchFilter::Substring.allows(MatchType::Substring));
3085        assert!(!MatchFilter::Substring.allows(MatchType::WordStart));
3086    }
3087
3088    #[test]
3089    fn palette_style_default_has_all_colors() {
3090        let style = PaletteStyle::default();
3091        assert!(style.border.fg.is_some());
3092        assert!(style.input.fg.is_some());
3093        assert!(style.item.fg.is_some());
3094        assert!(style.item_selected.fg.is_some());
3095        assert!(style.item_selected.bg.is_some());
3096        assert!(style.match_highlight.fg.is_some());
3097        assert!(style.description.fg.is_some());
3098        assert!(style.category.fg.is_some());
3099        assert!(style.hint.fg.is_some());
3100    }
3101
3102    #[test]
3103    fn palette_style_debug_and_clone() {
3104        let style = PaletteStyle::default();
3105        let debug = format!("{:?}", style);
3106        assert!(debug.contains("PaletteStyle"));
3107
3108        let cloned = style.clone();
3109        // Verify cloned fields match
3110        assert_eq!(cloned.border.fg, style.border.fg);
3111    }
3112
3113    #[test]
3114    fn with_style_builder() {
3115        let style = PaletteStyle::default();
3116        let palette = CommandPalette::new().with_style(style);
3117        // Should not panic — style applied
3118        assert!(!palette.is_visible());
3119    }
3120
3121    #[test]
3122    fn command_palette_debug() {
3123        let mut palette = CommandPalette::new();
3124        palette.register("Alpha", None, &[]);
3125        let debug = format!("{:?}", palette);
3126        assert!(debug.contains("CommandPalette"));
3127    }
3128
3129    #[test]
3130    fn unrecognized_key_returns_none() {
3131        let mut palette = CommandPalette::new();
3132        palette.open();
3133
3134        let tab = Event::Key(KeyEvent {
3135            code: KeyCode::Tab,
3136            modifiers: Modifiers::empty(),
3137            kind: KeyEventKind::Press,
3138        });
3139        let result = palette.handle_event(&tab);
3140        assert!(result.is_none());
3141    }
3142
3143    #[test]
3144    fn ctrl_p_when_visible_does_not_reopen() {
3145        let mut palette = CommandPalette::new();
3146        palette.register("Alpha", None, &[]);
3147        palette.open();
3148        palette.set_query("test");
3149
3150        // Ctrl+P while visible should be treated as Ctrl+Char('p')
3151        let ctrl_p = Event::Key(KeyEvent {
3152            code: KeyCode::Char('p'),
3153            modifiers: Modifiers::CTRL,
3154            kind: KeyEventKind::Press,
3155        });
3156        let _ = palette.handle_event(&ctrl_p);
3157        // The visible palette handles Ctrl+P as a Ctrl char, not toggling
3158        assert!(palette.is_visible());
3159    }
3160
3161    #[test]
3162    fn close_clears_query_and_results() {
3163        let mut palette = CommandPalette::new();
3164        palette.register("Alpha", None, &[]);
3165        palette.open();
3166        palette.set_query("alpha");
3167        assert!(!palette.query().is_empty());
3168        assert!(palette.result_count() > 0);
3169
3170        palette.close();
3171        assert!(!palette.is_visible());
3172        assert_eq!(palette.query(), "");
3173        assert_eq!(palette.result_count(), 0);
3174    }
3175
3176    #[test]
3177    fn render_cursor_position_set() {
3178        use ftui_render::grapheme_pool::GraphemePool;
3179
3180        let mut palette = CommandPalette::new();
3181        palette.register("Alpha", None, &[]);
3182        palette.open();
3183
3184        let area = Rect::from_size(60, 15);
3185        let mut pool = GraphemePool::new();
3186        let mut frame = Frame::new(60, 15, &mut pool);
3187        palette.render(area, &mut frame);
3188
3189        assert!(frame.cursor_position.is_some());
3190        assert!(frame.cursor_visible);
3191    }
3192
3193    #[test]
3194    fn render_uses_rounded_corners_for_overlay_border() {
3195        use ftui_render::grapheme_pool::GraphemePool;
3196
3197        let mut palette = CommandPalette::new();
3198        palette.register("Alpha", None, &[]);
3199        palette.open();
3200
3201        let area = Rect::from_size(60, 15);
3202        let mut pool = GraphemePool::new();
3203        let mut frame = Frame::new(60, 15, &mut pool);
3204        palette.render(area, &mut frame);
3205
3206        let palette_width = (area.width * 3 / 5).max(30).min(area.width - 2);
3207        let result_rows = palette.result_count().min(palette.max_visible);
3208        let palette_height = (result_rows as u16 + 3)
3209            .max(5)
3210            .min(area.height.saturating_sub(2));
3211        let palette_x = area.x + (area.width.saturating_sub(palette_width)) / 2;
3212        let palette_y = area.y + area.height / 6;
3213        let right = palette_x + palette_width - 1;
3214        let bottom = palette_y + palette_height - 1;
3215
3216        assert_eq!(
3217            frame
3218                .buffer
3219                .get(palette_x, palette_y)
3220                .and_then(|c| c.content.as_char()),
3221            Some('╭')
3222        );
3223        assert_eq!(
3224            frame
3225                .buffer
3226                .get(right, palette_y)
3227                .and_then(|c| c.content.as_char()),
3228            Some('╮')
3229        );
3230        assert_eq!(
3231            frame
3232                .buffer
3233                .get(palette_x, bottom)
3234                .and_then(|c| c.content.as_char()),
3235            Some('╰')
3236        );
3237        assert_eq!(
3238            frame
3239                .buffer
3240                .get(right, bottom)
3241                .and_then(|c| c.content.as_char()),
3242            Some('╯')
3243        );
3244    }
3245
3246    #[test]
3247    fn render_many_items_with_scroll() {
3248        use ftui_render::grapheme_pool::GraphemePool;
3249
3250        let mut palette = CommandPalette::new().with_max_visible(3);
3251        for i in 0..20 {
3252            palette.register(format!("Action {i}"), None, &[]);
3253        }
3254        palette.open();
3255
3256        // Scroll to bottom
3257        let end = Event::Key(KeyEvent {
3258            code: KeyCode::End,
3259            modifiers: Modifiers::empty(),
3260            kind: KeyEventKind::Press,
3261        });
3262        let _ = palette.handle_event(&end);
3263
3264        let area = Rect::from_size(60, 15);
3265        let mut pool = GraphemePool::new();
3266        let mut frame = Frame::new(60, 15, &mut pool);
3267        // Should render without panic even when scrolled
3268        palette.render(area, &mut frame);
3269        assert!(frame.cursor_position.is_some());
3270    }
3271}
3272mod property_tests;