Die Startseite am Fernseher — und die Ladeschicht nur einmal

Aufmacher, Reihen, Mediatheken, Raster. Der sichtbare Teil ist neu; der
Teil darunter ist derselbe wie am Telefon, und das war die eigentliche
Arbeit.

**Herausgelöst statt kopiert.** `HomeFeed` und `LibraryFeed` tragen jetzt,
was vorher in `HomeView` und `LibraryView` stand: laden, ordnen, den
Aufmacher auslosen, den Zwischenspeicher abziehen, entdoppeln, nach einem
Fehlschlag sperren. Das zu kopieren wäre der schlimmste Ausgang dieses
Vorhabens gewesen — an mindestens drei dieser Stellen klebte schon je ein
Fehler, der sich als „es sind nicht alle Filme drin" äusserte und sonst
nichts. Einer davon, das Los des Aufmachers an der Position statt am
Titel, wäre in einer Kopie ein zweites Mal zu finden gewesen.

Mitgewandert sind `rowTitle`, `rowArtworkPath`, `posterArtworkPath`,
`runtimeLabel` und `HeroArtwork`: reine Ableitungen, die in einer
Ansichtsdatei lagen und deshalb nur das Telefon übersetzte.

**Nachgeladen wird am Fokus, nicht am Erscheinen.** Die alte Regel hiess
„die letzten fünf" und hing daran, dass eine Kachel sichtbar wird. Beim
ersten Zeichnen erscheinen aber alle sechzig, auch die letzten fünf — das
Nachladen lief sofort los statt beim Blättern. Auf einem Raster aus sechs
Spalten sind fünf Einträge ausserdem nicht einmal eine Zeile. `PagingWindow`
rechnet deshalb in Zeilen; sechs Tests halten es fest, darunter der Fall,
der die alte Regel entlarvt.

**Der Fokus setzt den Aufmacher.** Wer durch „Zuletzt hinzugefügt"
wandert, sieht oben, was er gerade anschaut. Kein Wechsel im Sieben-
sekundentakt wie am Telefon: vor einem Fernseher wäre ein Bild, das sich
von allein austauscht, während man es liest, eine Zumutung.

**Drei Dinge, die erst der Simulator zeigte.** Die Seiten müssen
bildfüllend laufen, weil ein Aufmacher, der achtzig Punkte vor der
Bildschirmkante aufhört, nach Fehler aussieht — also trägt `screenMargin`
auf tvOS den Überscan mit. Die Karten brauchen einen Fokus-Rückruf, weil
`\.isFocused` den nächsten fokussierbaren Vorfahren meint und das in einer
Reihe aus Karten nicht verlässlich die Karte ist. Und der Bau scheiterte
an „Unable to resolve module dependency: VLCKit" — der Abhängigkeits-
Sucher prüft `canImport(FlixyVLC)` auch für ein Ziel, das es nie verlinkt.
Ein `&& !os(tvOS)` genügt; das Paket selbst bleibt unverändert.

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

Flixy/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)
+    }
+}