Address review feedback and fix CI test failures

- Switch debounce from DispatcherTimer to CancellationTokenSource +
  Task.Delay so it works in headless unit tests (where there's no
  Avalonia UI dispatcher) and removes the orphan `_ = SearchModels()`
  fire-and-forget — the debounced helper now awaits SearchModels directly
- Expose SearchDebounceInterval as a public property so tests can collapse
  it to TimeSpan.Zero instead of waiting hundreds of ms per assertion
- Update the two ViewModel tests broken by debounce: set the interval to
  zero, and add a brief await in the queued-while-loading test so the
  debounced fire-and-forget Task.Delay(0) propagates before SetResult
- Track array depth in CivArchiveSingleStringConverter so a hypothetical
  nested array doesn't strand the JSON reader mid-structure (return on
  the matching EndArray, not past it — STJ verifies cursor position)
- Serialize concurrent first-load callers of GetFilterOptionsAsync via a
  SemaphoreSlim so a cold cache + concurrent invocations don't fire
  redundant fetches (matches the existing buildId pattern)

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

Author: mohnjiles

StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/CivArchiveBrowserViewModel.cs

@@ -36,7 +36,14 @@ IModelIndexService modelIndexService
     private bool filterOptionsLoaded;
     private bool searchQueued;
     private int currentPage = 1;
-    private DispatcherTimer? searchDebounceTimer;
+    private CancellationTokenSource? searchDebounceCts;
+
+    /// <summary>
+    /// How long to wait after the most recent filter change before firing the search.
+    /// Kept settable (not a const) so unit tests can collapse it to <see cref="TimeSpan.Zero"/>
+    /// instead of waiting hundreds of ms per assertion.
+    /// </summary>
+    public TimeSpan SearchDebounceInterval { get; set; } = TimeSpan.FromMilliseconds(300);
 
     /// <summary>
     /// All search results we've fetched so far across pages, regardless of client-side filters.
@@ -272,16 +279,13 @@ 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;
+        // Cancel any pending debounced search when the VM is disposed.
         AddDisposable(
             Disposable.Create(() =>
             {
-                searchDebounceTimer.Stop();
-                searchDebounceTimer.Tick -= OnSearchDebounceElapsed;
+                searchDebounceCts?.Cancel();
+                searchDebounceCts?.Dispose();
+                searchDebounceCts = null;
             })
         );
 
@@ -350,16 +354,10 @@ 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.
+    /// Cancel any pending debounced search and start a new wait window. The actual
+    /// search runs once the user pauses for <see cref="SearchDebounceInterval"/> —
+    /// multiple rapid filter changes within that window collapse into a single fetch.
     /// </summary>
     private void RequestDebouncedSearch()
     {
@@ -375,16 +373,40 @@ private void RequestDebouncedSearch()
             return;
         }
 
-        searchDebounceTimer?.Stop();
-        searchDebounceTimer?.Start();
+        searchDebounceCts?.Cancel();
+        searchDebounceCts?.Dispose();
+
+        var cts = new CancellationTokenSource();
+        searchDebounceCts = cts;
+
+        _ = RunDebouncedSearchAsync(cts.Token);
+    }
+
+    private async Task RunDebouncedSearchAsync(CancellationToken token)
+    {
+        try
+        {
+            await Task.Delay(SearchDebounceInterval, token);
+        }
+        catch (TaskCanceledException)
+        {
+            return;
+        }
+
+        if (token.IsCancellationRequested)
+        {
+            return;
+        }
+
+        await SearchModels();
     }
 
     [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();
+        // ResetFilters, etc.) doesn't get shadowed by a redundant fire moments later.
+        searchDebounceCts?.Cancel();
 
         if (IsLoading)
         {

StabilityMatrix.Core/Api/CivArchiveApiClient.cs

@@ -29,6 +29,7 @@ IHttpClientFactory httpClientFactory
 
     private readonly HttpClient httpClient = CreateHttpClient(httpClientFactory);
     private readonly SemaphoreSlim buildIdLock = new(1, 1);
+    private readonly SemaphoreSlim filterOptionsLock = new(1, 1);
     private string? cachedBuildId;
 
     private readonly LRUCache<string, CacheEntry<CivArchiveSearchResponse>> searchCache = new(64);
@@ -118,25 +119,41 @@ public async Task<CivArchiveFilterOptions> GetFilterOptionsAsync(
             return cached.Value;
         }
 
-        // Parameterless URL is intentional — CivArchive returns empty filter-option arrays
-        // the moment any query param is present, even if every value is the default.
-        var response = await GetNextDataAsync<CivArchiveListPageResponse>(
-            "/top-models.json",
-            cancellationToken
-        );
+        // Singleton API client → multiple concurrent first-load callers could otherwise
+        // fire redundant fetches before the cache is populated. Serialize them so only
+        // one request goes out per cold cache.
+        await filterOptionsLock.WaitAsync(cancellationToken);
+        try
+        {
+            if (cachedFilterOptions is { } cachedRetry && cachedRetry.IsFresh(FilterOptionsCacheTtl))
+            {
+                return cachedRetry.Value;
+            }
 
-        var pageProps =
-            response.PageProps
-            ?? throw new InvalidOperationException("CivArchive list page was missing pageProps");
+            // Parameterless URL is intentional — CivArchive returns empty filter-option arrays
+            // the moment any query param is present, even if every value is the default.
+            var response = await GetNextDataAsync<CivArchiveListPageResponse>(
+                "/top-models.json",
+                cancellationToken
+            );
 
-        var result = new CivArchiveFilterOptions
-        {
-            BaseModels = pageProps.FilterOptions?.BaseModels ?? [],
-            ModelTypes = pageProps.FilterOptions?.ModelTypes ?? [],
-        };
+            var pageProps =
+                response.PageProps
+                ?? throw new InvalidOperationException("CivArchive list page was missing pageProps");
 
-        cachedFilterOptions = new CacheEntry<CivArchiveFilterOptions>(DateTimeOffset.UtcNow, result);
-        return result;
+            var result = new CivArchiveFilterOptions
+            {
+                BaseModels = pageProps.FilterOptions?.BaseModels ?? [],
+                ModelTypes = pageProps.FilterOptions?.ModelTypes ?? [],
+            };
+
+            cachedFilterOptions = new CacheEntry<CivArchiveFilterOptions>(DateTimeOffset.UtcNow, result);
+            return result;
+        }
+        finally
+        {
+            filterOptionsLock.Release();
+        }
     }
 
     public async Task<CivArchiveModelDetailsResponse> GetModelDetailsAsync(
@@ -654,17 +671,29 @@ JsonSerializerOptions options
 
             if (reader.TokenType == JsonTokenType.StartArray)
             {
+                // Track depth so a hypothetical nested array (e.g. [["a"]]) doesn't leave
+                // the reader stranded mid-structure for the next property to deserialize.
+                // Must return *on* the matching EndArray token (not past it) — STJ strictly
+                // verifies the converter's final cursor position.
                 string? first = null;
+                var depth = 1;
                 while (reader.Read())
                 {
-                    if (reader.TokenType == JsonTokenType.EndArray)
-                    {
-                        return first;
-                    }
-
-                    if (reader.TokenType == JsonTokenType.String && first is null)
+                    switch (reader.TokenType)
                     {
-                        first = reader.GetString();
+                        case JsonTokenType.StartArray:
+                            depth++;
+                            break;
+                        case JsonTokenType.EndArray:
+                            depth--;
+                            if (depth == 0)
+                            {
+                                return first;
+                            }
+                            break;
+                        case JsonTokenType.String when first is null:
+                            first = reader.GetString();
+                            break;
                     }
                 }
 

StabilityMatrix.Tests/Avalonia/CivArchiveBrowserViewModelTests.cs

@@ -45,6 +45,9 @@ public async Task ChangingFilters_TriggersNewQueryAndResetsPaging()
             });
 
         var vm = CreateViewModel(apiClient, out _, out _);
+        // Collapse the debounce so the sort-change re-fetch happens within the test
+        // window instead of after the production-default 300ms idle delay.
+        vm.SearchDebounceInterval = TimeSpan.Zero;
         vm.OnLoaded();
 
         await vm.SearchModelsCommand.ExecuteAsync(false);
@@ -147,13 +150,20 @@ public async Task ChangingFilterWhileLoading_QueuesRefreshWithLatestFilter()
             });
 
         var vm = CreateViewModel(apiClient, out _, out _);
+        vm.SearchDebounceInterval = TimeSpan.Zero;
         vm.OnLoaded();
 
         await vm.SearchModelsCommand.ExecuteAsync(false);
 
         var loadingSearch = vm.SearchModelsCommand.ExecuteAsync(false);
         vm.SelectedSort = vm.AllSorts.First(x => x.Value == CivArchiveSortOption.Newest);
 
+        // Let the debounced fire-and-forget task spin up: it'll await Task.Delay(0),
+        // call SearchModels, see IsLoading=true, and set searchQueued. After the
+        // delayed in-flight call completes, the queued mechanism re-fires with the
+        // newest sort.
+        await Task.Delay(50);
+
         delayedResponse.SetResult(CreateSearchResponse(1));
         await loadingSearch;