Flixy heißt ab hier Halo

Reine Umbenennung, kein Verhalten geändert — bewusst als eigener Commit,
damit „umbenannt" und „umgebaut" im Nachhinein auseinanderzuhalten sind.

712 mal `Flixy`, 778 mal `flixy`, 7 mal `FLIXY` in 169 Dateien, dazu 25
Pfade. Ziele: `Halo`, `HaloTV`, `HaloTopShelf`, `HaloUITests`, `HaloKit` mit
`HaloDesign`, `HaloDownloads`, `HaloPlayback` und `HaloProbe`. `MediaKit`,
`JellyfinKit` und `DownloadWidget` tragen den Namen nicht und bleiben.

`docs/superpowers/specs/` ist ausgenommen. Datierte Entwurfsdokumente sind
ein Protokoll getroffener Entscheidungen; sie nachträglich umzuschreiben
hiesse, die Vergangenheit zu glätten.

**Die Bundle-ID wandert mit** — ausdrücklich so gewollt, mit bekanntem Preis:
`com.scarriffleservices.halo` ist für iOS eine *andere* App. Die installierte
Fassung bleibt daneben stehen, mit Downloads und Anmeldung in ihrem Container;
Halo startet leer. Einmal neu anmelden, heruntergeladene Folgen einmal neu
laden. Dasselbe gilt für die App-Gruppe, die sich TV-App und Top Shelf teilen.

**Eine Folge davon, die beim Entscheiden noch nicht auf dem Tisch lag:** der
Aufräumschritt aus dem vorigen Commit kommt an die alten Plex-Token nicht mehr
heran. Der Schlüsselbund grenzt nach Team und Bundle-Kennung ab — was unter
`…flixy` liegt, ist für `…halo` unerreichbar. Erledigt wird es trotzdem, nur
anders: **die alte App löschen.** iOS räumt deren Schlüsselbund-Einträge beim
Deinstallieren mit ab. Der Code bleibt stehen, weil er für jeden Stand vor
dieser Umbenennung richtig ist und im Jahr einen Startvergleich kostet.

Die Projektdatei ist aus `project.yml` neu erzeugt, der alte Ordner gelöscht
statt umbenannt — sie steht ohnehin nicht im Repo.

Das Verzeichnis des Repos selbst heißt weiter `Flixy`; das umzubenennen ist
ein Handgriff ausserhalb des Projekts.

368 Tests grün. iOS und tvOS bauen.

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

Halo/Session/LibraryFeed.swift

@@ -0,0 +1,131 @@
+import MediaKit
+import Observation
+
+/// Eine Mediathek als Modell: laden, nachladen, entdoppeln.
+///
+/// **Der teuerste Brocken, den man hätte kopieren können.** Hier stecken der
+/// Abzug aus dem Zwischenspeicher, der Seitenversatz, die Entdoppelung gegen
+/// Plex-Serverscans und die Sperre nach einem Fehlschlag — und an mindestens
+/// zwei davon hat schon je ein Fehler geklebt, der sich als „es sind nicht
+/// alle Filme drin" äusserte und sonst nichts. Ein zweites Mal wären sie in
+/// einer Kopie zu finden gewesen.
+///
+/// **Was das Nachladen auslöst, steht hier nicht.** Am Telefon ist es das
+/// Erscheinen einer Kachel, am Fernseher der Fokus. Die Regel selbst —
+/// `PagingWindow` — ist ein reiner Typ mit Tests.
+@MainActor
+@Observable
+final class LibraryFeed {
+    let library: MediaLibrary
+
+    private(set) var items: [MediaItem] = []
+    private(set) var state: LoadState<Void> = .loading
+    private(set) var page: MediaPage?
+    /// Ob der letzte Nachladeversuch misslungen ist.
+    ///
+    /// Dann passiert von selbst nichts mehr, und es braucht einen Knopf: die
+    /// Kacheln, die das Nachladen auslösen, sind längst erschienen und
+    /// erscheinen kein zweites Mal.
+    private(set) var loadMoreFailed = false
+    private(set) var isLoadingMore = false
+
+    var query = MediaQuery()
+
+    init(library: MediaLibrary) {
+        self.library = library
+    }
+
+    /// Wie viele Platzhalter noch unter dem Geladenen stehen.
+    var pendingCount: Int {
+        guard let page else { return 0 }
+        return max(0, page.totalCount - items.count)
+    }
+
+    func reload(from backend: (any MediaBackend)?) async {
+        guard let server = backend else { return }
+        let schlüssel = query.cacheKey
+        let kennung = server.identity
+
+        // Nur wenn nichts dasteht. Beim Aktualisieren und beim Filterwechsel
+        // ist das Gezeigte aktueller als jeder Abzug.
+        if items.isEmpty,
+           let stand = await LibraryCache.shared.snapshot(
+               server: kennung, library: library.id, queryKey: schlüssel
+           ) {
+            items = stand.items
+            page = MediaPage(items: stand.items, totalCount: stand.totalCount)
+            state = .loaded(())
+        } else if items.isEmpty {
+            state = .loading
+        }
+
+        do {
+            let erste = try await server.items(
+                inLibrary: library, query: query, offset: 0, limit: 60
+            )
+            items = erste.items
+            page = erste
+            loadMoreFailed = false
+            state = .loaded(())
+
+            await LibraryCache.shared.store(
+                LibraryCache.Snapshot(
+                    queryKey: schlüssel, items: erste.items, totalCount: erste.totalCount
+                ),
+                server: kennung,
+                library: library.id
+            )
+        } catch {
+            // Siehe `LoadState.load`: eine abgebrochene Netzanfrage meldet
+            // sich als Übertragungsfehler, nicht als Abbruch.
+            if Task.isCancelled { return }
+            // Steht schon etwas da — aus dem Speicher oder von vorhin —, dann
+            // bleibt es. Den Fehler über eine brauchbare Liste zu legen nähme
+            // dem Nutzer etwas weg, statt ihm etwas zu sagen.
+            guard items.isEmpty else { return }
+            state = .failed(message: ErrorText.describe(error))
+        }
+    }
+
+    func loadMore(from backend: (any MediaBackend)?) async {
+        guard let server = backend, let page, !isLoadingMore,
+              items.count < page.totalCount
+        else { return }
+
+        isLoadingMore = true
+        loadMoreFailed = false
+        defer { isLoadingMore = false }
+
+        do {
+            let nächste = try await server.items(
+                inLibrary: library, query: query, offset: page.nextOffset, limit: 60
+            )
+            // **Anhängen, nie ersetzen.** Plex kann bei gleichzeitigem
+            // Serverscan denselben Titel auf zwei Seiten liefern; ohne diese
+            // Prüfung stünde er doppelt im Raster, und SwiftUI beschwert sich
+            // über doppelte Kennungen. Und auf dem Fernseher hinge daran noch
+            // mehr: würde `items` als Ganzes ersetzt, verlöre der Fokus mitten
+            // im Scrollen seinen Halt und spränge an den Anfang.
+            let bekannt = Set(items.map(\.id))
+            items.append(contentsOf: nächste.items.filter { !bekannt.contains($0.id) })
+            self.page = nächste
+        } catch {
+            // **Nicht `page = nil`.** Das stand hier einmal, und es beendete
+            // das Nachladen **endgültig**: eine einzige misslungene Anfrage
+            // auf einer wackeligen Leitung, und die Mediathek blieb für immer
+            // bei sechzig Titeln stehen — lautlos. Genau so sieht „es sind
+            // nicht alle Filme drin" aus.
+            loadMoreFailed = true
+        }
+    }
+
+    /// Ob der Eintrag an dieser Stelle nah genug am Ende liegt.
+    ///
+    /// Die Regel steht in `PagingWindow`; hier steht nur, woher die Zahlen
+    /// kommen. **Was das auslöst**, entscheidet die Ansicht.
+    func shouldLoadMore(at index: Int, columns: Int) -> Bool {
+        guard !loadMoreFailed, !isLoadingMore, let page else { return false }
+        return PagingWindow(columns: columns)
+            .shouldLoad(focusedIndex: index, loaded: items.count, total: page.totalCount)
+    }
+}