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>

Packages/HaloKit/Sources/HaloPlayback/Decision/PlayerQuality.swift

@@ -0,0 +1,208 @@
+import Foundation
+
+/// Eine im Player wählbare Qualitätsstufe.
+///
+/// Getrennt von den Einstellungen unter „Qualität": dort steht, was
+/// üblicherweise gelten soll; hier greift man für diesen einen Film ein — weil
+/// es gerade ruckelt oder weil man ausnahmsweise das Original will.
+public enum PlayerQuality: Hashable, Sendable, Identifiable {
+    /// Was in den Einstellungen für die aktuelle Verbindung hinterlegt ist.
+    case automatic
+    /// Die Datei unverändert, ohne Umrechnung.
+    case original
+    /// Eine Stufe der Leiter, die der Server anbietet.
+    case limited(Rung)
+    /// So wenig Bild wie möglich.
+    case audioOnly
+
+    /// Eine Sprosse: Bitrate und die Auflösung, die Plex dafür vorsieht.
+    ///
+    /// Die Werte stammen nicht aus der Luft, sondern aus dem, was der Server
+    /// über sich selbst sagt (`transcoderVideoBitrates`). Eine eigene Leiter
+    /// zu erfinden hieße, Stufen anzubieten, die der Transcoder gar nicht
+    /// kennt — er rundet dann still auf die nächste, und die Anzeige log.
+    public struct Rung: Hashable, Sendable {
+        public let bitrate: Int
+        public let height: Int
+
+        public init(bitrate: Int, height: Int) {
+            self.bitrate = bitrate
+            self.height = height
+        }
+
+        public var width: Int {
+            // 16:9, auf gerade Zahlen gerundet — ungerade Kantenlängen mag
+            // kein Kodierer.
+            let raw = Int((Double(height) * 16.0 / 9.0).rounded())
+            return raw % 2 == 0 ? raw : raw + 1
+        }
+
+        public var resolution: String { "\(width)x\(height)" }
+    }
+
+    /// Die Leiter von oben nach unten.
+    public static let ladder: [Rung] = [
+        Rung(bitrate: 20_000, height: 1080),
+        Rung(bitrate: 12_000, height: 1080),
+        Rung(bitrate: 10_000, height: 1080),
+        Rung(bitrate: 8_000, height: 1080),
+        Rung(bitrate: 4_000, height: 1080),
+        Rung(bitrate: 3_000, height: 720),
+        Rung(bitrate: 2_000, height: 720),
+        Rung(bitrate: 1_500, height: 720),
+        Rung(bitrate: 720, height: 480),
+        Rung(bitrate: 320, height: 360),
+        Rung(bitrate: 208, height: 360),
+        Rung(bitrate: 96, height: 240),
+        Rung(bitrate: 64, height: 160),
+    ]
+
+    /// Eine Zahl, die sich aufbewahren lässt.
+    ///
+    /// Über mehrere Filme hinweg gilt nur die **Absicht** — „ungefähr so viel
+    /// Bitrate" —, nicht die genaue Sprosse: welche Sprossen es gibt, hängt
+    /// von der Quelle ab. Deshalb eine Zahl und kein Aufzählungswert.
+    public var storageValue: Int {
+        switch self {
+        case .automatic: 0
+        case .original: -1
+        case .audioOnly: -2
+        case .limited(let rung): rung.bitrate
+        }
+    }
+
+    /// Die Stufe zu einer aufbewahrten Zahl, so nah wie möglich.
+    ///
+    /// Gibt es die Sprosse für diese Quelle nicht, wird die nächstgelegene
+    /// genommen — eine 720p-Datei kennt keine 20-Megabit-Stufe, und dann
+    /// stillschweigend auf „automatisch" zurückzufallen wäre eine andere
+    /// Antwort als die, um die gebeten wurde.
+    public static func restored(from value: Int, forSourceHeight height: Int?) -> PlayerQuality? {
+        switch value {
+        case 0: return nil
+        case -1: return .original
+        case -2: return .audioOnly
+        default: break
+        }
+
+        let rungs = available(forSourceHeight: height).compactMap { quality -> Rung? in
+            if case .limited(let rung) = quality { return rung }
+            return nil
+        }
+        guard let closest = rungs.min(by: {
+            abs($0.bitrate - value) < abs($1.bitrate - value)
+        }) else { return nil }
+        return .limited(closest)
+    }
+
+    public static var allCases: [PlayerQuality] {
+        [.automatic, .original] + ladder.map(PlayerQuality.limited) + [.audioOnly]
+    }
+
+    public var id: String {
+        switch self {
+        case .automatic: "automatic"
+        case .original: "original"
+        case .audioOnly: "audioOnly"
+        case .limited(let rung): "limited-\(rung.bitrate)"
+        }
+    }
+
+    /// Obergrenze in Kilobit. `nil` bei `automatic` und `original`.
+    public var maximumBitrate: Int? {
+        switch self {
+        case .automatic, .original: nil
+        case .limited(let rung): rung.bitrate
+        // Plex kennt für Videos keinen reinen Tonstrom. Die unterste Sprosse
+        // ist das, was dem am nächsten kommt; das Bild wird dazu im Player
+        // ausgeblendet, damit der Schirm dunkel bleiben kann.
+        case .audioOnly: Self.ladder.last?.bitrate
+        }
+    }
+
+    public var resolution: String? {
+        switch self {
+        case .automatic, .original: nil
+        case .limited(let rung): rung.resolution
+        case .audioOnly: Self.ladder.last?.resolution
+        }
+    }
+
+    /// Die Höhe in Bildzeilen, sofern die Stufe eine vorgibt.
+    public var height: Int? {
+        switch self {
+        case .automatic, .original: nil
+        case .limited(let rung): rung.height
+        case .audioOnly: Self.ladder.last?.height
+        }
+    }
+
+    /// Ob das Bild gezeigt werden soll.
+    public var showsVideo: Bool {
+        if case .audioOnly = self { return false }
+        return true
+    }
+
+    /// Ob diese Stufe eine Umrechnung erzwingt.
+    ///
+    /// `original` erzwingt das Gegenteil: keine Umrechnung, auch wenn die
+    /// Einstellungen eine Grenze vorsehen.
+    public var forcesTranscode: Bool {
+        switch self {
+        case .automatic, .original: false
+        case .limited, .audioOnly: true
+        }
+    }
+
+    /// Die Richtlinie für diese Stufe.
+    ///
+    /// `automatic` reicht durch, was ohnehin gilt. Die übrigen überschreiben
+    /// sie — das ist der Zweck eines Eingriffs im Player.
+    public func policy(basedOn base: PlaybackPolicy) -> PlaybackPolicy {
+        switch self {
+        case .automatic:
+            base
+        case .original:
+            // Keine Grenze und kein Umrechnen: ausdrücklich das Original.
+            PlaybackPolicy(allowsTranscoding: false, maximumBitrate: nil)
+        case .limited, .audioOnly:
+            PlaybackPolicy(
+                allowsTranscoding: true,
+                maximumBitrate: maximumBitrate,
+                forcesTranscoding: true
+            )
+        }
+    }
+
+    /// Die kurze Liste: je Auflösung eine Stufe, und zwar eine brauchbare.
+    ///
+    /// Dreizehn Sprossen sind für den Normalfall zu viel — man will „geht
+    /// gerade nicht flüssig, nimm eine Stufe kleiner", nicht die Wahl
+    /// zwischen zehn und zwölf Megabit. Die vollständige Leiter bleibt
+    /// erreichbar, steht aber nicht im Weg.
+    public static let everyday: [Rung] = [
+        Rung(bitrate: 8_000, height: 1080),
+        Rung(bitrate: 3_000, height: 720),
+        Rung(bitrate: 720, height: 480),
+    ]
+
+    /// Die kurze Auswahl für eine Quelle dieser Höhe.
+    public static func everyday(forSourceHeight height: Int?) -> [PlayerQuality] {
+        let rungs = everyday.filter { height == nil || $0.height <= (height ?? 0) }
+        let usable = rungs.isEmpty ? Array(everyday.suffix(1)) : rungs
+        return [.automatic, .original] + usable.map(PlayerQuality.limited) + [.audioOnly]
+    }
+
+    /// Nur die Stufen, die für eine Quelle dieser Höhe sinnvoll sind.
+    ///
+    /// Eine 720p-Datei auf 1080p „hochzurechnen" bringt kein Bild dazu, und
+    /// die Stufen sähen alle gleich aus — dieselbe Falle wie beim Herunterladen.
+    public static func available(forSourceHeight height: Int?) -> [PlayerQuality] {
+        guard let height, height > 0 else { return allCases }
+        let fitting = ladder.filter { $0.height <= height }
+        // Mindestens die unterste Sprosse anbieten, sonst bliebe bei einer
+        // sehr kleinen Quelle nur „Original".
+        let rungs = fitting.isEmpty ? Array(ladder.suffix(1)) : fitting
+        return [.automatic, .original] + rungs.map(PlayerQuality.limited) + [.audioOnly]
+    }
+}