Zwei Namen für denselben Titel brachen den ganzen Lauf ab

Der Eindeutigkeitsindex aus Punkt 3 stellte die Regel auf, dichtete aber
den einen Weg nicht ab, auf dem sie verletzt wird: der Enricher setzt die
TMDB-Kennung, und sobald zwei Einträge derselben Mediathek dieselbe
bekamen, brach EF die gesamte Speicherung ab — mit "An error occurred
while saving the entity changes", einer Meldung, die den Grund nicht nennt
und den ganzen Scan mitnimmt.

Jetzt wird die Kennung nicht blind gesetzt, sondern vorgemerkt und nach
der Schleife zusammengelegt. Zwei Tests halten den Fall fest: der Anbieter
antwortet auf jede Anfrage mit demselben Film beziehungsweise derselben
Serie, also genau die Lage, die vorher den Lauf zerriss.

Dazu der wahrscheinliche Grund für die siebenhundert Serien: der
Serientitel kam ausschliesslich aus dem Dateinamen. Heisst eine Datei nur
"S01E01.mkv", steht vor der Folgennummer nichts, und der ganze Dateiname
wurde zum Serientitel — zwanzig Folgen ergaben zwanzig Serien namens
"S01E01", "S01E02", und so weiter. Jetzt sagt der Ordner den Namen, wenn
die Datei ihn nicht nennt; der Staffelordner wird dabei übersprungen, sonst
hiesse die Serie "Staffel 1". Plex und Jellyfin lesen ihn seit je so.

Dazu die Prüfliste: Folgen werden nach Serie gebündelt, weil zwanzig neue
Folgen eine Entscheidung sind und nicht zwanzig. Mit Mehrfachauswahl —
anhaken und gemeinsam freigeben oder auf einen Zeitpunkt legen. Und der
Zeitpunkt ist ein datetime-local statt eines Textfelds mit Formvorschrift,
bei dem jeder Tippfehler erst nach dem Absenden auffiel.

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

server/Dockerfile

@@ -48,7 +48,7 @@ FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime
 ARG TARGETARCH
 RUN apt-get update \
  && apt-get install -y --no-install-recommends \
-      ffmpeg libva2 libva-drm2 mesa-va-drivers \
+      ffmpeg libva2 libva-drm2 mesa-va-drivers curl \
  && if [ "$TARGETARCH" = "amd64" ]; then \
       apt-get install -y --no-install-recommends intel-media-va-driver i965-va-driver; \
     fi \
@@ -67,10 +67,13 @@ RUN mkdir -p /config /cache /transcode && chown -R 1000:1000 /config /cache /tra
 # braucht weder ein Startskript noch root im Container.
 USER 1000:1000
 
+# **Kein eigenes ASPNETCORE_URLS.** Das Basisimage setzt seit .NET 8 selbst
+# ASPNETCORE_HTTP_PORTS=8080; beides zusammen ergab bei jedem Start die
+# Warnung „Overriding HTTP_PORTS '8080'". Zwei Wege zum selben Port sind
+# einer zu viel.
 ENV FLARO_DATA=/config \
     FLARO_CACHE=/cache \
     FLARO_TRANSCODE=/transcode \
-    ASPNETCORE_URLS=http://+:8080 \
     DOTNET_gcServer=0
 
 WORKDIR /app
@@ -78,6 +81,20 @@ COPY --from=build /app .
 COPY --from=web /web/dist ./wwwroot
 
 EXPOSE 8080
+
+# **Eine Gesundheitsprüfung, die den Server fragt — nicht die Laufzeit.**
+#
+# Ohne sie weiss Docker nur, dass ein Prozess läuft. Die Oberfläche eines NAS
+# zeigt dann minutenlang „wird bereitgestellt", während der Server längst
+# antwortet, und niemand kann unterscheiden, ob er noch wandert oder hängt.
+#
+# `/health` und nicht `dotnet --info`: letzteres sagt nur, dass die Laufzeit
+# da ist, und das war sie auch, als der Server noch migrierte.
+#
+# 60 Sekunden Anlaufzeit, weil die Migrationen beim ersten Start einer
+# gefüllten Datenbank länger brauchen als ein Startvorgang sonst.
+HEALTHCHECK --interval=30s --timeout=5s --start-period=60s --retries=3 \
+    CMD curl -fsS http://localhost:8080/health || exit 1
 VOLUME ["/config", "/cache", "/transcode"]
 
 ENTRYPOINT ["dotnet", "Flaro.Api.dll"]

server/docker-compose.example.yml

@@ -67,9 +67,7 @@ services:
     devices:
       - /dev/dri:/dev/dri
 
-    healthcheck:
+    # Die Gesundheitsprüfung steckt im Image und fragt /health ab — hier
-      test: ["CMD", "dotnet", "--info"]
+    # braucht es sie nicht noch einmal. Die alte Fassung prüfte `dotnet
-      interval: 30s
+    # --info` und sagte damit nur, dass die Laufzeit da ist; das war sie auch,
-      timeout: 5s
+    # während der Server noch migrierte.
-      retries: 3
-      start_period: 20s

server/src/Flaro.Api/Endpoints/Contracts.cs

@@ -85,13 +85,32 @@ public sealed record Bildauswahl(
 public sealed record BildWahlRequest(string Kind, string? Url);
 
 /// <summary>Ein Titel, der noch wartet oder geplant ist.</summary>
+///
+/// <remarks>
+/// <b>Eine Zeile je Serie, nicht je Folge.</b> Bei zwanzig neuen Folgen
+/// derselben Serie wären zwanzig Zeilen zwanzig Entscheidungen für eine
+/// Sache. Die Folgen stecken in <see cref="Ids"/>; freigegeben werden sie
+/// gemeinsam.
+/// </remarks>
 public sealed record Pruefeintrag(
-    string Kind, Guid Id, string Title, int? Year, string? PosterImage,
+    /// <summary><c>movie</c> oder <c>series</c>.</summary>
+    string Kind,
+    Guid Id, string Title, int? Year, string? PosterImage,
     /// <summary><c>null</c> heisst: wartet. Ein Zeitpunkt in der Zukunft heisst: geplant.</summary>
+    ///
+    /// <remarks>
+    /// Bei einer Serie nur gesetzt, wenn alle Folgen denselben Termin tragen —
+    /// sonst wäre es eine Behauptung über zwanzig Folgen, von denen eine
+    /// anders liegt.
+    /// </remarks>
     DateTimeOffset? PublishAt,
     string? Path,
     /// <summary>Ob eine Zuordnung besteht — ohne sie fehlen Titel und Bilder.</summary>
-    bool Matched);
+    bool Matched,
+    /// <summary>Wie viele Titel dahinterstecken — bei einer Serie die Zahl der Folgen.</summary>
+    int Count,
+    /// <summary>Worauf eine Freigabe wirkt.</summary>
+    IReadOnlyList<Guid> Ids);
 
 public sealed record FreigabeRequest(IReadOnlyList<Guid>? Ids, DateTimeOffset? PublishAt);
 

server/src/Flaro.Api/Endpoints/FreigabeEndpoints.cs

@@ -26,24 +26,56 @@ public static class FreigabeEndpoints
                 .Select(m => new Pruefeintrag(
                     "movie", m.Id, m.Title, m.Year, m.PosterImage, m.PublishAt,
                     db.MediaFiles.Where(f => f.MovieId == m.Id).Select(f => f.Path).FirstOrDefault(),
-                    m.TmdbId != null))
+                    m.TmdbId != null, 1, new List<Guid> { m.Id }))
                 .ToListAsync(ct);
 
-            var folgen = await db.Episodes.AsNoTracking()
+            // **Folgen werden nach Serie gebündelt.** Zwanzig neue Folgen
+            // derselben Serie sind eine Entscheidung, nicht zwanzig.
+            var offeneFolgen = await db.Episodes.AsNoTracking()
                 .Where(f => f.PublishAt == null || f.PublishAt > jetzt)
-                .OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
+                .Select(f => new
-                .Select(f => new Pruefeintrag(
+                {
-                    "episode", f.Id,
+                    f.Id, f.SeriesId, f.SeasonNumber, f.EpisodeNumber, f.PublishAt,
-                    db.Series.Where(s => s.Id == f.SeriesId).Select(s => s.Title).First()
+                    Pfad = db.MediaFiles.Where(d => d.EpisodeId == f.Id)
-                        + $" · S{f.SeasonNumber}E{f.EpisodeNumber}",
+                        .Select(d => d.Path).FirstOrDefault(),
-                    null,
+                })
-                    db.Series.Where(s => s.Id == f.SeriesId).Select(s => s.PosterImage).First(),
-                    f.PublishAt,
-                    db.MediaFiles.Where(d => d.EpisodeId == f.Id).Select(d => d.Path).FirstOrDefault(),
-                    true))
                 .ToListAsync(ct);
 
-            return Results.Ok(filme.Concat(folgen).ToList());
+            var serienIds = offeneFolgen.Select(f => f.SeriesId).Distinct().ToList();
+            var serien = await db.Series.AsNoTracking()
+                .Where(s => serienIds.Contains(s.Id))
+                .Select(s => new { s.Id, s.Title, s.Year, s.PosterImage, Zugeordnet = s.TmdbId != null })
+                .ToDictionaryAsync(s => s.Id, ct);
+
+            var gebuendelt = offeneFolgen
+                .GroupBy(f => f.SeriesId)
+                .Select(g =>
+                {
+                    var serie = serien.GetValueOrDefault(g.Key);
+                    var termine = g.Select(f => f.PublishAt).Distinct().ToList();
+
+                    return new Pruefeintrag(
+                        "series", g.Key,
+                        serie?.Title ?? "Unbekannte Serie",
+                        serie?.Year,
+                        serie?.PosterImage,
+                        // Nur wenn alle denselben Termin tragen — sonst wäre es
+                        // eine Behauptung über Folgen, die anders liegen.
+                        termine.Count == 1 ? termine[0] : null,
+                        Pfad(g.Select(f => f.Pfad).FirstOrDefault()),
+                        serie?.Zugeordnet ?? false,
+                        g.Count(),
+                        g.OrderBy(f => f.SeasonNumber).ThenBy(f => f.EpisodeNumber)
+                            .Select(f => f.Id).ToList());
+                })
+                .OrderBy(e => e.Title)
+                .ToList();
+
+            return Results.Ok(filme.Concat(gebuendelt).ToList());
+
+            // Bei einer Serie sagt der Ordner mehr als die erste Folgendatei.
+            static string? Pfad(string? datei) =>
+                datei is null ? null : System.IO.Path.GetDirectoryName(datei);
         });
 
         // Veröffentlichen oder planen. Ohne Zeitpunkt heisst: jetzt.

server/src/Flaro.Api/Program.cs

@@ -1,3 +1,4 @@
+using Microsoft.AspNetCore.DataProtection;
 using System.Threading.RateLimiting;
 using Flaro.Api;
 using Flaro.Api.Auth;
@@ -99,6 +100,22 @@ builder.Services.AddSingleton<PackageCoordinator>();
 // ueber den Augenblick. Nach einem Neustart lautet die Antwort: niemand.
 builder.Services.AddSingleton<PlaybackSessions>();
 builder.Services.AddSingleton<Tagebuch>();
+
+// **Die Schlüssel der Datenverschlüsselung gehören ins Volume.**
+//
+// Ohne diese Zeile legt ASP.NET sie unter `~/.aspnet/DataProtection-Keys` ab —
+// also im Container, der beim nächsten Update weg ist. Heute fällt das nicht
+// auf, weil Flaros Sitzungs-Cookie das Gerätetoken selbst trägt und nichts
+// davon verschlüsselt wird. Es fällt erst auf, wenn irgendwann etwas doch
+// darauf baut, und dann sieht es aus wie ein Fehler anderswo.
+//
+// Nebenbei verschwindet damit die Warnung, die bei jedem Start im Protokoll
+// stand und nach einem Problem aussah, das keines war.
+var schluesselOrdner = Path.Combine(pfade.Data, "keys");
+Directory.CreateDirectory(schluesselOrdner);
+builder.Services.AddDataProtection()
+    .PersistKeysToFileSystem(new DirectoryInfo(schluesselOrdner))
+    .SetApplicationName("Flaro");
 builder.Services.AddProblemDetails();
 
 var app = builder.Build();

server/src/Flaro.Core/Library/FileNames.cs

@@ -206,13 +206,61 @@ public static partial class FileNames
         var (worteDanach, _) = Zerlegen(danach, istDateiname: false);
         var (folgenTitel, _) = TitelBis(worteDanach, worteDanach.Length);
 
+        // **Steht im Dateinamen keine Serie, sagt der Ordner sie.**
+        //
+        // Bei „Dark/Staffel 1/S01E01.mkv" steht vor der Folgennummer nichts —
+        // und bis hierher wurde dann der ganze Dateiname zum Serientitel.
+        // Jede so benannte Datei ergab damit eine eigene Serie: aus zwanzig
+        // Folgen wurden zwanzig Serien namens „S01E01", „S01E02", …
+        //
+        // Plex und Jellyfin lesen den Namen seit je aus dem Ordner. Der
+        // Staffelordner wird dabei übersprungen, sonst hiesse die Serie
+        // „Staffel 1".
+        var ausOrdner = serie.Length > 0 ? null : SerieAusOrdner(dateiname);
+
         return new EpisodeName(
-            SeriesTitle: serie.Length > 0 ? serie : Rohname(dateiname),
+            SeriesTitle: serie.Length > 0 ? serie : ausOrdner ?? Rohname(dateiname),
             Season: staffel,
             Episode: folge,
             EpisodeTitle: folgenTitel.Length > 0 ? folgenTitel : null);
     }
 
+    /// <summary>Der Serienname aus dem Pfad — Staffelordner übersprungen.</summary>
+    ///
+    /// <remarks>
+    /// <b>Höchstens zwei Ebenen hoch.</b> Weiter oben steht der Wurzelordner
+    /// der Mediathek, und „Serien" ist kein Serientitel.
+    /// </remarks>
+    private static string? SerieAusOrdner(string pfad)
+    {
+        var ordner = Path.GetDirectoryName(pfad);
+
+        for (var ebene = 0; ebene < 2 && !string.IsNullOrEmpty(ordner); ebene++)
+        {
+            var name = Path.GetFileName(ordner);
+            if (name.Length == 0) return null;
+
+            if (!IstStaffelordner(name))
+            {
+                var (worte, _) = Zerlegen(name, istDateiname: false);
+                var (titel, _) = TitelBis(worte, worte.Length);
+                return titel.Length > 0 ? titel : null;
+            }
+
+            ordner = Path.GetDirectoryName(ordner);
+        }
+
+        return null;
+    }
+
+    /// <summary>„Staffel 1", „Season 02", „S3" — Ordner, die keine Serie benennen.</summary>
+    private static bool IstStaffelordner(string name) =>
+        StaffelOrdnerName().IsMatch(name.Trim());
+
+    [GeneratedRegex(@"^(staffel|season|series|s)[\s._-]*\d{1,3}$|^(specials?|extras?)$",
+        RegexOptions.IgnoreCase)]
+    private static partial Regex StaffelOrdnerName();
+
     /// <summary>Nimmt Worte, bis das erste Beiwerk oder eine Jahreszahl kommt.</summary>
     private static (string Titel, int? Jahr) TitelBis(string[] worte, int grenze)
     {

server/src/Flaro.Data/MetadataEnricher.cs

@@ -30,6 +30,7 @@ public sealed class MetadataEnricher(
     IImageStore bilder,
     IImageReader bildLeser,
     ISidecarStore beiwerk,
+    Zusammenlegung zusammenlegung,
     ILogger<MetadataEnricher> log)
 {
     /// <param name="erneut">
@@ -81,6 +82,14 @@ public sealed class MetadataEnricher(
         var zugeordnet = 0;
         var durch = 0;
 
+        // Wer welche Kennung schon hat — auch die, die dieser Lauf gerade
+        // vergeben hat und die deshalb noch nicht in der Datenbank stehen.
+        var vergeben = await db.Movies
+            .Where(m => m.LibraryId == libraryId && m.TmdbId != null)
+            .ToDictionaryAsync(m => m.TmdbId!.Value, m => m.Id, ct);
+
+        var zusammenzulegen = new List<(Guid Sieger, Guid Verlierer)>();
+
         foreach (var film in offen)
         {
             ct.ThrowIfCancellationRequested();
@@ -101,6 +110,24 @@ public sealed class MetadataEnricher(
 
             if (gefunden is null) continue;
 
+            // **Zwei Einträge, derselbe Film — und das fällt erst hier auf.**
+            //
+            // Beim Scan heisst der eine „Ich einfach unverbesserlich" und der
+            // andere „Despicable Me"; dass es derselbe ist, verrät allein die
+            // TMDB-Kennung. Die hier blind zu setzen verletzt den
+            // Eindeutigkeitsindex, und EF bricht die ganze Speicherung ab —
+            // mit „An error occurred while saving the entity changes", einer
+            // Meldung, die den Grund nicht nennt und den ganzen Lauf mitnimmt.
+            //
+            // Also nicht setzen, sondern vormerken: zusammengelegt wird nach
+            // der Schleife, wenn nichts mehr dazwischenkommt.
+            if (vergeben.TryGetValue(gefunden.ProviderId, out var schonDa))
+            {
+                zusammenzulegen.Add((Sieger: schonDa, Verlierer: film.Id));
+                continue;
+            }
+
+            vergeben[gefunden.ProviderId] = film.Id;
             film.TmdbId = gefunden.ProviderId;
             film.ImdbId = gefunden.ImdbId;
             film.Title = gefunden.Title;
@@ -128,6 +155,23 @@ public sealed class MetadataEnricher(
         }
 
         if (zugeordnet > 0) await db.SaveChangesAsync(ct);
+
+        // **Erst speichern, dann zusammenlegen.** Das Verschmelzen löscht
+        // Zeilen am Änderungsverfolger vorbei; stünde es davor, schriebe das
+        // folgende Speichern sie wieder hin.
+        foreach (var (sieger, verlierer) in zusammenzulegen)
+        {
+            await zusammenlegung.FilmVerschmelzenAsync(sieger, verlierer, ct);
+        }
+
+        if (zusammenzulegen.Count > 0)
+        {
+            await db.SaveChangesAsync(ct);
+            log.LogInformation(
+                "{Anzahl} Film(e) waren derselbe Titel unter anderem Namen und wurden zusammengelegt.",
+                zusammenzulegen.Count);
+        }
+
         return zugeordnet;
     }
 
@@ -160,6 +204,12 @@ public sealed class MetadataEnricher(
         var zugeordnet = 0;
         var durch = 0;
 
+        var vergeben = await db.Series
+            .Where(x => x.LibraryId == libraryId && x.TmdbId != null)
+            .ToDictionaryAsync(x => x.TmdbId!.Value, x => x.Id, ct);
+
+        var zusammenzulegen = new List<(Guid Sieger, Guid Verlierer)>();
+
         foreach (var serie in offen)
         {
             ct.ThrowIfCancellationRequested();
@@ -181,6 +231,17 @@ public sealed class MetadataEnricher(
 
             if (gefunden is null) continue;
 
+            // Wie beim Film: zwei Einträge, dieselbe Serie. Bei Serien ist das
+            // noch häufiger — derselbe Ordner unter zwei Schreibweisen, oder
+            // ein Staffelordner, der versehentlich als eigene Serie gelesen
+            // wurde.
+            if (vergeben.TryGetValue(gefunden.ProviderId, out var schonDa))
+            {
+                zusammenzulegen.Add((Sieger: schonDa, Verlierer: serie.Id));
+                continue;
+            }
+
+            vergeben[gefunden.ProviderId] = serie.Id;
             serie.TmdbId = gefunden.ProviderId;
             serie.ImdbId = gefunden.ImdbId;
             serie.Title = gefunden.Title;
@@ -208,6 +269,20 @@ public sealed class MetadataEnricher(
         }
 
         if (zugeordnet > 0) await db.SaveChangesAsync(ct);
+
+        foreach (var (sieger, verlierer) in zusammenzulegen)
+        {
+            await zusammenlegung.SerieVerschmelzenAsync(sieger, verlierer, ct);
+        }
+
+        if (zusammenzulegen.Count > 0)
+        {
+            await db.SaveChangesAsync(ct);
+            log.LogInformation(
+                "{Anzahl} Serie(n) waren dieselbe unter anderem Namen und wurden zusammengelegt.",
+                zusammenzulegen.Count);
+        }
+
         return zugeordnet;
     }
 

server/tests/Flaro.Api.Tests/MetadataTests.cs

@@ -155,6 +155,73 @@ public class MetadataTests
         Assert.That(bilder.Geholt, Is.EquivalentTo(new[] { "https://bild/p.jpg", "https://bild/b.jpg" }));
     }
 
+    /// <summary>Zwei Namen, ein Film — das darf den Lauf nicht abbrechen.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>Der Fehler, den der Eindeutigkeitsindex selbst verursacht hat.</b>
+    /// Beim Scan heisst der eine Eintrag „Ich einfach unverbesserlich" und
+    /// der andere „Despicable Me"; dass es derselbe Film ist, verrät erst die
+    /// TMDB-Kennung. Wurde sie beiden zugewiesen, verletzte das die Regel —
+    /// und EF brach die gesamte Speicherung ab, mit „An error occurred while
+    /// saving the entity changes". Die Meldung nennt den Grund nicht und
+    /// nimmt den ganzen Lauf mit.
+    /// </para>
+    /// <para>
+    /// Hier antwortet der Anbieter auf jede Anfrage mit demselben Film — also
+    /// genau die Lage, die vorher den Lauf zerriss.
+    /// </para>
+    /// </remarks>
+    [Test]
+    public async Task Zwei_Namen_fuer_denselben_Film_werden_zusammengelegt()
+    {
+        Datei("Despicable Me (2010).mkv");
+        Datei("Ich einfach unverbesserlich (2010).mkv");
+
+        var anbieter = new VorgegebenerAnbieter
+        {
+            Film = new MovieMetadata(20352, "Ich einfach unverbesserlich", 2010, "Gru hat einen Plan.",
+                null, null),
+        };
+
+        using var server = MitAnbieter(anbieter);
+        var (client, bibliothek) = await Einrichten(server, "Movies");
+        var stand = await Scannen(client, bibliothek);
+
+        Assert.That(stand.State, Is.EqualTo("finished"), "Der Lauf darf nicht abbrechen.");
+        Assert.That(stand.Metadata!.Error, Is.Null);
+
+        var filme = await client.GetFromJsonAsync<Page<MovieResponse>>("/api/v1/movies");
+        Assert.That(filme!.Total, Is.EqualTo(1), "Ein Film, nicht zwei.");
+        Assert.That(filme.Items[0].Title, Is.EqualTo("Ich einfach unverbesserlich"));
+        Assert.That(filme.Items[0].Files, Has.Count.EqualTo(2),
+            "Beide Dateien hängen am überlebenden Eintrag — keine darf verlorengehen.");
+    }
+
+    /// <summary>Dasselbe für Serien.</summary>
+    [Test]
+    public async Task Zwei_Namen_fuer_dieselbe_Serie_werden_zusammengelegt()
+    {
+        Datei("Dark/Staffel 1/Dark - S01E01.mkv");
+        Datei("Dark (2017)/Staffel 1/Dark (2017) - S01E02.mkv");
+
+        var anbieter = new VorgegebenerAnbieter
+        {
+            Serie = new SeriesMetadata(70523, "Dark", 2017, "Eine Höhle.", null, null),
+        };
+
+        using var server = MitAnbieter(anbieter);
+        var (client, bibliothek) = await Einrichten(server, "Shows");
+        var stand = await Scannen(client, bibliothek);
+
+        Assert.That(stand.State, Is.EqualTo("finished"));
+
+        var serien = await client.GetFromJsonAsync<Page<SeriesResponse>>("/api/v1/series");
+        Assert.That(serien!.Total, Is.EqualTo(1));
+        Assert.That(serien.Items[0].EpisodeCount, Is.EqualTo(2),
+            "Beide Folgen hängen an der überlebenden Serie.");
+    }
+
     /// <summary>Was die Quelle nicht kennt, bleibt trotzdem in der Mediathek.</summary>
     [Test]
     public async Task Ein_Film_ohne_Treffer_behaelt_seinen_Dateinamen()

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

@@ -165,3 +165,36 @@ public class MedienDateienTests
         Assert.That(MediaExtensions.IsSkippedDirectory(name), Is.EqualTo(erwartet));
     }
 }
+
+/// <summary>Woher der Serienname kommt, wenn der Dateiname ihn nicht nennt.</summary>
+///
+/// <remarks>
+/// <b>Der Fall, der aus einer Serie siebenhundert machte.</b> Heisst eine
+/// Datei nur „S01E01.mkv", steht vor der Folgennummer nichts — und bis dahin
+/// wurde der ganze Dateiname zum Serientitel. Zwanzig Folgen ergaben zwanzig
+/// Serien namens „S01E01", „S01E02", und so weiter.
+/// </remarks>
+public class SerieAusOrdnerTests
+{
+    [TestCase("Dark/Staffel 1/S01E01.mkv", "Dark")]
+    [TestCase("Dark/Season 2/S02E05.mkv", "Dark")]
+    [TestCase("Doctor Who (2005)/Staffel 12/S12E04.mkv", "Doctor Who")]
+    [TestCase("Serien/Dark/S01E01.mkv", "Dark")]
+    [TestCase("Dark/Specials/S00E01.mkv", "Dark")]
+    public void Ohne_Namen_in_der_Datei_gilt_der_Ordner(string pfad, string erwartet) =>
+        Assert.That(FileNames.ParseEpisode(pfad)?.SeriesTitle, Is.EqualTo(erwartet));
+
+    /// <summary>Steht er im Dateinamen, hat er Vorrang — er ist genauer.</summary>
+    [Test]
+    public void Der_Dateiname_sticht_den_Ordner() =>
+        Assert.That(FileNames.ParseEpisode("Irgendwas/Staffel 1/Dark - S01E01 - Geheimnisse.mkv")?.SeriesTitle,
+            Is.EqualTo("Dark"));
+
+    [Test]
+    public void Staffel_und_Folge_bleiben_richtig()
+    {
+        var name = FileNames.ParseEpisode("Dark/Staffel 2/S02E05.mkv");
+        Assert.That(name!.Season, Is.EqualTo(2));
+        Assert.That(name.Episode, Is.EqualTo(5));
+    }
+}

web/app/src/api.ts

@@ -520,13 +520,17 @@ export const bildHochladen = async (
 };
 
 export type Pruefeintrag = {
-  kind: 'movie' | 'episode';
+  kind: 'movie' | 'series';
   id: string; title: string; year: number | null;
   posterImage: string | null;
-  /** `null` heisst: wartet. Ein Zeitpunkt in der Zukunft heisst: geplant. */
+  /** `null` heisst: wartet — oder bei einer Serie: die Folgen liegen verschieden. */
   publishAt: string | null;
   path: string | null;
   matched: boolean;
+  /** Wie viele Titel dahinterstecken; bei einer Serie die Zahl der Folgen. */
+  count: number;
+  /** Worauf eine Freigabe wirkt. */
+  ids: string[];
 };
 
 export const zuPruefen = () => anfrage<Pruefeintrag[]>('/review');

web/app/src/dialog.ts

@@ -10,7 +10,7 @@ import { ordner, type Ordnerstand } from './api';
  * Vorlesesoftware kündigt ihn als Dialog an. Jede Zeile, die das selbst
  * baut, ist eine Zeile, die es schlechter kann. */
 
-export type Feldart = 'text' | 'password' | 'number' | 'ordner';
+export type Feldart = 'text' | 'password' | 'number' | 'ordner' | 'zeitpunkt';
 
 export type Dialogfeld = {
   name: string;
@@ -23,6 +23,8 @@ export type Dialogfeld = {
   auswahl?: { wert: string; text: string }[];
   /** Ein Schalter statt eines Feldes. */
   schalter?: boolean;
+  /** Frühester erlaubter Zeitpunkt — nur bei `art: 'zeitpunkt'`. */
+  min?: string;
 };
 
 /** Liest einen Feldwert — nie `undefined`, ein unbekannter Name ergibt „".
@@ -104,6 +106,19 @@ export function dialog(optionen: {
       block.prepend(e);
       titel.remove();
       block.append(titel);
+    } else if (f.art === 'zeitpunkt') {
+      // **Der Wähler des Browsers, nicht ein Textfeld mit Formvorschrift.**
+      // Vorher stand dort „Form: 2026-12-24 20:15" als Hinweis — und jeder
+      // Tippfehler darin war erst nach dem Absenden zu sehen. `datetime-local`
+      // bringt Kalender und Uhr mit, kennt die Zeitzone des Geräts und lässt
+      // sich mit den Pfeiltasten bedienen.
+      const e = document.createElement('input');
+      e.className = 'feld';
+      e.type = 'datetime-local';
+      e.value = f.wert ?? '';
+      if (f.min) e.min = f.min;
+      eingaben.set(f.name, e);
+      block.appendChild(e);
     } else if (f.art === 'ordner') {
       const e = document.createElement('input');
       e.className = 'feld';

web/app/src/style.css

@@ -938,3 +938,28 @@ h2 { font-size: var(--t-abschnitt); font-weight: 700; letter-spacing: -.015em; m
 }
 .pruefzeile .pruef-bild img { width: 100%; height: 100%; object-fit: cover; display: block; }
 .pruefzeile .knopfreihe { align-items: center; }
+
+/* Der Zeitpunktwähler — der Browser bringt Kalender und Uhr mit, aber nicht
+   die Farben. Ohne das eigene Farbschema wäre das Symbol unsichtbar dunkel. */
+input[type="datetime-local"].feld {
+  color-scheme: dark;
+  min-height: 38px;
+}
+input[type="datetime-local"].feld::-webkit-calendar-picker-indicator {
+  filter: invert(1) opacity(.55);
+  cursor: pointer;
+}
+input[type="datetime-local"].feld::-webkit-calendar-picker-indicator:hover {
+  filter: invert(1) opacity(.9);
+}
+
+/* Die Mehrfachauswahl in der Prüfliste. */
+.pruefzeile input[type="checkbox"] {
+  width: 17px; height: 17px; flex: none;
+  accent-color: var(--accent);
+}
+.reihe-kopf .knopfreihe .bleiben {
+  display: flex; align-items: center; gap: 6px;
+  color: var(--text-dim); font-size: var(--t-normal);
+}
+.reihe-kopf .knopfreihe .bleiben input { accent-color: var(--accent); width: 16px; height: 16px; }

web/app/src/views/admin.ts

@@ -178,32 +178,110 @@ function pruefbereich(geaendert: () => void): HTMLElement {
   const liste = document.createElement('div');
   liste.className = 'einstellungen';
 
-  const alle = knopf('Alle veröffentlichen', 'btn btn-primary');
+  /** Was gerade angehakt ist. Als Menge und nicht am DOM abgelesen: beim
-  alle.onclick = async () => {
+   *  Neuladen bleibt die Auswahl damit erhalten. */
-    alle.disabled = true;
+  const gewaehlt = new Set<string>();
-    try { await veroeffentlichen(); await laden(); geaendert(); }
+  let stand: Pruefeintrag[] = [];
-    catch (fehler) { liste.prepend(fehlerzeile((fehler as Error).message)); alle.disabled = false; }
+
+  const alleHaken = document.createElement('label');
+  alleHaken.className = 'bleiben';
+  const alleKasten = document.createElement('input');
+  alleKasten.type = 'checkbox';
+  alleHaken.append(alleKasten, document.createTextNode(' Alle'));
+  alleKasten.onchange = () => {
+    gewaehlt.clear();
+    if (alleKasten.checked) stand.forEach(e => gewaehlt.add(e.id));
+    zeichnen();
   };
 
-  bereich.append(abschnitt('Zu prüfen', [alle]), liste);
+  const freigeben = knopf('Veröffentlichen', 'btn btn-primary');
+  freigeben.onclick = () => void handeln(undefined);
+
+  const planen = knopf('Planen…', 'btn');
+  planen.onclick = () => dialog({
+    titel: `${betroffene().length} Titel planen`,
+    text: 'Ab diesem Zeitpunkt erscheinen sie für alle. Es läuft dafür nichts '
+      + 'im Hintergrund — die Sichtbarkeit wird bei jeder Abfrage gerechnet und '
+      + 'stimmt deshalb auch, wenn der Server gerade nicht lief.',
+    felder: [{
+      name: 'wann', beschriftung: 'Zeitpunkt', art: 'zeitpunkt',
+      wert: inEingabeform(new Date(Date.now() + 86400000)),
+      min: inEingabeform(new Date()),
+    }],
+    bestaetigen: 'Planen',
+    tun: async wert => {
+      const wann = new Date(wert('wann'));
+      if (Number.isNaN(wann.getTime())) throw new Error('Das ist kein Zeitpunkt.');
+      await handeln(wann.toISOString());
+    },
+  });
+
+  bereich.append(abschnitt('Zu prüfen', [alleHaken, freigeben, planen]), liste);
   void laden();
 
-  async function laden(): Promise<void> {
+  /** Die Auswahl — oder alles, wenn nichts angehakt ist. */
-    let wartend: Pruefeintrag[];
+  function betroffene(): Pruefeintrag[] {
-    try { wartend = await zuPruefen(); } catch { bereich.classList.add('hidden'); return; }
+    const angehakt = stand.filter(e => gewaehlt.has(e.id));
+    return angehakt.length > 0 ? angehakt : stand;
+  }
 
-    if (wartend.length === 0) { bereich.classList.add('hidden'); return; }
+  async function handeln(wann: string | undefined): Promise<void> {
+    const ids = betroffene().flatMap(e => e.ids);
+    if (ids.length === 0) return;
+
+    freigeben.disabled = true;
+    planen.disabled = true;
+    try {
+      await veroeffentlichen(ids, wann);
+      gewaehlt.clear();
+      await laden();
+      geaendert();
+    } catch (fehler) {
+      liste.prepend(fehlerzeile((fehler as Error).message));
+    } finally {
+      freigeben.disabled = false;
+      planen.disabled = false;
+    }
+  }
+
+  async function laden(): Promise<void> {
+    try { stand = await zuPruefen(); } catch { bereich.classList.add('hidden'); return; }
+
+    if (stand.length === 0) { bereich.classList.add('hidden'); return; }
     bereich.classList.remove('hidden');
-    alle.disabled = false;
+
+    // Was es nicht mehr gibt, bleibt nicht angehakt.
+    const da = new Set(stand.map(e => e.id));
+    [...gewaehlt].forEach(id => { if (!da.has(id)) gewaehlt.delete(id); });
+
+    zeichnen();
+  }
+
+  function zeichnen(): void {
+    alleKasten.checked = gewaehlt.size > 0 && gewaehlt.size === stand.length;
+    alleKasten.indeterminate = gewaehlt.size > 0 && gewaehlt.size < stand.length;
+
+    const anzahl = betroffene().reduce((n, e) => n + e.count, 0);
+    const wieViele = gewaehlt.size > 0 ? `${anzahl} gewählt` : `alle ${anzahl}`;
+    freigeben.textContent = `Veröffentlichen (${wieViele})`;
 
     liste.innerHTML = '';
-    wartend.forEach(e => liste.appendChild(zeileFuer(e)));
+    stand.forEach(e => liste.appendChild(zeileFuer(e)));
   }
 
   function zeileFuer(e: Pruefeintrag): HTMLElement {
     const d = document.createElement('div');
     d.className = 'einstellung pruefzeile';
 
+    const haken = document.createElement('input');
+    haken.type = 'checkbox';
+    haken.checked = gewaehlt.has(e.id);
+    haken.setAttribute('aria-label', `„${e.title}“ auswählen`);
+    haken.onchange = () => {
+      if (haken.checked) gewaehlt.add(e.id); else gewaehlt.delete(e.id);
+      zeichnen();
+    };
+
     const bild = document.createElement('div');
     bild.className = 'pruef-bild';
     const adresse = bildAdresse(e.posterImage);
@@ -216,53 +294,39 @@ function pruefbereich(geaendert: () => void): HTMLElement {
     const text = document.createElement('div');
     text.className = 'zeile';
     text.style.flex = '1';
+
     const geplant = e.publishAt ? new Date(e.publishAt) : null;
-    const stand = geplant
+    const was = e.kind === 'series'
+      ? `${e.count} ${e.count === 1 ? 'Folge' : 'Folgen'}`
+      : null;
+    const lage = geplant
       ? `Geplant für ${geplant.toLocaleString('de-CH', { dateStyle: 'medium', timeStyle: 'short' })}`
-      : e.matched ? 'Wartet auf Freigabe'
+      : e.kind === 'series' && e.count > 1 && !e.publishAt
+        ? 'Wartet'
+        : 'Wartet auf Freigabe';
     // Ohne Zuordnung fehlen Titel und Bilder — dann ist nicht die Freigabe
     // das Nächste, sondern die Zuordnung.
-      : 'Wartet — und ist noch keinem Titel zugeordnet';
+    const hinweis = e.matched ? null : 'noch keinem Titel zugeordnet';
+
     text.innerHTML = `<strong>${esc(e.title)}${e.year ? ` (${e.year})` : ''}</strong>`
-      + `<span class="winzig">${esc(stand)}</span>`;
+      + `<span class="winzig">${[was, lage, hinweis].filter(Boolean).map(esc).join(' · ')}</span>`;
 
-    const frei = knopf('Veröffentlichen', 'btn');
+    const nur = knopf(geplant ? 'Jetzt veröffentlichen' : 'Veröffentlichen', 'btn');
-    frei.onclick = async () => {
+    nur.onclick = async () => {
-      frei.disabled = true;
+      nur.disabled = true;
-      try { await veroeffentlichen([e.id]); await laden(); geaendert(); }
+      try { await veroeffentlichen(e.ids); await laden(); geaendert(); }
-      catch (fehler) { d.appendChild(fehlerzeile((fehler as Error).message)); frei.disabled = false; }
+      catch (fehler) { d.appendChild(fehlerzeile((fehler as Error).message)); nur.disabled = false; }
     };
 
-    const planen = knopf('Planen', 'btn');
-    planen.onclick = () => dialog({
-      titel: `„${e.title}" planen`,
-      text: 'Ab diesem Zeitpunkt erscheint der Titel für alle. '
-        + 'Es läuft dafür nichts im Hintergrund — die Sichtbarkeit wird bei '
-        + 'jeder Abfrage gerechnet und stimmt deshalb auch, wenn der Server '
-        + 'gerade nicht lief.',
-      felder: [{
-        name: 'wann', beschriftung: 'Zeitpunkt', art: 'text',
-        wert: inEingabeform(geplant ?? new Date(Date.now() + 86400000)),
-        hinweis: 'Form: 2026-12-24 20:15',
-      }],
-      bestaetigen: 'Planen',
-      tun: async wert => {
-        const wann = new Date(wert('wann').replace(' ', 'T'));
-        if (Number.isNaN(wann.getTime())) throw new Error('Das ist kein Zeitpunkt.');
-        await veroeffentlichen([e.id], wann.toISOString());
-        await laden();
-      },
-    });
-
     const oben = document.createElement('div');
     oben.className = 'knopfreihe';
-    oben.append(bild, text, frei, planen);
+    oben.append(haken, bild, text, nur);
 
     if (geplant) {
       const zurueck = knopf('Zurückziehen', 'btn');
       zurueck.onclick = async () => {
         zurueck.disabled = true;
-        try { await zurueckziehen([e.id]); await laden(); }
+        try { await zurueckziehen(e.ids); await laden(); }
         catch (fehler) { d.appendChild(fehlerzeile((fehler as Error).message)); zurueck.disabled = false; }
       };
       oben.appendChild(zurueck);
@@ -280,11 +344,11 @@ function pruefbereich(geaendert: () => void): HTMLElement {
     return d;
   }
 
-  /** „2026-12-24 20:15" — ohne Zeitzone, weil man sie eintippt, nicht liest. */
+  /** Die Form, die `datetime-local` erwartet — Ortszeit ohne Zone. */
   function inEingabeform(d: Date): string {
     const z = (n: number) => String(n).padStart(2, '0');
     return `${d.getFullYear()}-${z(d.getMonth() + 1)}-${z(d.getDate())}`
-      + `${z(d.getHours())}:${z(d.getMinutes())}`;
+      + `T${z(d.getHours())}:${z(d.getMinutes())}`;
   }
 
   return bereich;