Die Sprache lässt sich jetzt auch je Serie und je Mediathek sagen

Das Regelwerk stand schon und wurde abgefragt — es gab nur keinen Ort, an
dem man etwas hineinschreiben konnte. Jetzt steht die Wahl auf der
Serienseite und im Filter-Sheet der Mediathek, beide über denselben
Auswahlknopf: zwei mit demselben Inhalt liefen unweigerlich auseinander.

Bei der Mediathek in einem eigenen Abschnitt, nicht zwischen den Filtern.
Ein Filter schränkt ein, was zu sehen ist; das hier bestimmt, was zu hören
ist — dazwischengestellt läse es sich als „nur Titel mit deutscher Tonspur
zeigen".

Die Rangfolge Serie → Mediathek → allgemein ist dabei von den Einstellungen
zu `AudioTrackChooser.resolve` gewandert. Sie ist eine Regel, keine Ablage,
und im App-Ziel gibt es kein Unit-Test-Ziel — dort liesse sie sich nicht
durchspielen. Sechs Tests decken sie jetzt ab, darunter der Fall, an dem
man sonst lange sucht: eine leere Zeichenkette steht in den Einstellungen
für „soll der Server entscheiden" und darf nicht als Sprache gelten, sonst
schaltet sie die Ebene darüber stillschweigend ab.

Nebenbei bekommt das Filter-Sheet die Mediathek selbst statt nur ihrer Art.
Die Genres wurden vorher über irgendeine Mediathek dieser Art nachgeschlagen
— bei zwei Filmmediatheken also über die falsche.

Und der Puffer steht auf einer Minute statt auf 25 Sekunden. Es ist ein
Mindestwunsch, keine Obergrenze; der harte Deckel liegt ohnehin woanders,
nämlich darin, wie weit der Transcoder schon produziert hat.

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

Packages/FlixyKit/Sources/FlixyPlayback/Decision/AudioTrackChooser.swift

@@ -44,6 +44,42 @@ public enum AudioTrackChooser {
         }
     }
 
+    /// Drei Ebenen, eine Antwort.
+    ///
+    ///     Serie  →  Mediathek  →  allgemein
+    ///
+    /// Gefragt wird von unten nach oben; die erste Antwort gilt. Bei Filmen
+    /// gibt es die Serienebene nicht, dort endet es bei der Mediathek.
+    ///
+    /// **Warum die Rangfolge hier steht und nicht bei den Einstellungen.**
+    /// Weil sie eine Regel ist, keine Ablage. Im App-Ziel liesse sie sich
+    /// nicht mit einer Wertefolge durchspielen — hier schon, und das ist der
+    /// Unterschied zwischen einer geprüften und einer geglaubten Rangfolge.
+    ///
+    /// Eine leere Zeichenkette zählt als „nichts gesagt": in den Einstellungen
+    /// steht sie für „soll der Server entscheiden", und das ist keine Sprache,
+    /// sondern das Ausbleiben einer Antwort.
+    public static func resolve(
+        series: String?,
+        library: String?,
+        general: String?,
+        fallbacks: [String] = [],
+        remembered: TrackSignature? = nil,
+        avoidsAudioDescription: Bool = true
+    ) -> Wish {
+        func gesagt(_ wert: String?) -> String? {
+            guard let wert, !wert.trimmingCharacters(in: .whitespaces).isEmpty else { return nil }
+            return wert
+        }
+
+        return Wish(
+            language: gesagt(series) ?? gesagt(library) ?? gesagt(general),
+            fallbacks: fallbacks,
+            remembered: remembered,
+            avoidsAudioDescription: avoidsAudioDescription
+        )
+    }
+
     /// Wie eine Spur aussieht — genug, um sie in der nächsten Folge
     /// wiederzuerkennen.
     ///

Packages/FlixyKit/Tests/FlixyPlaybackTests/AudioTrackChooserTests.swift

@@ -200,3 +200,64 @@ struct AudioTrackChooserTests {
         #expect(AudioTrackChooser.choose(from: spuren, wish: .init(language: "de"))?.id == "0")
     }
 }
+
+@Suite("Rangfolge der drei Ebenen")
+struct WishResolutionTests {
+    /// Serie schlägt Mediathek schlägt allgemein. Das ist der ganze Zweck der
+    /// Abstufung — und der einzige Ort, an dem sie steht.
+    @Test("Die Serie gewinnt")
+    func seriesWins() {
+        let wunsch = AudioTrackChooser.resolve(series: "en", library: "fr", general: "de")
+        #expect(wunsch.language == "en")
+    }
+
+    @Test("Ohne Serie gewinnt die Mediathek")
+    func libraryWinsWithoutSeries() {
+        #expect(AudioTrackChooser.resolve(series: nil, library: "fr", general: "de").language == "fr")
+    }
+
+    @Test("Ohne beides gilt die allgemeine")
+    func generalIsTheFloor() {
+        #expect(AudioTrackChooser.resolve(series: nil, library: nil, general: "de").language == "de")
+    }
+
+    /// In den Einstellungen steht eine leere Zeichenkette für „soll der Server
+    /// entscheiden". Sie als Sprache zu behandeln hiesse, die Ebene darüber
+    /// stillschweigend abzuschalten — genau der Fehler, den man erst bemerkt,
+    /// wenn eine Einstellung scheinbar wirkungslos ist.
+    @Test("Leer heisst nichts gesagt, nicht eine Sprache namens leer")
+    func emptyIsNotAnAnswer() {
+        #expect(AudioTrackChooser.resolve(series: "", library: "fr", general: "de").language == "fr")
+        #expect(AudioTrackChooser.resolve(series: " ", library: "", general: "de").language == "de")
+        #expect(AudioTrackChooser.resolve(series: nil, library: nil, general: "").language == nil)
+    }
+
+    /// Die Rangliste ist keine vierte Ebene: sie gilt überall gleich und wird
+    /// von keiner Ebene überstimmt.
+    @Test("Rangliste und Schalter gehen unverändert durch")
+    func theRestPassesThrough() {
+        let wunsch = AudioTrackChooser.resolve(
+            series: nil, library: nil, general: "de",
+            fallbacks: ["gsw", "en"], avoidsAudioDescription: false
+        )
+        #expect(wunsch.fallbacks == ["gsw", "en"])
+        #expect(wunsch.avoidsAudioDescription == false)
+    }
+
+    /// Der ZDF-Fall durch die ganze Kette: die Mediathek sagt Deutsch, die
+    /// gemerkte Spur sagt etwas anderes — und behält recht.
+    @Test("Die gemerkte Spur überlebt die Rangfolge")
+    func rememberedSurvives() {
+        let spuren = [
+            MediaStream(id: "0", kind: .audio, language: "ger", languageCode: "ger",
+                        channels: 2, title: "Deutsch (Audiodeskription)", isDefault: true),
+            MediaStream(id: "1", kind: .audio, language: "eng", languageCode: "eng",
+                        channels: 2, title: "Deutsch"),
+        ]
+        let wunsch = AudioTrackChooser.resolve(
+            series: nil, library: "de", general: "en",
+            remembered: AudioTrackChooser.TrackSignature(spuren[1])
+        )
+        #expect(AudioTrackChooser.choose(from: spuren, wish: wunsch)?.id == "1")
+    }
+}