Eine Folge ist weder ein Film noch eine Serie

Die App meldete auf der Startseite „Dieser Titel ist auf dem Server nicht
mehr vorhanden" — über eine Folge, die sie selbst gerade anzeigte.

Gemessen im Quelltext: `item(id:)` probiert `/movies/{id}`, dann
`/series/{id}`, und wirft sonst `.notFound`. In „Weiterschauen" steht
eine Folge mit ihrer eigenen Kennung, und einen Endpunkt für eine
einzelne Folge gab es gar nicht. Jetzt gibt es `GET /api/v1/episodes/{id}`
— mit `SeriesId`, denn ohne die Serie fehlen der Folge Titel und Bild.
Im Simulator nachgestellt und nachgeprüft: die Seite steht.

**Zuletzt hinzugefügt.** Die App zeigte „Filme" und „Serien" — den Anfang
der Mediathek in der Reihenfolge der Datenbank, also immer denselben.
Jetzt je Mediathek eine Reihe „Neu in …", sortiert nach Zugang. Die
Kennungen beginnen nun mit `latest`, und daran hängen zwei Einstellungen,
die an einem Flaro-Server deshalb nichts taten: „Gesehenes in Neuzugängen
ausblenden" und „Aufmacher nur aus Neuzugängen".

**Geplante Titel.** `MediaItem` kennt jetzt `availableFrom`. Aufmacher und
Detailseite zeigen statt des Knopfes „Bald ist es soweit" mit dem Termin.
Die Kachel spielte trotzdem los — im Simulator kam der Spieler bis „Wird
vorbereitet …" —, also zählt ein geplanter Titel jetzt wie eine Sammlung:
nichts zu starten, der Tipp führt auf die Seite.

**Und das Bild im Aufmacher.** Bei einer angefangenen Folge stand dort ihr
Standbild statt des Bildes der Serie; wer der Serie eines ausgesucht
hatte, fand ein anderes vor. Die Kachel behält das Standbild — sie zeigt,
wo man steht —, der Aufmacher bekommt `SeriesBackdropImage`.

**Die Punkte im Karussell waren 26 × 3 Pixel.** Von drei Klicks auf
denselben Punkt traf nur der auf der Mittellinie; fünf Pixel daneben
geschah nichts. Der Knopf ist jetzt 27 Pixel hoch, sichtbar bleiben 3.

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

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

@@ -666,6 +666,47 @@ public static class LibraryContentEndpoints
                 PublishAt: folgen.Min(f => f.PublishAt)));
         }).RequireAuthorization();
 
+        // **Eine Folge für sich.**
+        //
+        // Es gab sie nur im Rudel — als Liste einer Serie. Die Apps reichen
+        // aber eine blanke Kennung durch: sie haben sie aus „Weiterschauen"
+        // und wissen nicht, ob ein Film, eine Serie oder eine Folge
+        // dahintersteckt. Sie fragten der Reihe nach Film und Serie, fanden
+        // beides nicht und meldeten „Dieser Titel ist auf dem Server nicht
+        // mehr vorhanden" — über eine Folge, die sie selbst gerade zeigten.
+        app.MapGet("/api/v1/episodes/{id:guid}", async (
+            Guid id, ClaimsPrincipal wer, FlaroContext db) =>
+        {
+            var folge = await db.Episodes.AsNoTracking()
+                .Where(f => f.Id == id)
+                .Select(f => new
+                {
+                    f.Id, f.SeriesId, f.SeasonNumber, f.EpisodeNumber,
+                    f.Title, f.Overview, f.StillImage, f.PublishAt,
+                })
+                .FirstOrDefaultAsync();
+            if (folge is null) return Results.NotFound();
+
+            var dateien = await db.MediaFiles.AsNoTracking()
+                .Where(d => d.EpisodeId == id)
+                .Select(d => new { d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, d.VersionLabel })
+                .ToListAsync();
+            var spuren = await SpurenZu(db, dateien.Select(d => d.Id).ToList());
+            var stände = await ZuständeZu(db, wer, folgen: [id]);
+
+            var wurzel = await MediathekspfadFuer(db, wer,
+                await db.Series.AsNoTracking().Where(x => x.Id == folge.SeriesId)
+                    .Select(x => x.LibraryId).FirstAsync());
+
+            return Results.Ok(new EpisodeResponse(
+                folge.Id, folge.SeasonNumber, folge.EpisodeNumber,
+                folge.Title, folge.Overview, folge.StillImage,
+                dateien.Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren, d.VersionLabel, wurzel)).ToList(),
+                stände.GetValueOrDefault(id),
+                folge.PublishAt,
+                SeriesId: folge.SeriesId));
+        }).RequireAuthorization();
+
         // **Die nächste Folge nach dieser.** Reihenfolge ist Staffel, dann
         // Folge — nicht die Kennung: die ist zeitlich geordnet und sagt, wann
         // der Scan sie fand, nicht wann sie läuft.
@@ -709,7 +750,8 @@ public static class LibraryContentEndpoints
                 naechste.Title, naechste.Overview, naechste.StillImage ?? serienBild,
                 dateien.Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren, d.VersionLabel)).ToList(),
                 stände.GetValueOrDefault(naechste.Id),
-                naechste.PublishAt));
+                naechste.PublishAt,
+                SeriesId: diese.SeriesId));
         }).RequireAuthorization();
 
         app.MapGet("/api/v1/series/{id:guid}/episodes", async (
@@ -747,7 +789,8 @@ public static class LibraryContentEndpoints
                 dateien.Where(d => d.EpisodeId == f.Id)
                     .Select(d => Datei(d.Id, d.Path, d.SizeBytes, d.Container, d.Duration, spuren, d.VersionLabel, wurzel)).ToList(),
                 stände.GetValueOrDefault(f.Id),
-                f.PublishAt)).ToList();
+                f.PublishAt,
+                SeriesId: id)).ToList();
 
             return Results.Ok(new Page<EpisodeResponse>(items, items.Count));
         }).RequireAuthorization();