Gate network parsers on a working proxy and remember what worked

The pool now warms up from what the previous run learned instead of starting
cold every launch. Startup probes the remembered proxies first, stops as soon
as ProxyMinimumLive of them answer, and writes the survivors to
proxies.state.json after the warm-up and again on shutdown. Only proxies that
ever answered are stored: the feed republishes a few thousand dead addresses
every five minutes, and "was dead an hour ago" says almost nothing.

Remembered state is a hint, not a verdict. A restored proxy sorts first in the
warm-up queue but is not counted live until it answers in this session -
otherwise a launch a week later would report live proxies it had never spoken
to, the warm-up would skip the very entries it exists to re-check, and the
parser gate would open on week-old evidence.

That gate is the other half: a parser declaring RequiresNetwork will not run
while the pool has nothing live. The Parse page disables the run button and
shows a banner that leads to the Proxies page. Parsers that work on pasted text
are never gated - they have nothing to route, and blocking them would make the
app useless whenever the public lists are down. Two new settings cover the
escape hatch and the target: "allow network parsers without a proxy" and how
many live proxies to find at startup.

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

tests/AvParser.UI.HeadlessTests/ParseViewTests.cs

@@ -0,0 +1,121 @@
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using AvParser.Core.Parsing;
+using AvParser.Core.Parsing.Samples;
+using AvParser.Core.Proxies;
+using AvParser.Core.Settings;
+using AvParser.UI.ViewModels;
+using AvParser.UI.Views;
+using Microsoft.Extensions.Logging.Abstractions;
+using ReactiveUI.Primitives.Concurrency;
+
+namespace AvParser.UI.HeadlessTests;
+
+public class ParseViewTests
+{
+    private static (ParseView View, ParseViewModel ViewModel, Window Window) ShowPage(params ITextParser[] extra)
+    {
+        var catalog = new ParserCatalog([new DelimitedTextParser(), new KeyValueTextParser(), .. extra]);
+        var lastParser = extra.Length > 0 ? extra[0].Id : null;
+
+        var viewModel = new ParseViewModel(
+            catalog,
+            new FakeSettingsService(new AppSettings { LastParserId = lastParser }),
+            new ProxyPool([], new FakeProxyProbe(), new ProxyOptions()),
+            new EmptyServiceProvider(),
+            NullLogger<ParseViewModel>.Instance,
+            ImmediateSequencer.Instance
+        );
+
+        var view = new ParseView { DataContext = viewModel };
+        var window = new Window
+        {
+            Width = 1400,
+            Height = 900,
+            Content = view,
+        };
+
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        return (view, viewModel, window);
+    }
+
+    private static Border Banner(ParseView view) => view.FindControl<Border>("ProxyGateBanner").ShouldNotBeNull();
+
+    [AvaloniaFact]
+    public void No_banner_is_shown_for_a_parser_that_needs_no_network()
+    {
+        var (view, viewModel, _) = ShowPage();
+
+        viewModel.IsBlockedWithoutProxy.ShouldBeFalse();
+        Banner(view).IsVisible.ShouldBeFalse();
+    }
+
+    [AvaloniaFact]
+    public void A_blocked_network_parser_puts_the_banner_on_screen()
+    {
+        // Rendered rather than asserted on the view model: an IsVisible binding that never fires
+        // leaves the page silently unhelpful, which is exactly the failure this guards.
+        var (view, viewModel, _) = ShowPage(new NetworkParser());
+        Dispatcher.UIThread.RunJobs();
+
+        viewModel.IsBlockedWithoutProxy.ShouldBeTrue();
+        Banner(view).IsEffectivelyVisible.ShouldBeTrue();
+    }
+
+    [AvaloniaFact]
+    public void The_banner_offers_a_way_to_the_proxies_page()
+    {
+        var (view, viewModel, _) = ShowPage(new NetworkParser());
+        Dispatcher.UIThread.RunJobs();
+
+        var button = Banner(view).GetVisualDescendants().OfType<Button>().ShouldHaveSingleItem();
+
+        button.Command.ShouldBeSameAs(viewModel.GoToProxiesCommand);
+    }
+
+    [AvaloniaFact]
+    public void A_blocked_page_will_not_run_the_parser()
+    {
+        var (view, viewModel, _) = ShowPage(new NetworkParser());
+        viewModel.InputText = "anything";
+        Dispatcher.UIThread.RunJobs();
+
+        var run = view.GetVisualDescendants()
+            .OfType<Button>()
+            .First(candidate => ReferenceEquals(candidate.Command, viewModel.ParseCommand));
+
+        run.IsEffectivelyEnabled.ShouldBeFalse();
+    }
+
+    private sealed class EmptyServiceProvider : IServiceProvider
+    {
+        public object? GetService(Type serviceType) => null;
+    }
+
+    private sealed class NetworkParser : ITextParser
+    {
+        public string Id => "network";
+
+        public string DisplayName => "Network parser";
+
+        public string Description => "Fetches something";
+
+        public bool RequiresNetwork => true;
+
+        public bool CanParse(string input) => true;
+
+        public async IAsyncEnumerable<ParseOutcome<ParsedRecord>> ParseAsync(
+            string input,
+            IProgress<ParseProgress>? progress,
+            [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken
+        )
+        {
+            await Task.Yield();
+            yield break;
+        }
+    }
+}