Zweimal vermerkt, einmal gespeichert, Serie verloren

„Markensuche für ‚A Knight of the Seven Kingdoms' abgebrochen — An error
occurred while saving the entity changes." Das war meiner, und er hat
mehr gekostet als eine Fehlermeldung: der Lauf brach beim Speichern ab,
und damit war alles weg, was er für diese Serie gefunden hatte.

`VermerkenAsync` sah in der Datenbank nach, ob die Staffel schon
vermerkt ist — und eine Abfrage sieht nicht, was derselbe Lauf eben erst
hinzugefügt und noch nicht gespeichert hat. Seit der Bildweg dazukam,
wird für dieselbe Staffel zweimal vermerkt: einmal nach dem Tonabgleich,
einmal vor dem Bild. Die zweite Abfrage fand nichts, legte eine zweite
Zeile an, und der eindeutige Schlüssel über (Serie, Staffel, Art) warf
sie beim Speichern wieder hinaus. Jetzt wird erst im Änderungsspeicher
nachgesehen, dann in der Datenbank.

**Und die Meldung taugte nichts.** Das Tagebuch hängt nur `Message` an,
und EF Core schreibt dort „See the inner exception for details." — eine
Zeile, die ausdrücklich sagt, dass sie die Auskunft nicht enthält. Alle
vier Abbruchmeldungen nennen jetzt den innersten Grund über
`Fehlertext.FuerMenschen`.

**Dazu der zweite Fund aus demselben Protokoll.** „(T)Raumschiff
Surprise": kein Abspann, 1318 Proben, Schwelle 51,1, letzte Probe 17 —
das Ende ist also dunkel, und trotzdem kein Fund. 1318 Proben auf zwanzig
Minuten heissen eine alle 0,9 Sekunden, und die Nachsicht gegenüber
hellen Stellen mitten im Abspann war in *Proben* angegeben: zwei Stück,
dort also 1,8 Sekunden. Bei einer Datei mit einem Schlüsselbild alle zehn
Sekunden waren dieselben zwei Proben zwanzig Sekunden. Dasselbe
Zugeständnis, zehnfach verschieden — genau der Fehler, den ich eine Zeile
höher bei der Schlusstafel schon behoben hatte. `Nachsicht` zählt jetzt
Sekunden, zehn davon.

**Und die Suche sagt, woran es lag.** „kein Abspann — das Ende ist hell"
gegen „die dunkle Strecke ist mit 20 s zu kurz" sind zwei verschiedene
Ursachen mit zwei verschiedenen Antworten; bisher stand dort beides Mal
dasselbe.

Vier neue Prüfungen, darunter dieselbe Szene bei 0,9 und bei 10 Sekunden
Abtastung. Mit der alten Probenzählung ist die dichte rot.

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

server/tests/Flaro.Core.Tests/AbspannkanteTests.cs

@@ -72,13 +72,20 @@ public class AbspannkanteTests
     }
 
     /// <summary>Eine helle Schrifttafel mittendrin bricht die Strecke nicht.</summary>
+    ///
+    /// <remarks>
+    /// <b>Eine Probe, also zehn Sekunden.</b> Hier standen zwei, und das
+    /// war unter der alten Zählweise gedacht: nachgesehen wurde, wie viele
+    /// <i>Proben</i> am Stück hell sind, nicht wie lange. Zwanzig Sekunden
+    /// helles Bild sind keine Schrifttafel mehr, sondern eine Szene — dass
+    /// die Suche dort abbricht, ist richtig und steht in
+    /// <c>AbspannNachsichtTests</c>.
+    /// </remarks>
     [Test]
     public void Eine_kurze_helle_Tafel_bricht_nichts()
     {
         var proben = Reihe(0, 600, abspannAb: 420);
-        // Zwei Proben, also zwanzig Sekunden, sind hell.
         proben[50] = proben[50] with { Helligkeit = 140 };
-        proben[51] = proben[51] with { Helligkeit = 140 };
 
         Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(420));
     }
@@ -310,3 +317,94 @@ public class AbspannSchlusstafelTests
         Assert.That(Abspannkante.Suchen(proben, Regeln), Is.Null);
     }
 }
+
+/// <summary>Dieselbe Szene, zweierlei Schlüsselbilddichte.</summary>
+///
+/// <remarks>
+/// <para>
+/// <b>Der Fehler, für den diese Prüfungen stehen.</b> Die Nachsicht
+/// gegenüber hellen Stellen mitten im Abspann war in <i>Proben</i>
+/// angegeben, nicht in Sekunden. Was das bedeutet, hängt allein daran,
+/// wie dicht eine Datei ihre Schlüsselbilder setzt — und das schwankt um
+/// eine Zehnerpotenz.
+/// </para>
+/// <para>
+/// Gemessen am Bestand: „(T)Raumschiff Surprise" liefert 1318 Proben auf
+/// zwanzig Minuten, also eine alle 0,9 Sekunden. Zwei Proben Nachsicht
+/// waren dort 1,8 Sekunden; bei einer Datei mit einem Schlüsselbild alle
+/// zehn Sekunden waren dieselben zwei Proben zwanzig Sekunden. Ein
+/// fünfsekündiges Logo mitten im Abspann zerriss die Strecke deshalb nur
+/// bei der dicht abgetasteten Datei — und genau die fiel durch.
+/// </para>
+/// </remarks>
+public class AbspannNachsichtTests
+{
+    private static readonly Abspannregeln Regeln = Abspannregeln.Vorgabe;
+
+    /// <summary>Abspann ab 2340 s, darin fünf Sekunden helles Logo.</summary>
+    private static List<Bildprobe> Fenster(double takt)
+    {
+        var proben = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += takt)
+        {
+            var imLogo = t >= 2500 && t < 2505;
+            proben.Add(new Bildprobe(t, t < 2340 ? 126 : imLogo ? 180 : 32));
+        }
+        return proben;
+    }
+
+    /// <summary>Dicht abgetastet — der Fall, der im Bestand durchfiel.</summary>
+    [Test]
+    public void Ein_Logo_zerreisst_den_Abspann_nicht_bei_dichten_Proben()
+    {
+        Assert.That(Abspannkante.Suchen(Fenster(takt: 0.9), Regeln),
+            Is.EqualTo(2340.0).Within(2));
+    }
+
+    /// <summary>Dünn abgetastet — derselbe Film, dieselbe Antwort.</summary>
+    [Test]
+    public void Und_auch_nicht_bei_duennen_Proben()
+    {
+        Assert.That(Abspannkante.Suchen(Fenster(takt: 10), Regeln),
+            Is.EqualTo(2340.0).Within(11));
+    }
+
+    /// <summary>Eine lange helle Strecke bricht weiterhin ab.</summary>
+    ///
+    /// <remarks>
+    /// Sonst liefe die Suche rückwärts durch jede Nachtszene und meldete
+    /// den halben Film als Abspann.
+    /// </remarks>
+    [Test]
+    public void Eine_lange_helle_Strecke_bricht_die_Suche()
+    {
+        var proben = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += 1)
+        {
+            // Dunkel ab 2340, aber von 2400 bis 2460 eine Minute hell.
+            var hell = t < 2340 || (t >= 2400 && t < 2460);
+            proben.Add(new Bildprobe(t, hell ? 126 : 32));
+        }
+
+        // Gefunden wird nur das Stück hinter der hellen Minute.
+        Assert.That(Abspannkante.Suchen(proben, Regeln), Is.EqualTo(2460.0).Within(2));
+    }
+
+    /// <summary>Und der Grund steht für das Protokoll bereit.</summary>
+    [Test]
+    public void Der_Grund_wird_benannt()
+    {
+        var hell = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += 5) hell.Add(new Bildprobe(t, 126));
+
+        Abspannkante.Suchen(hell, Regeln, out var grund);
+        Assert.That(grund, Does.Contain("hell"));
+
+        var kurz = new List<Bildprobe>();
+        for (var t = 1500.0; t <= 2700; t += 5)
+            kurz.Add(new Bildprobe(t, t < 2680 ? 126 : 32));
+
+        Abspannkante.Suchen(kurz, Regeln, out var zuKurz);
+        Assert.That(zuKurz, Does.Contain("kurz"));
+    }
+}