Fix CivArchive browser filter bugs and compact layout

- Handle array-shaped platform echo in filter response — CivArchive returns
  pageProps.filters.platform as an array (e.g. ["civitai"]) once a non-default
  platform is selected, which threw at $.pageProps.filters.platform
- Fetch filter options via parameterless /top-models.json — the endpoint
  returns empty baseModels/modelTypes the moment any query param is present,
  so the Model Type and Base Model dropdowns were silently empty
- Collapse Rating/Status into icon-button flyouts and group Zoom / Hide
  Installed / Fit Images / Reset behind a single View overflow button so
  the filter row stays single-line at narrower widths
- Show "(N)" count badge on Model Type / Base Model when partially selected
- Debounce filter-driven searches at 300ms — rapid toggling no longer
  fires N back-to-back searches and trips CivArchive's rate limit
- Cache SearchAsync / GetFilterOptionsAsync / GetModelDetailsAsync /
  ResolveFileUrlAsync responses with per-endpoint TTLs

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

Author: mohnjiles

StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/CivArchiveBrowserViewModel.cs

@@ -36,6 +36,7 @@ IModelIndexService modelIndexService
     private bool filterOptionsLoaded;
     private bool searchQueued;
     private int currentPage = 1;
+    private DispatcherTimer? searchDebounceTimer;
 
     /// <summary>
     /// All search results we've fetched so far across pages, regardless of client-side filters.
@@ -95,6 +96,25 @@ IModelIndexService modelIndexService
             ? string.Empty
             : $"{AllBaseModels.Count(x => x.IsSelected)} of {AllBaseModels.Count} selected";
 
+    /// <summary>
+    /// True when a partial selection is active — at least one selected and at least one
+    /// deselected. The "all selected" stock state and the "none selected" degenerate state
+    /// both render plain (no badge), since neither is a meaningful filter to surface.
+    /// </summary>
+    public bool HasModelTypeFilter =>
+        AllModelTypes.Count > 0
+        && AllModelTypes.Any(x => x.IsSelected)
+        && AllModelTypes.Any(x => !x.IsSelected);
+
+    public bool HasBaseModelFilter =>
+        AllBaseModels.Count > 0
+        && AllBaseModels.Any(x => x.IsSelected)
+        && AllBaseModels.Any(x => !x.IsSelected);
+
+    public int SelectedModelTypeCount => AllModelTypes.Count(x => x.IsSelected);
+
+    public int SelectedBaseModelCount => AllBaseModels.Count(x => x.IsSelected);
+
     [ObservableProperty]
     private string searchQuery = string.Empty;
 
@@ -252,9 +272,54 @@ protected override async Task OnInitialLoadedAsync()
         EventManager.Instance.ModelIndexChanged += indexHandler;
         AddDisposable(Disposable.Create(() => EventManager.Instance.ModelIndexChanged -= indexHandler));
 
+        // Debounce filter-driven searches so rapid toggles (e.g. picking a dozen base
+        // models in a row) collapse into a single API call instead of N — CivArchive
+        // 429s aggressively otherwise.
+        searchDebounceTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(300) };
+        searchDebounceTimer.Tick += OnSearchDebounceElapsed;
+        AddDisposable(
+            Disposable.Create(() =>
+            {
+                searchDebounceTimer.Stop();
+                searchDebounceTimer.Tick -= OnSearchDebounceElapsed;
+            })
+        );
+
+        // Filter options (Model Type / Base Model dropdown contents) only come back
+        // populated when the URL has no query string, so we have to fetch them with a
+        // dedicated parameterless call before the first filtered search runs.
+        await LoadFilterOptionsAsync();
+
         await SearchModels();
     }
 
+    private async Task LoadFilterOptionsAsync()
+    {
+        if (filterOptionsLoaded)
+        {
+            return;
+        }
+
+        try
+        {
+            var options = await civArchiveApiClient.GetFilterOptionsAsync();
+            ApplyFilterOptions(options);
+            filterOptionsLoaded = true;
+        }
+        catch (Exception ex)
+        {
+            // Don't block the search itself — failure here just means the multi-select
+            // dropdowns stay empty until the user reloads the page.
+            NoResultsText = ex.Message;
+        }
+        finally
+        {
+            // ApplyFilterOptions sets suppressSearch=true while it populates the option
+            // collections; release it before the real search runs so user input flows.
+            suppressSearch = false;
+        }
+    }
+
     partial void OnHideInstalledModelsChanged(bool value) => RebuildVisibleResults();
 
     private void OnLocalModelIndexChanged()
@@ -285,9 +350,42 @@ private void RebuildVisibleResults()
         OnPropertyChanged(nameof(IsEndOfResults));
     }
 
+    private void OnSearchDebounceElapsed(object? sender, EventArgs e)
+    {
+        searchDebounceTimer?.Stop();
+        _ = SearchModels();
+    }
+
+    /// <summary>
+    /// Restart the debounce timer. The actual search runs once the user pauses for the
+    /// timer's interval — multiple rapid filter changes within that window collapse into
+    /// a single fetch.
+    /// </summary>
+    private void RequestDebouncedSearch()
+    {
+        if (suppressSearch)
+        {
+            return;
+        }
+
+        SaveSettings();
+
+        if (!HasSearched)
+        {
+            return;
+        }
+
+        searchDebounceTimer?.Stop();
+        searchDebounceTimer?.Start();
+    }
+
     [RelayCommand]
     private async Task SearchModels(bool isInfiniteScroll = false)
     {
+        // Cancel any pending debounced search so an explicit invocation (search button,
+        // ResetFilters, etc.) doesn't get shadowed by a redundant fire 300ms later.
+        searchDebounceTimer?.Stop();
+
         if (IsLoading)
         {
             if (!isInfiniteScroll)
@@ -321,31 +419,6 @@ private async Task SearchModels(bool isInfiniteScroll = false)
         {
             var response = await civArchiveApiClient.SearchAsync(filters);
 
-            if (!filterOptionsLoaded)
-            {
-                ApplyFilterOptions(response.FilterOptions);
-                filterOptionsLoaded = true;
-
-                // ApplyFilterOptions sets suppressSearch=true while populating the option
-                // collections. Only re-fetch if the user actually has saved selections
-                // (Types/BaseModels) that we couldn't apply on the first call — for a
-                // first-run user with no saved selections the initial response is already
-                // correct and a second fetch is wasted bandwidth.
-                var savedOptions = settingsManager.Settings.CivArchiveBrowserOptions;
-                var hasSelections =
-                    savedOptions.SelectedModelTypes.Count > 0 || savedOptions.SelectedBaseModels.Count > 0;
-
-                if (!isInfiniteScroll && suppressSearch && hasSelections)
-                {
-                    suppressSearch = false;
-                    response = await civArchiveApiClient.SearchAsync(BuildFilters(currentPage));
-                }
-                else
-                {
-                    suppressSearch = false;
-                }
-            }
-
             TotalHits = response.TotalHits;
             currentPage = response.EffectiveFilters.Page;
 
@@ -613,11 +686,15 @@ IReadOnlyCollection<string> selectedValues
         {
             ApplyModelTypeFilter();
             OnPropertyChanged(nameof(ModelTypeSelectionSummary));
+            OnPropertyChanged(nameof(HasModelTypeFilter));
+            OnPropertyChanged(nameof(SelectedModelTypeCount));
         }
         else if (ReferenceEquals(target, AllBaseModels))
         {
             ApplyBaseModelFilter();
             OnPropertyChanged(nameof(BaseModelSelectionSummary));
+            OnPropertyChanged(nameof(HasBaseModelFilter));
+            OnPropertyChanged(nameof(SelectedBaseModelCount));
         }
     }
 
@@ -756,7 +833,7 @@ private void SaveSettings()
         );
     }
 
-    private async void OnSelectableOptionChanged(object? sender, PropertyChangedEventArgs e)
+    private void OnSelectableOptionChanged(object? sender, PropertyChangedEventArgs e)
     {
         if (e.PropertyName != nameof(BaseModelOptionViewModel.IsSelected))
         {
@@ -765,18 +842,12 @@ private async void OnSelectableOptionChanged(object? sender, PropertyChangedEven
 
         OnPropertyChanged(nameof(ModelTypeSelectionSummary));
         OnPropertyChanged(nameof(BaseModelSelectionSummary));
+        OnPropertyChanged(nameof(HasModelTypeFilter));
+        OnPropertyChanged(nameof(HasBaseModelFilter));
+        OnPropertyChanged(nameof(SelectedModelTypeCount));
+        OnPropertyChanged(nameof(SelectedBaseModelCount));
 
-        if (suppressSearch)
-        {
-            return;
-        }
-
-        SaveSettings();
-
-        if (HasSearched)
-        {
-            await SearchModels();
-        }
+        RequestDebouncedSearch();
     }
 
     partial void OnSelectedPlatformChanged(NamedOption<CivArchivePlatformOption>? value) =>
@@ -793,18 +864,5 @@ partial void OnSelectedPlatformStatusChanged(NamedOption<CivArchivePlatformStatu
 
     partial void OnSelectedKindChanged(NamedOption<CivArchiveKindOption>? value) => TriggerFilterSearch();
 
-    private async void TriggerFilterSearch()
-    {
-        if (suppressSearch)
-        {
-            return;
-        }
-
-        SaveSettings();
-
-        if (HasSearched)
-        {
-            await SearchModels();
-        }
-    }
+    private void TriggerFilterSearch() => RequestDebouncedSearch();
 }