Der Player weiß jetzt, wie es ihm geht

Bisher gab es über eine laufende Wiedergabe zwei Zahlen — gemessene
Bitrate und verworfene Bilder —, und die standen nur zur Anzeige da. Die
Frage „trägt die Leitung das gerade" war nicht zu beantworten, weder für
den Nutzer noch für die App.

**Die wichtigste neue Zahl ist `variantCount`.** Sie kommt aus
`AVAsset.variants`, also vom Parser des Players, und beantwortet die
Frage, ob es überhaupt etwas zum Umschalten gibt. Steht dort 1, greift
jedes Nachregeln ins Leere — und genau das ist heute der Fall, weil die
App bei beiden Servern eine Playlist mit einer Stufe bestellt.

Dazu der Pufferstand aus `loadedTimeRanges`: der einzige echte
Frühwarner. Schrumpft er schneller, als die Zeit vergeht, kommt weniger
herein als hinausgeht — zehn bis zwanzig Sekunden, bevor das Bild steht.
Alles andere meldet sich erst danach.

**Verworfene Bilder werden jetzt über alle Protokolleinträge summiert.**
Das Zugriffsprotokoll legt bei jedem Stufenwechsel einen neuen an, dessen
Zähler bei null beginnt; wer nur `last` liest, hält eine Wiedergabe für
makellos, die schon zwanzigmal Bilder verworfen hat.

**Der Wachhund war blind für den häufigsten Fall.** Vierzig Sekunden am
Stück ohne Daten brechen ab — aber er setzte sich bei jedem kurzen
Erholen zurück, und zehn Rückler à dreißig Sekunden lösten ihn nie aus.
`StallLedger` zählt daneben mit, wie viel Zeit im gleitenden Fenster
fürs Warten draufging. Es bricht nichts ab, es stellt nur fest — und ist
ein reiner Typ ohne Uhr und ohne AVFoundation, damit sich eine Folge von
Rücklern als Zahlenreihe hinschreiben und das Urteil prüfen lässt.
Sieben Tests, darunter genau der Fall, an dem der alte Wachhund
vorbeisah.

Gezählt wird nur der Weg vom Spielen ins Warten. Das anfängliche Puffern
ist der Start, kein Rückler; würde es mitgezählt, hätte jede Wiedergabe
eine Vorstrafe.

Und zwei Kommentare sind berichtigt. Sie behaupteten, AVPlayer wechsle
die Bitrate von selbst und das sei „die zugesagte automatische
Qualitätsanpassung". Umschalten kann er nur zwischen Varianten, die in
der Liste stehen.

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

Packages/FlixyKit/Tests/FlixyPlaybackTests/StallLedgerTests.swift

@@ -0,0 +1,89 @@
+import Testing
+import Foundation
+@testable import FlixyPlayback
+
+@Suite("Rückler-Buchführung")
+struct StallLedgerTests {
+    /// Der Fall, wegen dem es den Typ gibt.
+    ///
+    /// Zehn Rückler à dreißig Sekunden lösten beim alten Wachhund nichts aus,
+    /// weil er sich bei jedem Erholen zurücksetzte. Hier muss sichtbar
+    /// werden, dass die Wiedergabe unbrauchbar ist.
+    @Test("Viele kurze Rückler bleiben sichtbar")
+    func manyShortStallsAreVisible() {
+        var ledger = StallLedger(window: .seconds(180))
+
+        // Alle 20 s ein Rückler von 5 s, drei Minuten lang.
+        for step in 1...9 {
+            ledger.record(.init(endedAt: .seconds(step * 20), length: .seconds(5)))
+        }
+
+        let now = Duration.seconds(180)
+        #expect(ledger.count(at: now) == 9)
+        // 45 s Warten in 180 s Fenster.
+        #expect(ledger.share(at: now) > 0.2)
+        #expect(ledger.share(at: now) < 0.3)
+    }
+
+    @Test("Was aus dem Fenster fällt, zählt nicht mehr")
+    func oldEpisodesFallOut() {
+        var ledger = StallLedger(window: .seconds(180))
+        ledger.record(.init(endedAt: .seconds(10), length: .seconds(30)))
+
+        #expect(ledger.count(at: .seconds(60)) == 1)
+        // Weit hinter dem Fenster: vergessen.
+        #expect(ledger.count(at: .seconds(300)) == 0)
+        #expect(ledger.share(at: .seconds(300)) == 0)
+    }
+
+    /// Am Anfang ist das Fenster noch nicht voll — dann gegen die tatsächlich
+    /// vergangene Zeit rechnen, sonst sieht ein früher Rückler harmlos aus.
+    @Test("Früh im Film zählt die vergangene Zeit, nicht das ganze Fenster")
+    func earlyStallsAreNotDiluted() {
+        var ledger = StallLedger(window: .seconds(180))
+        ledger.record(.init(endedAt: .seconds(20), length: .seconds(5)))
+
+        let share = ledger.share(at: .seconds(20))
+        // 5 s von 20 s, nicht 5 s von 180 s.
+        #expect(share > 0.2)
+        #expect(share < 0.3)
+    }
+
+    @Test("Der laufende Rückler zählt mit")
+    func ongoingStallCounts() {
+        var ledger = StallLedger(window: .seconds(180))
+        ledger.record(.init(endedAt: .seconds(60), length: .seconds(10)))
+
+        let without = ledger.share(at: .seconds(180))
+        let with = ledger.share(at: .seconds(180), ongoing: .seconds(20))
+        #expect(with > without)
+    }
+
+    /// Ein einzelner langer Rückler ist eine andere Aussage als viele kurze.
+    @Test("Der längste Einzelfall lässt sich getrennt ablesen")
+    func longestIsSeparate() {
+        var ledger = StallLedger(window: .seconds(180))
+        ledger.record(.init(endedAt: .seconds(30), length: .seconds(2)))
+        ledger.record(.init(endedAt: .seconds(60), length: .seconds(18)))
+        ledger.record(.init(endedAt: .seconds(90), length: .seconds(3)))
+
+        #expect(ledger.longest(at: .seconds(120)) == .seconds(18))
+        #expect(ledger.count(at: .seconds(120)) == 3)
+    }
+
+    @Test("Eine ruhige Wiedergabe meldet nichts")
+    func quietPlaybackIsQuiet() {
+        let ledger = StallLedger()
+        #expect(ledger.count(at: .seconds(600)) == 0)
+        #expect(ledger.share(at: .seconds(600)) == 0)
+        #expect(ledger.longest(at: .seconds(600)) == .zero)
+    }
+
+    @Test("Der Anteil übersteigt nie eins")
+    func shareIsBounded() {
+        var ledger = StallLedger(window: .seconds(60))
+        // Absurd: mehr Wartezeit als Fenster.
+        ledger.record(.init(endedAt: .seconds(30), length: .seconds(200)))
+        #expect(ledger.share(at: .seconds(60)) == 1)
+    }
+}