refactor: deduplicate list_core nav/filter, add tests

Extract list_core_apply_nav and list_core_prepare to eliminate
duplicated keydown dispatch and filter/clamp/ID-collect logic
in combobox, command palette, and listbox. Move virtual buffer
constant to list_core.v. Reset highlight on close/dismiss.
Document ASCII-only fuzzy matching. Add 21 unit tests.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mike-ward

_list_core_test.v

@@ -0,0 +1,242 @@
+module gui
+
+fn test_fuzzy_score_exact_match() {
+	assert list_core_fuzzy_score('open', 'open') == 0
+}
+
+fn test_fuzzy_score_subsequence() {
+	s := list_core_fuzzy_score('open file', 'of')
+	assert s > 0
+}
+
+fn test_fuzzy_score_no_match() {
+	assert list_core_fuzzy_score('open', 'z') == -1
+}
+
+fn test_fuzzy_score_empty_query() {
+	assert list_core_fuzzy_score('anything', '') == 0
+}
+
+fn test_fuzzy_score_empty_candidate() {
+	assert list_core_fuzzy_score('', 'q') == -1
+}
+
+fn test_fuzzy_score_case_insensitive() {
+	// 'O' at 0, 'F' at 4 → gap 3.
+	s1 := list_core_fuzzy_score('OpenFile', 'of')
+	s2 := list_core_fuzzy_score('openfile', 'OF')
+	assert s1 >= 0
+	assert s1 == s2
+}
+
+fn test_filter_empty_query() {
+	items := [
+		ListCoreItem{
+			id:    'a'
+			label: 'alpha'
+		},
+		ListCoreItem{
+			id:            'h'
+			label:         'heading'
+			is_subheading: true
+		},
+		ListCoreItem{
+			id:    'b'
+			label: 'beta'
+		},
+	]
+	result := list_core_filter(items, '')
+	assert result.len == 3
+	assert result == [0, 1, 2]
+}
+
+fn test_filter_ranks_by_score() {
+	items := [
+		ListCoreItem{
+			id:    'a'
+			label: 'x_o_p_e_n'
+		},
+		ListCoreItem{
+			id:    'b'
+			label: 'open'
+		},
+	]
+	result := list_core_filter(items, 'open')
+	assert result.len == 2
+	// Exact match (score 0) should come first.
+	assert result[0] == 1
+	assert result[1] == 0
+}
+
+fn test_filter_skips_subheadings() {
+	items := [
+		ListCoreItem{
+			id:            'h'
+			label:         'open group'
+			is_subheading: true
+		},
+		ListCoreItem{
+			id:    'a'
+			label: 'open file'
+		},
+	]
+	result := list_core_filter(items, 'open')
+	assert result.len == 1
+	assert result[0] == 1
+}
+
+fn test_visible_range_empty() {
+	first, last := list_core_visible_range(0, 20, 100, 0)
+	assert first == 0
+	assert last == -1
+}
+
+fn test_visible_range_basic() {
+	first, last := list_core_visible_range(50, 20, 100, 0)
+	assert first == 0
+	assert last > 0
+	assert last < 50
+}
+
+fn test_visible_range_scroll() {
+	first_a, _ := list_core_visible_range(50, 20, 100, 0)
+	first_b, _ := list_core_visible_range(50, 20, 100, -200)
+	assert first_b > first_a
+}
+
+fn test_visible_range_clamp() {
+	_, last := list_core_visible_range(10, 20, 100, -9999)
+	assert last <= 9
+}
+
+fn test_navigate_keys() {
+	assert list_core_navigate(.up, 5, 2) == .move_up
+	assert list_core_navigate(.down, 5, 2) == .move_down
+	assert list_core_navigate(.enter, 5, 2) == .select_item
+	assert list_core_navigate(.escape, 5, 2) == .dismiss
+	assert list_core_navigate(.home, 5, 2) == .first
+	assert list_core_navigate(.end, 5, 2) == .last
+}
+
+fn test_navigate_empty() {
+	assert list_core_navigate(.up, 0, 0) == .none
+	assert list_core_navigate(.down, 0, 0) == .none
+}
+
+fn test_row_height_estimate() {
+	style := TextStyle{
+		size: 14
+	}
+	pad := Padding{
+		top:    2
+		bottom: 3
+	}
+	assert list_core_row_height_estimate(style, pad) == 19
+}
+
+fn test_to_lower_byte() {
+	assert to_lower_byte(u8(0x41)) == u8(0x61) // A -> a
+	assert to_lower_byte(u8(0x5A)) == u8(0x7A) // Z -> z
+	assert to_lower_byte(u8(0x61)) == u8(0x61) // a -> a
+	assert to_lower_byte(u8(0x30)) == u8(0x30) // 0 unchanged
+}
+
+fn test_apply_nav_move_up() {
+	next, changed := list_core_apply_nav(.move_up, 3, 10)
+	assert next == 2
+	assert changed == true
+}
+
+fn test_apply_nav_move_up_at_top() {
+	next, changed := list_core_apply_nav(.move_up, 0, 10)
+	assert next == 0
+	assert changed == false
+}
+
+fn test_apply_nav_move_down() {
+	next, changed := list_core_apply_nav(.move_down, 3, 10)
+	assert next == 4
+	assert changed == true
+}
+
+fn test_apply_nav_move_down_at_bottom() {
+	next, changed := list_core_apply_nav(.move_down, 9, 10)
+	assert next == 9
+	assert changed == false
+}
+
+fn test_apply_nav_first() {
+	next, changed := list_core_apply_nav(.first, 5, 10)
+	assert next == 0
+	assert changed == true
+}
+
+fn test_apply_nav_last() {
+	next, changed := list_core_apply_nav(.last, 0, 10)
+	assert next == 9
+	assert changed == true
+}
+
+fn test_apply_nav_none() {
+	next, changed := list_core_apply_nav(.none, 5, 10)
+	assert next == 5
+	assert changed == false
+}
+
+fn test_prepare_filters_and_clamps() {
+	items := [
+		ListCoreItem{
+			id:    'a'
+			label: 'alpha'
+		},
+		ListCoreItem{
+			id:    'b'
+			label: 'beta'
+		},
+		ListCoreItem{
+			id:    'c'
+			label: 'gamma'
+		},
+	]
+	p := list_core_prepare(items, 'al', 99)
+	assert p.items.len == 1
+	assert p.items[0].id == 'a'
+	assert p.ids == ['a']
+	assert p.hl == 0 // clamped from 99
+}
+
+fn test_prepare_empty_query_returns_all() {
+	items := [
+		ListCoreItem{
+			id:    'a'
+			label: 'alpha'
+		},
+		ListCoreItem{
+			id:    'b'
+			label: 'beta'
+		},
+	]
+	p := list_core_prepare(items, '', 1)
+	assert p.items.len == 2
+	assert p.hl == 1
+}
+
+fn test_prepare_excludes_subheadings_from_ids() {
+	items := [
+		ListCoreItem{
+			id:            'h'
+			label:         'heading'
+			is_subheading: true
+		},
+		ListCoreItem{
+			id:    'a'
+			label: 'alpha'
+		},
+	]
+	p := list_core_prepare(items, '', 0)
+	// Items includes subheading for rendering.
+	assert p.items.len == 2
+	// IDs excludes subheading.
+	assert p.ids.len == 1
+	assert p.ids[0] == 'a'
+}

list_core.v

@@ -3,6 +3,8 @@ module gui
 // list_core.v provides pure functions shared by list_box, select,
 // combobox, and command_palette. No state, no Window dependency.
 
+const list_core_virtual_buffer_rows = 2
+
 // ListCoreItem is the normalized item for the shared list engine.
 // Widgets map their domain types to this before calling core fns.
 @[minify]
@@ -194,7 +196,7 @@ fn list_core_visible_range(item_count int, row_height f32, list_height f32, scro
 	abs_scroll := if scroll_y < 0 { -scroll_y } else { scroll_y }
 	first := int_clamp(int(abs_scroll / row_height), 0, max_idx)
 	visible_rows := int(list_height / row_height) + 1
-	buf := list_box_virtual_buffer_rows
+	buf := list_core_virtual_buffer_rows
 	first_visible := int_max(0, first - buf)
 	mut last_visible := int_min(max_idx, first + visible_rows + buf)
 	if first_visible > last_visible {
@@ -221,7 +223,10 @@ fn list_core_navigate(key KeyCode, item_count int, current int) ListCoreAction {
 
 // list_core_fuzzy_score scores a candidate against a query.
 // Returns -1 (no match) or 0+ (lower = better). Zero-alloc,
-// raw byte walking.
+// raw byte walking. Byte-level comparison; ASCII
+// case-insensitive. Multi-byte UTF-8 sequences (accented
+// chars, CJK, emoji) are compared byte-by-byte without
+// case folding.
 fn list_core_fuzzy_score(candidate string, query string) int {
 	if query.len == 0 {
 		return 0
@@ -298,6 +303,75 @@ struct ListCoreScored {
 	score int
 }
 
+// list_core_apply_nav applies a navigation action to a
+// highlight index. Returns new index and whether it changed.
+fn list_core_apply_nav(action ListCoreAction, cur int, item_count int) (int, bool) {
+	match action {
+		.move_up {
+			next := if cur > 0 { cur - 1 } else { 0 }
+			return next, next != cur
+		}
+		.move_down {
+			next := if cur < item_count - 1 {
+				cur + 1
+			} else {
+				item_count - 1
+			}
+			return next, next != cur
+		}
+		.first {
+			return 0, cur != 0
+		}
+		.last {
+			last := if item_count > 0 {
+				item_count - 1
+			} else {
+				0
+			}
+			return last, cur != last
+		}
+		else {
+			return cur, false
+		}
+	}
+}
+
+// ListCorePrepared holds pre-computed filter results for a
+// frame.
+struct ListCorePrepared {
+	items []ListCoreItem
+	ids   []string
+	hl    int
+}
+
+// list_core_prepare filters items by query, clamps highlight,
+// and collects selectable IDs. Skips subheadings from IDs.
+fn list_core_prepare(items []ListCoreItem, query string, raw_highlight int) ListCorePrepared {
+	filtered_indices := list_core_filter(items, query)
+	mut filtered := []ListCoreItem{cap: filtered_indices.len}
+	for idx in filtered_indices {
+		if idx >= 0 && idx < items.len {
+			filtered << items[idx]
+		}
+	}
+	hl := if filtered.len > 0 {
+		int_clamp(raw_highlight, 0, filtered.len - 1)
+	} else {
+		0
+	}
+	mut ids := []string{cap: filtered.len}
+	for item in filtered {
+		if !item.is_subheading {
+			ids << item.id
+		}
+	}
+	return ListCorePrepared{
+		items: filtered
+		ids:   ids
+		hl:    hl
+	}
+}
+
 // list_core_row_height_estimate estimates row height from text
 // style + padding. No Window needed.
 fn list_core_row_height_estimate(style TextStyle, pad Padding) f32 {