fix(ui): cache sorted sound indices

Move sound filtering and sorting to update-side invalidation boundaries so Iced view construction only indexes cached results. Project only the active sort key and keep render benchmarks on the production cached-index API.

Co-Authored-By: Codex <noreply@openai.com>

Author: thewrz

benches/grid_render.rs

@@ -8,9 +8,7 @@ mod support;
 
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 
-use support::{
-    GridFixture, init_wgpu, make_sounds, render_tiny_skia, self_check, sound_refs, try_render_wgpu,
-};
+use support::{GridFixture, init_wgpu, make_sounds, render_tiny_skia, self_check, try_render_wgpu};
 
 /// Tile counts ADR-009 anchors the baseline against.
 const SIZES: [usize; 3] = [50, 200, 500];
@@ -24,9 +22,9 @@ fn bench_tiny_skia(c: &mut Criterion) {
     for &n in &SIZES {
         let sounds = make_sounds(n);
         let fx = GridFixture::new();
-        let refs = sound_refs(&sounds);
+        let visible_indices = (0..sounds.len()).collect::<Vec<_>>();
         group.bench_with_input(BenchmarkId::from_parameter(n), &n, |b, _| {
-            b.iter(|| render_tiny_skia(&refs, fx.grid_ctx(COLUMNS)));
+            b.iter(|| render_tiny_skia(&sounds, &visible_indices, fx.grid_ctx(COLUMNS)));
         });
     }
     group.finish();
@@ -45,9 +43,9 @@ fn bench_wgpu(c: &mut Criterion) {
     for &n in &SIZES {
         let sounds = make_sounds(n);
         let fx = GridFixture::new();
-        let refs = sound_refs(&sounds);
+        let visible_indices = (0..sounds.len()).collect::<Vec<_>>();
         group.bench_with_input(BenchmarkId::from_parameter(n), &n, |b, _| {
-            b.iter(|| try_render_wgpu(&refs, fx.grid_ctx(COLUMNS), &gpu));
+            b.iter(|| try_render_wgpu(&sounds, &visible_indices, fx.grid_ctx(COLUMNS), &gpu));
         });
     }
     group.finish();

benches/support/mod.rs

@@ -66,11 +66,6 @@ pub fn make_sounds(n: usize) -> Vec<SoundEntry> {
         .collect()
 }
 
-/// Borrows entries into the `&[&SoundEntry]` slice `view_grid` expects.
-pub fn sound_refs(sounds: &[SoundEntry]) -> Vec<&SoundEntry> {
-    sounds.iter().collect()
-}
-
 /// Owns the per-grid context state (`SlotMap`, trigger labels, meta store) so a
 /// `GridCtx` can borrow from it for the duration of a bench iteration. Empty /
 /// default state represents the common case (no slots bound, no favorites).
@@ -111,8 +106,13 @@ impl Default for GridFixture {
 /// Builds the grid `Element` and runs Iced's layout + draw passes against the
 /// provided renderer. This is the `view()`-construction + tessellation work
 /// ADR-009 cares about. Rasterization is renderer-specific (done by callers).
-fn layout_and_draw(sounds: &[&SoundEntry], grid: GridCtx, renderer: &mut iced::Renderer) {
-    let element: Element<'_, Message> = view_grid(sounds.to_vec(), None, grid);
+fn layout_and_draw(
+    sounds: &[SoundEntry],
+    visible_indices: &[usize],
+    grid: GridCtx,
+    renderer: &mut iced::Renderer,
+) {
+    let element: Element<'_, Message> = view_grid(sounds, visible_indices, None, grid);
     let bounds = Size::new(VIEW_W as f32, VIEW_H as f32);
     let mut ui = UserInterface::build(element, bounds, Cache::new(), renderer);
     let theme = Theme::Dark;
@@ -138,12 +138,12 @@ fn full_damage() -> [Rectangle; 1] {
 /// Full tiny-skia render: layout + draw + CPU rasterization into a `Pixmap`.
 /// This is the `HONKHONK_RENDERER=software` path. Returns the top-left pixel so
 /// the optimizer cannot elide the raster. Always available (pure CPU).
-pub fn render_tiny_skia(sounds: &[&SoundEntry], grid: GridCtx) -> u32 {
+pub fn render_tiny_skia(sounds: &[SoundEntry], visible_indices: &[usize], grid: GridCtx) -> u32 {
     // The `Element` is generic over `iced::Renderer` (the fallback enum); its
     // `Secondary` arm *is* the tiny-skia renderer, so draw lands in its layers.
     let mut renderer =
         iced::Renderer::Secondary(iced_tiny_skia::Renderer::new(Font::DEFAULT, text_size()));
-    layout_and_draw(sounds, grid, &mut renderer);
+    layout_and_draw(sounds, visible_indices, grid, &mut renderer);
 
     let iced::Renderer::Secondary(ts) = &mut renderer else {
         unreachable!("constructed Secondary");
@@ -235,13 +235,18 @@ pub fn init_wgpu() -> Option<WgpuCtx> {
 /// Full wgpu render: layout + draw + present to the reusable offscreen target.
 /// Returns a token so the work cannot be optimized away. Requires an
 /// initialized context.
-pub fn try_render_wgpu(sounds: &[&SoundEntry], grid: GridCtx, gpu: &WgpuCtx) -> u32 {
+pub fn try_render_wgpu(
+    sounds: &[SoundEntry],
+    visible_indices: &[usize],
+    grid: GridCtx,
+    gpu: &WgpuCtx,
+) -> u32 {
     let mut renderer = iced::Renderer::Primary(iced_wgpu::Renderer::new(
         gpu.engine.clone(),
         Font::DEFAULT,
         text_size(),
     ));
-    layout_and_draw(sounds, grid, &mut renderer);
+    layout_and_draw(sounds, visible_indices, grid, &mut renderer);
 
     let iced::Renderer::Primary(wr) = &mut renderer else {
         unreachable!("constructed Primary");
@@ -272,7 +277,7 @@ pub fn self_check() {
         u64::from_str_radix(head, 16).expect("fixture id head parses as hex");
     }
     let sounds = make_sounds(50);
-    let refs = sound_refs(&sounds);
+    let visible_indices = (0..sounds.len()).collect::<Vec<_>>();
     let fx = GridFixture::new();
-    let _ = render_tiny_skia(&refs, fx.grid_ctx(5));
+    let _ = render_tiny_skia(&sounds, &visible_indices, fx.grid_ctx(5));
 }

src/app/filtering.rs

@@ -1,12 +1,12 @@
 use iced::event::Status;
 use iced::keyboard;
-use std::borrow::Cow;
 
-use super::{FAVORITES_TAB, HonkHonk, Message, ViewMode, sorting};
-use crate::state::SoundEntry;
-use crate::ui::list_controls::filter::{Activation, ActivationContext, filter_items};
+use super::{HonkHonk, Message, ViewMode};
+use crate::ui::list_controls::filter::{Activation, ActivationContext};
 use crate::ui::search_bar;
 
+mod cache;
+
 pub(super) fn type_to_filter_text(event: &iced::Event, status: Status) -> Option<String> {
     if status != Status::Ignored {
         return None;
@@ -30,6 +30,22 @@ pub(super) fn type_to_filter_text(event: &iced::Event, status: Status) -> Option
 }
 
 impl HonkHonk {
+    pub(super) fn select_sound_category(&mut self, category: Option<String>) {
+        if self.active_category == category {
+            return;
+        }
+        self.active_category = category;
+        self.refresh_filtered_sounds();
+    }
+
+    pub(super) fn replace_filter_query(&mut self, query: String) {
+        let changed = self.filter.query() != query;
+        self.filter.replace(query);
+        if changed {
+            self.refresh_filtered_sounds();
+        }
+    }
+
     fn filter_context(&self) -> ActivationContext {
         let activation = match self.view_mode {
             ViewMode::Main => Activation::TypeToFilter,
@@ -52,6 +68,9 @@ impl HonkHonk {
         }
 
         self.filter.insert(text);
+        if !text.is_empty() {
+            self.refresh_filtered_sounds();
+        }
         iced::widget::operation::focus(search_bar::input_id())
     }
 
@@ -75,40 +94,14 @@ impl HonkHonk {
         } else if event_was_captured {
             self.filter.consume_focus();
         } else {
+            let query_was_present = !self.filter.query().is_empty();
             self.filter.escape();
+            if query_was_present && self.filter.query().is_empty() {
+                self.refresh_filtered_sounds();
+            }
         }
         iced::Task::none()
     }
-
-    /// Returns sounds matching the shared query and active category filters.
-    pub fn filtered_sounds(&self) -> Vec<&SoundEntry> {
-        let sounds = filter_items(&self.sounds, self.filter.query(), |sound| {
-            let display_name = self
-                .sound_meta
-                .get_ref(&sound.id)
-                .and_then(|meta| meta.display_name.as_deref())
-                .unwrap_or("");
-            let filename = sound
-                .path
-                .file_name()
-                .map(std::ffi::OsStr::to_string_lossy)
-                .unwrap_or_default();
-            [
-                Cow::Borrowed(display_name),
-                filename,
-                Cow::Borrowed(sound.name.as_str()),
-                Cow::Borrowed(sound.category.as_str()),
-            ]
-        })
-        .into_iter()
-        .filter(|sound| match self.active_category.as_deref() {
-            Some(FAVORITES_TAB) => self.sound_meta.is_favorite(&sound.id),
-            Some(category) => sound.category == category,
-            None => true,
-        })
-        .collect();
-        sorting::sorted_sounds(sounds, self.sound_sort, &self.sound_meta)
-    }
 }
 
 #[cfg(test)]
@@ -118,7 +111,27 @@ mod tests {
     use iced::keyboard::{self, Key, Location, Modifiers};
 
     use super::*;
-    use crate::state::{AudioFormat, Macro};
+    use crate::app::FAVORITES_TAB;
+    use crate::state::{AudioFormat, Macro, SoundEntry};
+
+    fn sound(id: &str, name: &str, duration_ms: Option<u64>, category: &str) -> SoundEntry {
+        SoundEntry {
+            id: id.into(),
+            name: name.into(),
+            path: format!("/sounds/{category}/{id}.wav").into(),
+            format: AudioFormat::Wav,
+            duration_ms,
+            category: category.into(),
+            modified_ms: None,
+        }
+    }
+
+    fn filtered_ids(app: &HonkHonk) -> Vec<&str> {
+        app.filtered_sounds()
+            .into_iter()
+            .map(|sound| sound.id.as_str())
+            .collect()
+    }
 
     fn key_event(text: Option<&str>, modifiers: Modifiers) -> iced::Event {
         iced::Event::Keyboard(keyboard::Event::KeyPressed {
@@ -268,23 +281,92 @@ mod tests {
     #[test]
     fn main_grid_filter_results_follow_the_active_sort_state() {
         let mut app = HonkHonk::new_for_test();
-        app.sounds = ["Zulu", "alpha"]
-            .into_iter()
-            .map(|name| SoundEntry {
-                id: name.into(),
-                name: name.into(),
-                path: format!("/sounds/{name}.wav").into(),
-                format: AudioFormat::Wav,
-                duration_ms: None,
-                category: "Other".into(),
-                modified_ms: None,
-            })
-            .collect();
+        app.sounds = vec![
+            sound("zulu", "Zulu", None, "Other"),
+            sound("alpha", "alpha", None, "Other"),
+        ];
+        app.refresh_filtered_sounds();
 
         assert_eq!(app.filtered_sounds()[0].name, "alpha");
 
         let _ = app.update(Message::ToggleSoundSortDirection);
 
         assert_eq!(app.filtered_sounds()[0].name, "Zulu");
     }
+
+    #[test]
+    fn filtered_sounds_reads_cached_order_without_resorting() {
+        let mut app = HonkHonk::new_for_test();
+        app.sounds = vec![
+            sound("zulu", "Zulu", None, "Other"),
+            sound("alpha", "alpha", None, "Other"),
+        ];
+        app.refresh_filtered_sounds();
+
+        assert_eq!(filtered_ids(&app), vec!["alpha", "zulu"]);
+        app.sound_sort.toggle_direction();
+
+        assert_eq!(
+            filtered_ids(&app),
+            vec!["alpha", "zulu"],
+            "reading filtered sounds must not recompute their order"
+        );
+    }
+
+    #[test]
+    fn query_category_and_favorite_updates_refresh_cached_membership() {
+        let mut app = HonkHonk::new_for_test();
+        app.sounds = vec![
+            sound("alpha", "Alpha", None, "Animals"),
+            sound("beta", "Beta", None, "Memes"),
+        ];
+        app.refresh_filtered_sounds();
+
+        let _ = app.update(Message::SearchChanged("beta".into()));
+        assert_eq!(filtered_ids(&app), vec!["beta"]);
+
+        let _ = app.update(Message::SearchChanged(String::new()));
+        let _ = app.update(Message::SelectCategory(Some("Animals".into())));
+        assert_eq!(filtered_ids(&app), vec!["alpha"]);
+
+        let _ = app.update(Message::SelectCategory(None));
+        let _ = app.update(Message::TypeToFilter("beta".into()));
+        assert_eq!(filtered_ids(&app), vec!["beta"]);
+        let _ = app.update(Message::EscapePressed);
+        let _ = app.update(Message::EscapePressed);
+        assert_eq!(filtered_ids(&app), vec!["alpha", "beta"]);
+
+        let _ = app.update(Message::ToggleFavorite("beta".into()));
+        let _ = app.update(Message::SelectCategory(Some(FAVORITES_TAB.into())));
+        assert_eq!(filtered_ids(&app), vec!["beta"]);
+
+        let _ = app.update(Message::ToggleFavorite("beta".into()));
+        assert_eq!(filtered_ids(&app), vec!["alpha", "beta"]);
+    }
+
+    #[test]
+    fn duration_and_display_name_updates_refresh_cached_order() {
+        let mut app = HonkHonk::new_for_test();
+        app.sounds = vec![
+            sound("alpha", "Alpha", Some(200), "Other"),
+            sound("zulu", "Zulu", None, "Other"),
+        ];
+        app.refresh_filtered_sounds();
+
+        let _ = app.update(Message::SelectSoundSort("length"));
+        assert_eq!(filtered_ids(&app), vec!["alpha", "zulu"]);
+
+        let durations = std::collections::HashMap::from([("zulu".to_owned(), 100)]);
+        let _ = app.update(Message::DurationsLoaded(durations));
+        assert_eq!(filtered_ids(&app), vec!["zulu", "alpha"]);
+
+        let _ = app.update(Message::SelectSoundSort("name"));
+        let _ = app.update(Message::OpenSoundEditor("zulu".into()));
+        let _ = app.update(Message::SoundEditorNameChanged("Aardvark".into()));
+        let _ = app.update(Message::SaveSoundMeta("zulu".into()));
+        assert_eq!(filtered_ids(&app), vec!["zulu", "alpha"]);
+
+        let _ = app.update(Message::SearchChanged("aardvark".into()));
+        assert_eq!(filtered_ids(&app), vec!["zulu"]);
+    }
 }

src/app/filtering/cache.rs

@@ -0,0 +1,53 @@
+use std::borrow::Cow;
+
+use super::HonkHonk;
+use crate::app::{FAVORITES_TAB, sorting};
+use crate::state::SoundEntry;
+use crate::ui::list_controls::filter::filter_indices;
+
+impl HonkHonk {
+    pub(in crate::app) fn refresh_filtered_sounds(&mut self) {
+        let indices = filter_indices(&self.sounds, self.filter.query(), |sound| {
+            let display_name = self
+                .sound_meta
+                .get_ref(&sound.id)
+                .and_then(|meta| meta.display_name.as_deref())
+                .unwrap_or("");
+            let filename = sound
+                .path
+                .file_name()
+                .map(std::ffi::OsStr::to_string_lossy)
+                .unwrap_or_default();
+            [
+                Cow::Borrowed(display_name),
+                filename,
+                Cow::Borrowed(sound.name.as_str()),
+                Cow::Borrowed(sound.category.as_str()),
+            ]
+        })
+        .into_iter()
+        .filter(|&index| self.sound_matches_active_category(index))
+        .collect();
+        self.filtered_sound_indices =
+            sorting::sorted_sound_indices(&self.sounds, indices, self.sound_sort, &self.sound_meta);
+    }
+
+    fn sound_matches_active_category(&self, index: usize) -> bool {
+        let Some(sound) = self.sounds.get(index) else {
+            return false;
+        };
+        match self.active_category.as_deref() {
+            Some(FAVORITES_TAB) => self.sound_meta.is_favorite(&sound.id),
+            Some(category) => sound.category == category,
+            None => true,
+        }
+    }
+
+    /// Returns cached sounds matching the shared query and category filters.
+    pub fn filtered_sounds(&self) -> Vec<&SoundEntry> {
+        self.filtered_sound_indices
+            .iter()
+            .filter_map(|&index| self.sounds.get(index))
+            .collect()
+    }
+}