Die Ansichten sprechen nicht mehr mit Plex

Start, Suche, Mediathek, Detailseiten und Downloads arbeiten jetzt mit
`MediaItem` und dem `MediaBackend`-Vertrag. Damit sind sie fertig für
einen zweiten Server, ohne dass an ihnen noch etwas zu tun wäre.

Dabei sind ein paar Namen ehrlicher geworden: aus `grandparentTitle`
wurde `seriesTitle`, aus `viewedLeafCount` `playedEpisodeCount`. Und
`TagStrip` nahm bisher Plex-Marken mit Kennung und Rolle entgegen, um
davon nur den Namen anzuzeigen — Genres sind jetzt schlicht Zeichenketten.

`Arrangement` ist aus PlexKit heraus und generisch: dieselbe Rechnung
gilt für jede Liste, die jemand selbst zusammenstellt. Phase 3 baut die
konfigurierbare Seitenleiste darauf, statt sie ein zweites Mal — und ein
zweites Mal falsch — zu schreiben.

Die Fehlerübersetzung gibt es nur noch einmal. Es waren zwei, und sie
waren bereits auseinandergelaufen: derselbe Fehler bekam je nach
Bildschirm eine andere Erklärung.

Das Nachladen der Mediathek bleibt unangetastet: eine lange Liste, die
fünf Einträge vor dem Ende nachlädt. `MediaPage` heißt zwar Seite, ist
aber eine technische Portion — Blättern mit „weiter zu Seite 2" gehört
nicht in eine Mediathek, in der man stöbert. Der Kommentar dort sagt das
jetzt ausdrücklich, damit es niemand später „aufräumt".

Player, Live-TV und die Download-Engine sprechen noch unmittelbar mit
Plex. Sie folgen als Nächstes.

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

Packages/FlixyKit/Sources/MediaKit/Arrangement.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+/// Etwas, das der Nutzer ausblenden und verschieben kann.
+public protocol Arrangeable {
+    /// Eine Kennung, die über Abrufe hinweg gleich bleibt.
+    ///
+    /// **Nicht** der angezeigte Titel: benennt der Server eine Reihe oder eine
+    /// Mediathek um, wäre sonst alles Gespeicherte hinfällig.
+    var arrangementID: String { get }
+    var arrangementTitle: String { get }
+}
+
+/// Was ausgeblendet ist und in welcher Reihenfolge der Rest steht.
+///
+/// War bis eben an die Startseiten-Reihen von Plex gebunden. Die Rechnung ist
+/// dieselbe für jede Liste, die jemand selbst zusammenstellt — Reihen,
+/// Seitenleisteneinträge, Sender. Sie ein zweites Mal zu schreiben hieße, sie
+/// ein zweites Mal falsch zu machen.
+public struct Arrangement: Sendable, Equatable {
+    public var hidden: Set<String>
+    public var order: [String]
+
+    public init(hidden: Set<String> = [], order: [String] = []) {
+        self.hidden = hidden
+        self.order = order
+    }
+
+    /// Wendet Auswahl und Reihenfolge an.
+    ///
+    /// Unbekannte Einträge landen am Ende statt zu verschwinden. Sie zu
+    /// verwerfen wäre die einfachere Regel — und der Grund dafür, dass ein
+    /// neu angelegtes Regal auf dem Server in der App nie aufgetaucht wäre.
+    public func apply<Element: Arrangeable>(to elements: [Element]) -> [Element] {
+        let visible = elements.filter { !hidden.contains($0.arrangementID) }
+        guard !order.isEmpty else { return visible }
+
+        let positions = Dictionary(
+            order.enumerated().map { ($1, $0) },
+            // Ein doppelter Eintrag in der gespeicherten Reihenfolge — etwa
+            // nach einem fehlgeschlagenen Schreibvorgang — soll nicht
+            // abstürzen. Die erste Position gewinnt.
+            uniquingKeysWith: { first, _ in first }
+        )
+
+        return visible.enumerated().sorted { left, right in
+            let leftPosition = positions[left.element.arrangementID] ?? Int.max
+            let rightPosition = positions[right.element.arrangementID] ?? Int.max
+            // Bei gleicher Position — beide unbekannt — bleibt die Reihenfolge
+            // des Servers erhalten. Ohne diese Rückfalllinie wäre die
+            // Anordnung neuer Einträge zufällig.
+            if leftPosition == rightPosition { return left.offset < right.offset }
+            return leftPosition < rightPosition
+        }.map(\.element)
+    }
+
+    /// Die Liste für den Einstellungsbildschirm: gespeicherte Reihenfolge
+    /// zuerst, danach alles Übrige.
+    ///
+    /// Gespeicherte Einträge, die es nicht mehr gibt, fallen heraus — sie
+    /// anzuzeigen hieße, eine Reihe anzubieten, die niemand mehr hat.
+    public func arrangedIdentifiers<Element: Arrangeable>(from elements: [Element]) -> [String] {
+        let available = elements.map(\.arrangementID)
+        let known = Set(available)
+        let stored = order.filter(known.contains)
+        return stored + available.filter { !stored.contains($0) }
+    }
+}
+
+extension MediaRowGroup: Arrangeable {
+    public var arrangementID: String { id }
+    public var arrangementTitle: String { title }
+}

Packages/FlixyKit/Sources/MediaKit/MediaBackend.swift

@@ -43,6 +43,22 @@ public protocol MediaBackend: Sendable {
     nonisolated func artworkURL(path: String?, width: Int, height: Int) -> URL?
     nonisolated func rawImageURL(path: String?) -> URL?
 
+    // MARK: - Herunterladen
+
+    /// Die Adresse, unter der eine Datei unverändert zu holen ist.
+    nonisolated func downloadURL(for file: MediaFile) -> URL?
+
+    /// Die Adresse für eine verkleinerte Fassung.
+    ///
+    /// `nil`, wenn der Server das nicht anbietet — dann bleibt nur das
+    /// Original, und die Oberfläche soll die Wahl gar nicht erst zeigen.
+    nonisolated func compressedDownloadURL(
+        itemID: String,
+        versionIndex: Int,
+        maximumBitrate: Int,
+        resolution: String?
+    ) -> URL?
+
     // MARK: - Zustand melden
 
     func markWatched(id: String) async throws(MediaBackendError)
@@ -67,16 +83,27 @@ public enum BackendCapability: String, Sendable, Hashable {
     case transcoding
 }
 
-/// Eine Seite aus einer Mediathek.
+/// Ein Ausschnitt aus einer Mediathek.
+///
+/// „Seite" ist hier eine technische Portion, **keine Seite in der Oberfläche**.
+/// Die Mediathek ist eine einzige lange Liste, die nachlädt, sobald man sich
+/// dem Ende nähert — Blättern mit „weiter zu Seite 2" gehört nicht in eine
+/// Mediathek, in der man stöbert.
 public struct MediaPage: Sendable, Equatable {
     public let items: [MediaItem]
+    /// Ab welcher Stelle dieser Ausschnitt beginnt.
+    public let offset: Int
     /// Wie viele es insgesamt gibt — Grundlage fürs Nachladen.
-    public let totalCount: Int?
+    public let totalCount: Int
 
-    public init(items: [MediaItem], totalCount: Int? = nil) {
+    public init(items: [MediaItem], offset: Int = 0, totalCount: Int) {
         self.items = items
+        self.offset = offset
         self.totalCount = totalCount
     }
+
+    public var hasMore: Bool { offset + items.count < totalCount }
+    public var nextOffset: Int { offset + items.count }
 }
 
 /// Ein möglicher Wert für einen Filter.

Packages/FlixyKit/Sources/MediaKit/MediaVersion.swift

@@ -62,6 +62,31 @@ public struct MediaVersion: Sendable, Equatable, Identifiable {
         }
     }
 
+    /// Die Auflösung als Wort — „4K", „1080p".
+    ///
+    /// Aus der Bildhöhe, nicht aus dem Namen des Servers: Plex sagt „4k",
+    /// Jellyfin gibt Zahlen. Gemeint ist dasselbe.
+    public var resolutionLabel: String? {
+        guard let pixelHeight else { return videoResolution?.uppercased() }
+        switch pixelHeight {
+        case 1_600...: return "4K"
+        case 1_000..<1_600: return "1080p"
+        case 700..<1_000: return "720p"
+        case 1..<700: return "SD"
+        default: return nil
+        }
+    }
+
+    /// Eine kurze Beschreibung für die Versionsauswahl, etwa
+    /// „4K · HEVC · 38 Mbit/s".
+    public var qualityLabel: String {
+        var pieces: [String] = []
+        if let label = resolutionLabel { pieces.append(label) }
+        if let videoCodec { pieces.append(videoCodec.uppercased()) }
+        if let bitrate { pieces.append("\(bitrate / 1000) Mbit/s") }
+        return pieces.joined(separator: " · ")
+    }
+
     /// Was die Wiedergabe-Entscheidung über diese Fassung wissen muss.
     public func profile(file: MediaFile?) -> MediaProfile {
         MediaProfile(