feat: data lifecycle rewrite, download clients, wanted list, and central catalog index

Ships the fresh-start schema cleanup: rebuilt explore catalog index
pipeline (dump import, artifact fetch/build, incremental listen-count
refresh), a new download subsystem (Lidarr/Prowlarr/qBittorrent/SABnzbd/
slskd/yt-dlp providers, staging, reconciliation, wanted list), and the
supporting schema/query/store changes across backend and frontend.

Also includes two smaller follow-ups: bump the central index's
rebuild-after cadence from 90 to 180 days, and remove the Explore
"library only" online/offline toggle entirely (frontend-only, no
backend counterpart) rather than carry unused UI/state.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y2Agd9af5hE7qzti2ackiS

backend/download/concurrency_test.go

@@ -0,0 +1,215 @@
+package download
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestConcurrencyForPrefersOverrideThenKind(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		cfg  Config
+		want int
+	}{
+		{
+			name: "slskd defaults to one",
+			cfg:  Config{Kind: KindSlskd},
+			want: 1,
+		},
+		{
+			name: "usenet defaults higher",
+			cfg:  Config{Kind: KindSABnzbd},
+			want: 4,
+		},
+		{
+			name: "explicit override wins",
+			cfg: Config{
+				Kind:     KindSlskd,
+				Settings: map[string]string{concurrencyKey: "3"},
+			},
+			want: 3,
+		},
+		{
+			name: "nonsense override falls back",
+			cfg: Config{
+				Kind:     KindSlskd,
+				Settings: map[string]string{concurrencyKey: "not a number"},
+			},
+			want: 1,
+		},
+		{
+			name: "zero override falls back",
+			cfg: Config{
+				Kind:     KindSlskd,
+				Settings: map[string]string{concurrencyKey: "0"},
+			},
+			want: 1,
+		},
+		{
+			name: "unknown kind falls back to the global default",
+			cfg:  Config{Kind: Kind("something-new")},
+			want: defaultConcurrency,
+		},
+	}
+
+	for _, tt := range tests {
+		if got := concurrencyFor(tt.cfg); got != tt.want {
+			t.Errorf("%s: got %d, want %d", tt.name, got, tt.want)
+		}
+	}
+}
+
+// The reason the per-provider cap exists: a Soulseek daemon capped at
+// one transfer must serialize, even when the global cap would allow
+// more and the user has queued several albums at once.
+func TestPerProviderCapSerializesTransfers(t *testing.T) {
+	t.Parallel()
+
+	f := newManagerFixture(t)
+	f.manager.SetMaxConcurrent(4)
+
+	slow := fakeWithAlbum(1, "slskd-like", ".flac")
+	slow.GrabGate = make(chan struct{})
+
+	f.manager.installProvider(Config{
+		ID:       1,
+		Kind:     KindSlskd,
+		Priority: 50,
+	}, slow)
+
+	ctx := context.Background()
+
+	// Three requests against the same one-at-a-time provider.
+	for i := range 3 {
+		req := fourTrackRequest()
+		req.ID = "req-" + string(rune('a'+i))
+
+		if err := f.store.CreateRequest(ctx, req); err != nil {
+			t.Fatalf("CreateRequest: %v", err)
+		}
+
+		candidate := slow.Candidates[0]
+		candidate.ProviderID = 1
+
+		go f.manager.grab(ctx, req, candidate, nil)
+	}
+
+	// Give all three a chance to reach the transport, then check how
+	// many actually got through the gate.
+	waitFor(t, func() bool { return slow.GrabCallCount() >= 1 }, "no grab started")
+	time.Sleep(150 * time.Millisecond)
+
+	if got := slow.MaxParallelGrabs(); got != 1 {
+		t.Errorf("%d simultaneous transfers, want 1", got)
+	}
+
+	close(slow.GrabGate)
+
+	waitFor(
+		t,
+		func() bool { return slow.GrabCallCount() == 3 },
+		"not every queued transfer ran once the first finished",
+	)
+
+	if got := slow.MaxParallelGrabs(); got != 1 {
+		t.Errorf("%d simultaneous transfers overall, want 1", got)
+	}
+}
+
+// A provider that tolerates parallelism is not held to Soulseek's
+// limit, and the global cap is what bounds it.
+func TestPerProviderCapAllowsParallelWhereSafe(t *testing.T) {
+	t.Parallel()
+
+	f := newManagerFixture(t)
+	f.manager.SetMaxConcurrent(4)
+
+	fast := fakeWithAlbum(1, "usenet-like", ".flac")
+	fast.GrabGate = make(chan struct{})
+
+	f.manager.installProvider(Config{
+		ID:       1,
+		Kind:     KindSABnzbd,
+		Priority: 50,
+	}, fast)
+
+	ctx := context.Background()
+
+	for i := range 3 {
+		req := fourTrackRequest()
+		req.ID = "req-" + string(rune('a'+i))
+
+		if err := f.store.CreateRequest(ctx, req); err != nil {
+			t.Fatalf("CreateRequest: %v", err)
+		}
+
+		candidate := fast.Candidates[0]
+		candidate.ProviderID = 1
+
+		go f.manager.grab(ctx, req, candidate, nil)
+	}
+
+	waitFor(
+		t,
+		func() bool { return fast.MaxParallelGrabs() >= 3 },
+		"transfers were serialized against a provider that allows parallelism",
+	)
+
+	close(fast.GrabGate)
+}
+
+// Reload must not strand a running transfer's slot when a provider's
+// limit changes underneath it.
+func TestSyncSemaphoresReplacesChangedLimits(t *testing.T) {
+	t.Parallel()
+
+	f := newManagerFixture(t)
+
+	f.manager.installProvider(Config{ID: 1, Kind: KindSlskd}, nil)
+
+	first := f.manager.semaphoreFor(1)
+	if cap(first) != 1 {
+		t.Fatalf("slskd semaphore cap = %d, want 1", cap(first))
+	}
+
+	// Same limit: the semaphore is kept, so in-flight accounting is not
+	// reset by an unrelated settings save.
+	f.manager.syncSemaphores(map[int64]Config{1: {ID: 1, Kind: KindSlskd}})
+
+	if again := f.manager.semaphoreFor(1); again != first {
+		t.Error("semaphore was replaced despite an unchanged limit")
+	}
+
+	// Changed limit: a new semaphore, with the new capacity.
+	f.manager.syncSemaphores(map[int64]Config{1: {
+		ID:       1,
+		Kind:     KindSlskd,
+		Settings: map[string]string{concurrencyKey: "5"},
+	}})
+
+	f.manager.provMu.Lock()
+	f.manager.configs[1] = Config{
+		ID:       1,
+		Kind:     KindSlskd,
+		Settings: map[string]string{concurrencyKey: "5"},
+	}
+	f.manager.provMu.Unlock()
+
+	if changed := f.manager.semaphoreFor(1); cap(changed) != 5 {
+		t.Errorf("semaphore cap = %d after raising the limit, want 5", cap(changed))
+	}
+
+	// A provider that is gone leaves no semaphore behind.
+	f.manager.syncSemaphores(map[int64]Config{})
+
+	f.manager.semMu.Lock()
+	_, still := f.manager.provSem[1]
+	f.manager.semMu.Unlock()
+
+	if still {
+		t.Error("semaphore survived the provider being removed")
+	}
+}