feat(v5): Kern 5.4.0 — Vorgaenge, Kompressions-Warteschlange, Roh-Aufraeumen, Sprachen je Titel, Erkennung v2

WAS: Der Rip endet, sobald die Roh-Dateien liegen; die Kompression laeuft
danach in einer Warteschlange (eine zur Zeit), das Laufwerk ist frei fuer
die naechste Disc. Jeder Rip ist jetzt ein Datensatz (Tabelle vorgaenge,
Schema 4): Roh-Ordner, Zielordner, Phase, Auftrag als JSON. Darauf bauen:
Roh-Aufraeumen nach Regel (Vorgabe 7 Tage, nur bei gelungener Kompression
und nur wenn jede fertige Datei da und nicht leer ist), Wiederholen ab
Kompression, Aufraeumen halber Dateien nach Abbruch/Fehler, Wiederaufnahme
nach Neustart. Unkomprimierte Rips (4K, kein HandBrake) werden in den
Zielordner VERSCHOBEN statt unter roh\ liegen zu bleiben.
Sprachen je Titel reisen vom Info-Lauf (SINFO) bis in HandBrake; fremder
Ton schaltet den deutschen Untertitel vor (--subtitle-default=1). Vor der
Kompression prueft ein HandBrake-Scan die Roh-Datei. MakeMKVs
Auswahlregel wird gesetzt, wenn keine steht, damit alle Sprachen in die
Roh-Datei kommen. Staffel und erste Folge von Hand schlagen die
Laufzeit-Raterei. Durchgehender Fortschritt, nach Groesse gewichtet.
Erkennung v2: leere TMDb-Eintraege (Stubs) zaehlen nicht, Laufzeit wird
nach dem Info-Lauf gegen TMDb gehalten, Titel-Struktur als Fingerabdruck,
bdmt_deu als zweite Titel-Variante. TMDb liefert Logo, Tagline,
Bewertung, FSK und Besetzung in derselben Anfrage. Laufwerks-Gesundheit
aus dem Windows-Ereignisprotokoll (wevtutil): Disc oder Hardware.

WARUM: Uebergabe-Punkte 1-5, 8-12 des SAVEPOINT vom 01.09.2026 — vom
Commander gutgeheissen (7 Tage / Untertitel vorgewaehlt / entkoppelte
Kompression waren seine Wahl).

GEMESSEN (Regel D): HandBrake 1.11 Sprach-Schalter an einer ffmpeg-
Testdatei (jpn/deu/deu/eng + deu/eng), HandBrake --scan --json Format,
TMDb movie/149 + tv/46296 mit append_to_response, wevtutil /f:xml an
diesem PC (338x cdrom 7, 8x cdrom 11 in 30 Tagen), makemkvcon --minlength,
MakeMKV-Auswahlregel laut forum.makemkv.com t=4386.

348 Tests gruen (vorher 261), Typpruefung und Bau gruen. Oberflaeche
folgt im naechsten Schritt.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

rippy-windows/src/kern/metadaten/zuordnung.ts

@@ -12,9 +12,24 @@
 //
 // Rippy sagt nicht „das ist Akira", sondern „sehr wahrscheinlich Akira
 // (1988)" — und fragt nur, wenn es das nicht sagen kann (§ 5).
+//
+// 5.4.0 — Erkennung v2, drei Ergänzungen, alle an echten Daten bezahlt:
+//  * STUBS: TMDb hat „Spartacus: Gods of the Arena" dreimal als leeren
+//    Serien-Eintrag (kein Backdrop, keine Beschreibung, 1 Folge,
+//    Popularität 1). Ein wörtlicher Treffer darauf sah 5.1.1 als 90 %
+//    sicher an — es war ein Eintrag ohne Inhalt. Leere Einträge zählen
+//    nicht mehr als Treffer.
+//  * LAUFZEIT: Nach dem Info-Lauf wird die gemessene Länge des Hauptinhalts
+//    gegen TMDb gehalten (nachpruefen). Passt sie, wird aus „wahrscheinlich"
+//    „bestätigt"; passt sie gar nicht (95 vs. 158 min), fällt der Treffer
+//    auf einen Vorschlag zurück.
+//  * VARIANTEN: Die Disc trägt oft zwei Titel (bdmt_eng UND bdmt_deu) —
+//    jede Variante wird gefragt, und die Abdeckung wird an IHRER Vorlage
+//    gemessen, nicht an der englischen.
 import { discZusatzAbtrennen, titelKandidaten } from './discmerkmale'
-import type { FilmDetails, FilmTreffer, TmdbClient } from './tmdb'
+import { besetzungAus, fskAus, logoAus, type FilmDetails, type FilmTreffer, type TmdbClient } from './tmdb'
 import type { OmdbClient, OmdbTreffer } from './omdb'
+import type { Darsteller } from '../../gemeinsam/nachrichten'
 
 export const WENIGE_TREFFER = 3
 
@@ -30,6 +45,14 @@ export interface MetaTreffer {
   laufzeitMinuten: number
   genres: string[]
   quelle: 'tmdb' | 'omdb' | ''
+  // ── Kino-Banner v2 (5.4.0) ──
+  logoPfad: string
+  tagline: string
+  bewertung: number
+  fsk: string
+  besetzung: Darsteller[]
+  /** Folgen laut TMDb (Serie) — 0 wenn unbekannt/Film. */
+  folgenGesamt: number
 }
 
 export interface Zuordnung {
@@ -37,6 +60,8 @@ export interface Zuordnung {
   jahr: number | null
   confidence: number
   meta: MetaTreffer
+  /** Was Rippy nach dem Info-Lauf noch dazugelernt hat (nachpruefen). */
+  hinweise?: string[]
 }
 
 function jahrAus(datum: string | undefined): number | null {
@@ -45,7 +70,11 @@ function jahrAus(datum: string | undefined): number | null {
   return Number.isFinite(jahr) && jahr > 0 ? jahr : null
 }
 
-function ausDetails(typ: 'movie' | 'tv', id: number, details: FilmDetails): MetaTreffer {
+export function ausDetails(typ: 'movie' | 'tv', id: number, details: FilmDetails): MetaTreffer {
+  const laufzeit =
+    typ === 'movie'
+      ? (details.runtime ?? 0)
+      : ((details.episode_run_time ?? []).find((m) => typeof m === 'number' && m > 0) ?? 0)
   return {
     typ,
     id,
@@ -54,9 +83,15 @@ function ausDetails(typ: 'movie' | 'tv', id: number, details: FilmDetails): Meta
     beschreibung: details.overview ?? '',
     posterPfad: details.poster_path ?? '',
     backdropPfad: details.backdrop_path ?? '',
-    laufzeitMinuten: details.runtime ?? 0,
+    laufzeitMinuten: laufzeit,
     genres: (details.genres ?? []).map((g) => g.name),
     quelle: 'tmdb',
+    logoPfad: logoAus(details.images?.logos),
+    tagline: (details.tagline ?? '').trim(),
+    bewertung: typeof details.vote_average === 'number' ? Math.round(details.vote_average * 10) / 10 : 0,
+    fsk: fskAus(details, typ),
+    besetzung: besetzungAus(details.credits?.cast),
+    folgenGesamt: typ === 'tv' ? (details.number_of_episodes ?? 0) : 0,
   }
 }
 
@@ -73,27 +108,51 @@ function ausOmdb(treffer: OmdbTreffer): MetaTreffer {
     laufzeitMinuten: treffer.runtime,
     genres: treffer.genres,
     quelle: 'omdb',
+    logoPfad: '',
+    tagline: '',
+    bewertung: 0,
+    fsk: '',
+    besetzung: [],
+    folgenGesamt: 0,
   }
 }
 
+export const LEERER_TREFFER: MetaTreffer = {
+  typ: 'unknown',
+  id: null,
+  titel: '',
+  jahr: null,
+  beschreibung: '',
+  posterPfad: '',
+  backdropPfad: '',
+  laufzeitMinuten: 0,
+  genres: [],
+  quelle: '',
+  logoPfad: '',
+  tagline: '',
+  bewertung: 0,
+  fsk: '',
+  besetzung: [],
+  folgenGesamt: 0,
+}
+
 const UNBEKANNT = (titel: string): Zuordnung => ({
   titel,
   jahr: null,
   confidence: 0.3,
-  meta: {
-    typ: 'unknown',
-    id: null,
-    titel,
-    jahr: null,
-    beschreibung: '',
-    posterPfad: '',
-    backdropPfad: '',
-    laufzeitMinuten: 0,
-    genres: [],
-    quelle: '',
-  },
+  meta: { ...LEERER_TREFFER, titel },
 })
 
+/** Ein Eintrag ohne Inhalt ist kein Treffer (pur). Gemessen an den drei
+ *  „Spartacus: Gods of the Arena"-Stubs: kein Backdrop, keine Beschreibung,
+ *  keine Bewertung — TMDb kennt dort nur den Namen. */
+export function istStub(details: FilmDetails): boolean {
+  const beschreibung = (details.overview ?? '').trim().length > 0
+  const bild = (details.backdrop_path ?? '') !== '' && details.backdrop_path !== null
+  const bewertet = (details.vote_count ?? 0) > 0
+  return !beschreibung && !bild && !bewertet
+}
+
 /** Titel → Wortmenge, Satzzeichen fallen weg. Grundlage von Überlappung,
  *  Abdeckung und Titelvergleich — alle drei sollen dasselbe „Wort" meinen. */
 function worte(t: string): Set<string> {
@@ -163,6 +222,35 @@ export interface DiscHinweis {
    *  trägt (discmerkmale.discTitel().istSerie). Dann sind die Film-Zweige
    *  aus: Was bewiesen ist, muss nicht mehr geraten werden. */
   istSerie?: boolean
+  /** Weitere Titel derselben Disc (bdmt_deu neben bdmt_eng, 5.4.0). */
+  alternativen?: readonly string[]
+}
+
+interface Kandidat {
+  text: string
+  /** Die Vorlage, an der die Abdeckung gemessen wird (Titel ohne Zusatz). */
+  massstab: string
+}
+
+/** Suchvarianten aller Titel-Varianten: erst die vollen Titel, dann die
+ *  gestutzten — je Variante an ihrer eigenen Vorlage gemessen (pur). */
+export function kandidatenAus(titel: string, alternativen: readonly string[] = []): Kandidat[] {
+  const quellen = [titel, ...alternativen].map((t) => t.trim()).filter((t) => t.length > 0)
+  const gesehen = new Set<string>()
+  const voll: Kandidat[] = []
+  const rest: Kandidat[] = []
+  for (const quelle of quellen) {
+    const massstab = discZusatzAbtrennen(quelle).titel || quelle
+    const varianten = titelKandidaten(quelle)
+    if (varianten.length === 0) varianten.push(quelle)
+    varianten.forEach((text, i) => {
+      const schluessel = text.toLowerCase()
+      if (gesehen.has(schluessel)) return
+      gesehen.add(schluessel)
+      ;(i === 0 ? voll : rest).push({ text, massstab })
+    })
+  }
+  return [...voll, ...rest]
 }
 
 /** Die Kaskade — Clients injiziert, damit sie ohne Netz prüfbar ist.
@@ -183,6 +271,8 @@ export interface DiscHinweis {
  *     '- Disc 2' zählen nicht mit). Vorher hing das an „Kandidat Nummer
  *     0"; sobald der Zusatz abgetrennt wurde, war der richtige Kandidat
  *     Nummer 1 und fiel durch dieses Raster.
+ *   * (5.4.0) Ein Eintrag ohne Inhalt (istStub) ist kein Treffer — der
+ *     nächste wörtliche Treffer bekommt die Chance.
  */
 export async function zuordnen(
   discTitel: string,
@@ -194,43 +284,39 @@ export async function zuordnen(
   if (titel.length === 0) return UNBEKANNT('')
 
   const nurSerie = hinweis.istSerie === true
-  // Maßstab für die Abdeckung ist der Titel OHNE Verpackungs-Zusatz:
-  // '- Disc 2' ist Rauschen und darf einer guten Frage nicht angelastet werden.
-  const massstab = discZusatzAbtrennen(titel).titel || titel
-  const kandidaten = titelKandidaten(titel)
-  if (kandidaten.length === 0) kandidaten.push(titel)
+  const kandidaten = kandidatenAus(titel, hinweis.alternativen ?? [])
 
   let ersteFilme: FilmTreffer[] = []
   let ersteSerien: FilmTreffer[] = []
 
   for (const kandidat of kandidaten) {
-    const deckung = abdeckung(massstab, kandidat)
+    const deckung = abdeckung(kandidat.massstab, kandidat.text)
     const vollstaendig = deckung >= 1
     /** Ein Treffer auf eine stark gestutzte Frage bleibt ein Vorschlag. */
     const deckel = (basis: number): number => (deckung >= MINDEST_ABDECKUNG ? basis : Math.min(basis, VORSCHLAG))
 
-    const filme = nurSerie ? [] : ((await tmdb.searchMovie(kandidat)) ?? [])
+    const filme = nurSerie ? [] : ((await tmdb.searchMovie(kandidat.text)) ?? [])
     if (filme.length > 0 && ersteFilme.length === 0) ersteFilme = filme
 
     // Wörtlicher Filmtreffer (0,95)
     for (const film of filme) {
-      if (gleichBedeutend(film.title ?? '', kandidat)) {
+      if (gleichBedeutend(film.title ?? '', kandidat.text)) {
         const details = await tmdb.movieDetails(film.id)
-        if (details !== null) {
+        if (details !== null && !istStub(details)) {
           const meta = ausDetails('movie', film.id, details)
           return { titel: meta.titel, jahr: meta.jahr, confidence: deckel(0.95), meta }
         }
       }
     }
 
-    const serien = (await tmdb.searchTv(kandidat)) ?? []
+    const serien = (await tmdb.searchTv(kandidat.text)) ?? []
     if (serien.length > 0 && ersteSerien.length === 0) ersteSerien = serien
 
     // Wörtlicher Serientreffer (0,90)
     for (const serie of serien) {
-      if (gleichBedeutend(serie.name ?? '', kandidat)) {
+      if (gleichBedeutend(serie.name ?? '', kandidat.text)) {
         const details = await tmdb.tvDetails(serie.id)
-        if (details !== null) {
+        if (details !== null && !istStub(details)) {
           const meta = ausDetails('tv', serie.id, details)
           return { titel: meta.titel, jahr: meta.jahr, confidence: deckel(0.9), meta }
         }
@@ -239,20 +325,24 @@ export async function zuordnen(
 
     // Spezifische Treffer (0,80): Wer auf eine VOLLSTÄNDIGE Anfrage eine
     // Handvoll bekommt, hat gefragt wie jemand, der weiß, was er sucht
-    // (der Evangelion-Fund).
+    // (der Evangelion-Fund). Stubs zählen dabei nicht mit.
     if (vollstaendig) {
       if (filme.length > 0 && filme.length <= WENIGE_TREFFER) {
-        const details = await tmdb.movieDetails(filme[0].id)
-        if (details !== null) {
-          const meta = ausDetails('movie', filme[0].id, details)
-          return { titel: meta.titel, jahr: meta.jahr, confidence: 0.8, meta }
+        for (const film of filme) {
+          const details = await tmdb.movieDetails(film.id)
+          if (details !== null && !istStub(details)) {
+            const meta = ausDetails('movie', film.id, details)
+            return { titel: meta.titel, jahr: meta.jahr, confidence: 0.8, meta }
+          }
         }
       }
       if (serien.length > 0 && serien.length <= WENIGE_TREFFER) {
-        const details = await tmdb.tvDetails(serien[0].id)
-        if (details !== null) {
-          const meta = ausDetails('tv', serien[0].id, details)
-          return { titel: meta.titel, jahr: meta.jahr, confidence: 0.8, meta }
+        for (const serie of serien) {
+          const details = await tmdb.tvDetails(serie.id)
+          if (details !== null && !istStub(details)) {
+            const meta = ausDetails('tv', serie.id, details)
+            return { titel: meta.titel, jahr: meta.jahr, confidence: 0.8, meta }
+          }
         }
       }
     }
@@ -262,7 +352,7 @@ export async function zuordnen(
   //    Datensatz wird über TMDb /find (IMDb-ID) nachgeladen.
   if (omdb.verfuegbar) {
     for (const kandidat of kandidaten) {
-      const treffer = await omdb.lookup(kandidat)
+      const treffer = await omdb.lookup(kandidat.text)
       if (treffer !== null) {
         // Eine Serien-Disc nimmt keinen Film entgegen — sie hat bewiesen,
         // was sie ist.
@@ -270,7 +360,7 @@ export async function zuordnen(
         // Ähnlichkeits-Gate: OMDbs t=-Suche antwortet auch auf kryptische
         // Labels mit irgendeinem Film — gemessen „Bd Evg D2" → „BD Scream
         // 5". Ohne echte Wort-Überlappung ist das kein Treffer.
-        if (wortUeberlappung(kandidat, treffer.title) < 0.5) continue
+        if (wortUeberlappung(kandidat.text, treffer.title) < 0.5) continue
         const meta = ausOmdb(treffer)
         if (typeof meta.id === 'string' && meta.id.startsWith('tt') && tmdb.verfuegbar) {
           const deutsch = await tmdb.findByImdb(meta.id)
@@ -288,7 +378,7 @@ export async function zuordnen(
         }
         // Auch OMDb wird gedeckelt: Ein Treffer auf eine ausgedünnte Frage
         // ist ein Vorschlag, egal von welchem Dienst er kommt.
-        const sicher = abdeckung(massstab, kandidat) >= MINDEST_ABDECKUNG ? 0.8 : VORSCHLAG
+        const sicher = abdeckung(kandidat.massstab, kandidat.text) >= MINDEST_ABDECKUNG ? 0.8 : VORSCHLAG
         return { titel: meta.titel, jahr: meta.jahr, confidence: sicher, meta }
       }
     }
@@ -296,20 +386,26 @@ export async function zuordnen(
 
   // 5. Vorschlag: bester Rohtreffer (0,60) — das UI fragt nach. Bei einer
   //    Serien-Disc ist die Filmliste leer, dort zählen nur die Serien.
-  if (ersteFilme.length > 0) {
-    const details = await tmdb.movieDetails(ersteFilme[0].id)
-    if (details !== null) {
-      const meta = ausDetails('movie', ersteFilme[0].id, details)
-      return { titel: meta.titel, jahr: meta.jahr, confidence: VORSCHLAG, meta }
-    }
+  //    Einträge MIT Inhalt zuerst; ist alles leer, bleibt der erste Treffer
+  //    trotzdem ein Vorschlag — besser als gar keiner (es wird ja gefragt).
+  let notnagel: Zuordnung | null = null
+  for (const film of ersteFilme.slice(0, WENIGE_TREFFER)) {
+    const details = await tmdb.movieDetails(film.id)
+    if (details === null) continue
+    const meta = ausDetails('movie', film.id, details)
+    const vorschlag = { titel: meta.titel, jahr: meta.jahr, confidence: VORSCHLAG, meta }
+    if (!istStub(details)) return vorschlag
+    notnagel ??= vorschlag
   }
-  if (ersteSerien.length > 0) {
-    const details = await tmdb.tvDetails(ersteSerien[0].id)
-    if (details !== null) {
-      const meta = ausDetails('tv', ersteSerien[0].id, details)
-      return { titel: meta.titel, jahr: meta.jahr, confidence: VORSCHLAG, meta }
-    }
+  for (const serie of ersteSerien.slice(0, WENIGE_TREFFER)) {
+    const details = await tmdb.tvDetails(serie.id)
+    if (details === null) continue
+    const meta = ausDetails('tv', serie.id, details)
+    const vorschlag = { titel: meta.titel, jahr: meta.jahr, confidence: VORSCHLAG, meta }
+    if (!istStub(details)) return vorschlag
+    notnagel ??= vorschlag
   }
+  if (notnagel !== null) return notnagel
 
   return UNBEKANNT(titel)
 }
@@ -318,3 +414,71 @@ export async function zuordnen(
 export function istSicherGenug(zuordnung: Zuordnung, schwelle = 0.9): boolean {
   return zuordnung.confidence >= schwelle
 }
+
+/** Laufzeit passt, wenn die gemessene Länge des Hauptinhalts höchstens so
+ *  weit von TMDb abweicht (Kino- gegen Heimvideo-Fassung, Abspann). */
+export const LAUFZEIT_PASST = 0.06
+/** Darüber passt sie NICHT — der Treffer wird zum Vorschlag (95 vs. 158 min). */
+export const LAUFZEIT_FALSCH = 0.25
+
+/** Was der Info-Lauf über die Disc gemessen hat (rip/titelwahl.ts). */
+export interface Messung {
+  /** Länge des Hauptinhalts in Sekunden (Film) — 0 wenn keiner erkennbar. */
+  hauptS: number
+  /** Längen der Folgen-Kandidaten in Sekunden (Serie). */
+  folgenS: readonly number[]
+  /** Was die Titel-Struktur sagt: 'film' | 'serie' | 'unklar'. */
+  struktur: 'film' | 'serie' | 'unklar'
+}
+
+/**
+ * Nachprüfen NACH dem Info-Lauf (pur, 5.4.0): Erkannt wird beim EINLEGEN,
+ * also vor jeder Messung. Jetzt liegt die stärkste Evidenz vor, die zu
+ * haben ist — die Laufzeit. Aus „wahrscheinlich" wird „bestätigt", oder
+ * Rippy merkt selbst, dass es danebenlag. Eine Wahl des Nutzers
+ * (confidence 1) wird nie herabgestuft, nur kommentiert.
+ */
+export function nachpruefen(zuordnung: Zuordnung, messung: Messung): Zuordnung {
+  const hinweise: string[] = []
+  let confidence = zuordnung.confidence
+  const meta = zuordnung.meta
+  const vomNutzer = zuordnung.confidence >= 1
+  const soll = meta.laufzeitMinuten * 60
+
+  if (meta.typ === 'movie' && soll > 0 && messung.hauptS > 0) {
+    const abweichung = Math.abs(messung.hauptS - soll) / soll
+    const ist = Math.round(messung.hauptS / 60)
+    if (abweichung <= LAUFZEIT_PASST) {
+      hinweise.push(`Laufzeit bestätigt: ${ist} min auf der Disc, ${meta.laufzeitMinuten} min bei TMDb.`)
+      if (!vomNutzer) confidence = Math.max(confidence, 0.95)
+    } else if (abweichung >= LAUFZEIT_FALSCH) {
+      hinweise.push(
+        `Laufzeit passt NICHT: ${ist} min auf der Disc, ${meta.laufzeitMinuten} min bei TMDb — bitte über „Ändern …" nachsehen.`,
+      )
+      if (!vomNutzer) confidence = Math.min(confidence, VORSCHLAG)
+    } else {
+      hinweise.push(`Laufzeit ähnlich: ${ist} min auf der Disc, ${meta.laufzeitMinuten} min bei TMDb (andere Fassung?).`)
+    }
+  } else if (meta.typ === 'tv' && soll > 0 && messung.folgenS.length > 0) {
+    const mittel = messung.folgenS.reduce((s, f) => s + f, 0) / messung.folgenS.length
+    const abweichung = Math.abs(mittel - soll) / soll
+    const ist = Math.round(mittel / 60)
+    if (abweichung <= 0.2) {
+      hinweise.push(`Folgenlänge passt: ${ist} min auf der Disc, ${meta.laufzeitMinuten} min bei TMDb.`)
+      if (!vomNutzer) confidence = Math.max(confidence, 0.8)
+    } else if (abweichung >= 0.5) {
+      hinweise.push(`Folgenlänge passt NICHT: ${ist} min auf der Disc, ${meta.laufzeitMinuten} min bei TMDb.`)
+      if (!vomNutzer) confidence = Math.min(confidence, VORSCHLAG)
+    }
+  }
+
+  if (messung.struktur === 'serie' && meta.typ === 'movie') {
+    hinweise.push('Die Titel-Struktur sieht nach einer Serienstaffel aus (mehrere gleich lange Titel), TMDb-Treffer ist ein Film.')
+    if (!vomNutzer) confidence = Math.min(confidence, VORSCHLAG)
+  } else if (messung.struktur === 'film' && meta.typ === 'tv') {
+    hinweise.push('Die Titel-Struktur sieht nach einem Film aus (ein langer Titel), TMDb-Treffer ist eine Serie.')
+    if (!vomNutzer) confidence = Math.min(confidence, VORSCHLAG)
+  }
+
+  return { ...zuordnung, confidence: Math.round(confidence * 100) / 100, hinweise }
+}