fix(v5): Der Kern verwarf 'titel-lesen' STILL — Auswahl-Dialog hing ewig

Commander: "das funktioniert nicht, du kannst gerne am lebenen objekt
pruefen". Der Dialog blieb bei "Rippy liest die Titel der Disc ..."
stehen, ohne Fehler, ohne Ende.

Ursache, am lebenden Objekt gemessen: NICHT der Info-Lauf.

  makemkvcon -r --noscan info dev:G:  ->  0,8 s, TCOUNT:0
  MSG:5042 "konnte keine verwendbaren optischen Laufwerke finden"

Der Lauf antwortet also sofort. Der Fehler lag in MEINEM Code von 5.2.0:
istFensterNachricht() kannte 'titel-lesen' und 'rip-ueberspringen' nicht
— beide standen in der FensterNachricht-Union, aber nicht im Pruefer.
Der Kern verwarf sie mit `if (!istFensterNachricht(frage)) return`.
STILL. Genau die R4-Wunde, vor der die Hausordnung warnt.

Auf drei Ebenen behoben:

1. Der Pruefer kennt beide Nachrichten.
2. Eine verworfene Nachricht ist jetzt LAUT: console.error plus
   kern-fehler ins Fenster mit der Art, die verworfen wurde.
3. Neuer Waechter-Test (waechter.test.ts): Er liest das Schema und
   vergleicht JEDE `art: '...'` der Unions mit dem jeweiligen Pruefer;
   dazu prueft er, dass der Kern nicht mehr still verwirft.
   GEGENPROBE gemacht: Mit zurueckgenommener Reparatur schlaegt er fehl
   ("expected [ 'titel-lesen' ] to deeply equal []"), mit Reparatur ist
   er gruen. Kein Deko-Test.

Dazu: Der Info-Lauf reicht die URSACHE durch (DiscInfo.ursachen aus den
kritischen MSG-Nummern). Kam nichts heraus und MakeMKV hat einen Grund
genannt, steht im Dialog der Grund statt "keine Titel gefunden" — beim
5042-Zustand also die Abhilfe (Disc neu einlegen, Laufwerk ab- und
anstecken, notfalls neu starten) statt eines Fingerzeigs auf die Disc.

Neu test/messung.titelwahl.test.ts — faehrt am echten Laufwerk genau den
Weg des Kerns nach (Info-Lauf, Vorauswahl, Dialog-Fehlertext).

Zweimal in dieselbe Heredoc-Falle getappt (AGENTS.md warnt davor):
Escape-Sequenzen wurden halbiert, ein rohes CR landete in makemkv.ts.
Beides korrigiert; der Hygiene-Waechter haette das CR auch gefangen.

260 Tests gruen (vorher 257), Typpruefung sauber. Version 5.3.1.

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

rippy-windows/src/gemeinsam/nachrichten.ts

@@ -376,7 +376,13 @@ export function istDbStatus(wert: unknown): wert is DbStatus {
 export function istFensterNachricht(wert: unknown): wert is FensterNachricht {
   if (!istObjekt(wert)) return false
   if (wert.art === 'ping') return typeof wert.zeit === 'number'
-  if (wert.art === 'auswerfen' || wert.art === 'rip-start' || wert.art === 'rip-abbruch') {
+  if (
+    wert.art === 'auswerfen' ||
+    wert.art === 'titel-lesen' ||
+    wert.art === 'rip-start' ||
+    wert.art === 'rip-abbruch' ||
+    wert.art === 'rip-ueberspringen'
+  ) {
     return typeof wert.id === 'string' && wert.id.length > 0
   }
   if (wert.art === 'einstellung-setzen') {

rippy-windows/src/kern/index.ts

@@ -313,9 +313,22 @@ async function titelLesen(id: string): Promise<void> {
       istSerie: merkmale?.istSerie ?? false,
       folgen: merkmale?.folgen ?? 0,
     })
+    // Kam nichts heraus UND MakeMKV hat einen Grund genannt, dann ist der
+    // Grund die Nachricht — nicht „keine Titel gefunden". Am 01.09.2026
+    // gemessen: Beim 5042-Zustand antwortet der Info-Lauf nach 0,7 s mit
+    // TCOUNT:0, und ohne diesen Zweig stünde im Fenster, die DISC gäbe
+    // nichts her — dabei sieht MakeMKV das LAUFWERK nicht.
+    const ohneErgebnis = info.titel.length === 0 && info.ursachen.length > 0
     anFenster({
       art: 'disc-titel',
-      stand: { id, laeuft: false, titel: wahl.titel, einordnung: wahl.einordnung, unsicher: wahl.unsicher, fehler: '' },
+      stand: {
+        id,
+        laeuft: false,
+        titel: wahl.titel,
+        einordnung: wahl.einordnung,
+        unsicher: wahl.unsicher,
+        fehler: ohneErgebnis ? info.ursachen.join(' · ') : '',
+      },
     })
   } catch (fehler) {
     // R4: laut scheitern. „Konnte nicht nachsehen" ist etwas anderes als
@@ -640,7 +653,19 @@ process.parentPort.on('message', (ereignis) => {
     if (fensterPort === null) return
     fensterPort.on('message', (portEreignis) => {
       const frage: unknown = portEreignis.data
-      if (!istFensterNachricht(frage)) return
+      if (!istFensterNachricht(frage)) {
+        // R4: Eine verworfene Nachricht verschwindet NICHT still. Genau
+        // das kostete am 01.09.2026 eine Runde — 'titel-lesen' fehlte im
+        // Prüfer, der Kern warf sie weg, und im Fenster stand ewig
+        // „Rippy liest die Titel …", ohne dass irgendwo etwas stand.
+        const art =
+          typeof frage === 'object' && frage !== null
+            ? String((frage as Record<string, unknown>).art)
+            : typeof frage
+        console.error(`[kern] Fenster-Nachricht verworfen (unbekannt): ${art}`)
+        anFenster({ art: 'kern-fehler', text: `Nachricht „${art}" wurde verworfen — sie ist dem Kern unbekannt.` })
+        return
+      }
       if (frage.art === 'ping') {
         anFenster({ art: 'pong', zeit: frage.zeit })
       } else if (frage.art === 'auswerfen') {

rippy-windows/src/kern/rip/makemkv.ts

@@ -1,268 +1,286 @@
-// makemkvcon ansprechen — Kommandobau und Lauf (KONZEPT § 6.2).
-// Die Auswertung der Ausgabe steckt in RipAuswertung (pur, testbar);
-// hier bleiben nur spawn, Zeilenzerlegung und Aufräumen.
-//
-// Was aus dem Docker-Zweig zwingend mitkommt (ripping.py, gemessen):
-//  - Robot-Mode: -r --noscan --progress=-same (--noscan: der Geräte-Scan
-//    hing bzw. stürzte — Befund 23.07.)
-//  - BINÄR lesen, je Zeile dekodieren (textVon): makemkvcon mischt
-//    Kodierungen; „Das Öffnen" war die Folge von text=True.
-//  - Lesefehler heißen Lesefehler: MakeMKV kann 1 von 2 Titeln sichern und
-//    sich trotzdem mit 0 beenden (30.08.2026, Spartacus Disc 2).
-//  - Kritische MSG-NUMMERN einsammeln — die letzte Zeile ist fast immer
-//    nur „Failed to open disc", die Ursache steht Zeilen davor.
-import { spawn } from 'node:child_process'
-import { mkdirSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-import {
-  KRITISCHE_CODES,
-  KRITISCHE_TEXTE,
-  LESEFEHLER_MARKE,
-  offsetAusMeldung,
-  parseMsg,
-  parseStreamInfo,
-  parseTitelInfo,
-  progressAusPrgv,
-  quelle,
-  sprachenZusammenfassen,
-  textVon,
-  type SprachEintrag,
-  type TitelInfo,
-  type TitelStreams,
-} from './parser'
-
-export function buildInfoArgs(geraetepfad: string): string[] {
-  return ['-r', '--noscan', 'info', quelle(geraetepfad)]
-}
-
-export function buildRipArgs(geraetepfad: string, zielOrdner: string, titel: string): string[] {
-  return ['-r', '--noscan', '--progress=-same', 'mkv', quelle(geraetepfad), titel, zielOrdner]
-}
-
-/** Ab so vielen Meldungen an DERSELBEN Stelle gilt der Lauf als hängend.
- *  Jeder Leseversuch wirft zwei Zeilen (SCSI-Fehler + Betriebssystemfehler),
- *  zwölf sind also rund sechs Versuche — genug, um einen kurzen Aussetzer
- *  von einem echten Defekt zu unterscheiden. */
-export const HAENGT_AB = 12
-
-/** Auswertung der Rip-Ausgabe — pur, eine Zeile nach der anderen. */
-export class RipAuswertung {
-  prozent = -1
-  letzteMeldung = ''
-  lesefehler = false
-  kritischeMeldungen: string[] = []
-  /** Die Stelle, an der es zuletzt klemmte — '' wenn keine. */
-  haengtBei = ''
-  /** Wie oft dieselbe Stelle schon gemeldet wurde. */
-  haengtWiederholungen = 0
-
-  /** Klemmt der Lauf an einer festen Stelle? Dann ist das ein Defekt auf
-   *  der Disc und kein Fortschrittsproblem — Weiterversuchen hilft nicht. */
-  haengt(): boolean {
-    return this.haengtBei.length > 0 && this.haengtWiederholungen >= HAENGT_AB
-  }
-
-  /** Verarbeitet eine Zeile; gibt einen neuen Prozentwert zurück oder null. */
-  verarbeite(zeile: string): { prozent?: number; meldung?: { code: number; text: string } } {
-    const p = progressAusPrgv(zeile)
-    if (p >= 0) {
-      if (p === this.prozent) return {}
-      // Es geht wieder voran — was vorher klemmte, klemmt nicht mehr.
-      this.haengtBei = ''
-      this.haengtWiederholungen = 0
-      this.prozent = p
-      return { prozent: p }
-    }
-    const meldung = parseMsg(zeile)
-    if (meldung === null) return {}
-    this.letzteMeldung = meldung.text
-    if (meldung.text.includes(LESEFEHLER_MARKE)) this.lesefehler = true
-    // Dieselbe Stelle wieder und wieder heißt: physischer Defekt.
-    const stelle = offsetAusMeldung(meldung.text)
-    if (stelle.length > 0) {
-      if (stelle === this.haengtBei) {
-        this.haengtWiederholungen += 1
-      } else {
-        this.haengtBei = stelle
-        this.haengtWiederholungen = 1
-      }
-    }
-    if (meldung.code in KRITISCHE_CODES) {
-      this.kritischeMeldungen.push(`${KRITISCHE_CODES[meldung.code]} (${meldung.text.trim()})`)
-    } else if (KRITISCHE_TEXTE.some((muster) => meldung.text.includes(muster))) {
-      this.kritischeMeldungen.push(meldung.text)
-    }
-    return { meldung }
-  }
-
-  fehlerText(returncode: number | null, dateienDa: boolean): string {
-    return (
-      `makemkvcon endete mit Code ${returncode ?? '?'}` +
-      (this.kritischeMeldungen.length > 0 ? ` — Ursache: ${this.kritischeMeldungen.join('; ')}` : '') +
-      (this.letzteMeldung.length > 0 ? ` — letzte Meldung: ${this.letzteMeldung}` : '') +
-      (dateienDa ? '' : ' — keine MKV-Datei entstanden')
-    )
-  }
-}
-
-/** Buffer-Ströme in Zeilen zerlegen — binär, die letzte halbe Zeile bleibt
- *  liegen, bis ihr Rest kommt. Je Zeile wird einzeln dekodiert (textVon). */
-export class ZeilenLeser {
-  private rest: Buffer = Buffer.alloc(0)
-
-  hinzu(stueck: Buffer): string[] {
-    this.rest = this.rest.length === 0 ? stueck : Buffer.concat([this.rest, stueck])
-    const zeilen: string[] = []
-    for (;;) {
-      const umbruch = this.rest.indexOf(0x0a)
-      if (umbruch < 0) break
-      let ende = umbruch
-      if (ende > 0 && this.rest[ende - 1] === 0x0d) ende -= 1
-      zeilen.push(textVon(this.rest.subarray(0, ende)))
-      this.rest = this.rest.subarray(umbruch + 1)
-    }
-    return zeilen
-  }
-
-  schluss(): string[] {
-    if (this.rest.length === 0) return []
-    const letzte = textVon(this.rest)
-    this.rest = Buffer.alloc(0)
-    return letzte.trim().length > 0 ? [letzte] : []
-  }
-}
-
-export interface DiscInfo {
-  titel: TitelInfo[]
-  streams: Map<number, TitelStreams>
-  sprachen: { audio: SprachEintrag[]; untertitel: SprachEintrag[] }
-}
-
-/** EIN Info-Lauf liefert Titel UND Sprachen — er dauert je Disc 20–120 s,
- *  zweimal holen wäre eine Minute Wartezeit für nichts (ripping.py). */
-export function titelInfoLesen(
-  programm: string,
-  geraetepfad: string,
-  timeoutMs = 300_000,
-): Promise<DiscInfo> {
-  return new Promise((fertig, scheitert) => {
-    const kind = spawn(programm, buildInfoArgs(geraetepfad), {
-      windowsHide: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-    const stuecke: Buffer[] = []
-    kind.stdout.on('data', (stueck: Buffer) => stuecke.push(stueck))
-    kind.stderr.on('data', (stueck: Buffer) => stuecke.push(stueck))
-    const zeiger = setTimeout(() => {
-      kind.kill()
-      scheitert(new Error(`makemkvcon info: keine Antwort nach ${Math.round(timeoutMs / 1000)} s`))
-    }, timeoutMs)
-    kind.on('error', (fehler) => {
-      clearTimeout(zeiger)
-      scheitert(fehler)
-    })
-    kind.on('close', () => {
-      clearTimeout(zeiger)
-      const ausgabe = textVon(Buffer.concat(stuecke))
-      const titel = parseTitelInfo(ausgabe)
-      const streams = parseStreamInfo(ausgabe)
-      fertig({ titel, streams, sprachen: sprachenZusammenfassen(streams) })
-    })
-  })
-}
-
-export type RipErgebnis =
-  | { status: 'success'; dateien: string[]; lesefehler: boolean }
-  | { status: 'cancelled' }
-  | { status: 'error'; fehler: string; lesefehler: boolean }
-
-export interface RipLaufOptionen {
-  programm: string
-  geraetepfad: string
-  zielOrdner: string
-  /** 'all' oder eine Titel-Nummer als Text. */
-  titel: string
-  aufFortschritt?: (prozent: number) => void
-  aufMeldung?: (code: number, text: string) => void
-  /** Der Lauf klemmt an einer festen Stelle (oder klemmt nicht mehr) —
-   *  das ist ein Disc-Defekt, kein Fortschrittsproblem. */
-  aufHaengt?: (klemmt: { offset: string; wiederholungen: number } | null) => void
-  abbruch?: AbortSignal
-}
-
-/** Rippt verlustfrei. Löst NIE mit einer Ausnahme auf — das Ergebnis trägt
- *  den Fehler als Wert (der Aufrufer meldet ihn weiter, R4). */
-export function rippen(optionen: RipLaufOptionen): Promise<RipErgebnis> {
-  return new Promise((fertig) => {
-    mkdirSync(optionen.zielOrdner, { recursive: true })
-
-    const kind = spawn(
-      optionen.programm,
-      buildRipArgs(optionen.geraetepfad, optionen.zielOrdner, optionen.titel),
-      { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] },
-    )
-
-    const auswertung = new RipAuswertung()
-    const leser = new ZeilenLeser()
-    let abgebrochen = false
-
-    const abbrechen = (): void => {
-      abgebrochen = true
-      kind.kill()
-    }
-    optionen.abbruch?.addEventListener('abort', abbrechen, { once: true })
-
-    // Ob es klemmt, wird gemeldet, sobald es sich ÄNDERT — nicht bei jeder
-    // Zeile, sonst rauscht dieselbe Nachricht hundertfach durchs Fenster.
-    let klemmteVorher = false
-    const zeile = (z: string): void => {
-      const ergebnis = auswertung.verarbeite(z)
-      if (ergebnis.prozent !== undefined) optionen.aufFortschritt?.(ergebnis.prozent)
-      if (ergebnis.meldung !== undefined) {
-        optionen.aufMeldung?.(ergebnis.meldung.code, ergebnis.meldung.text)
-      }
-      const klemmt = auswertung.haengt()
-      if (klemmt !== klemmteVorher || (klemmt && auswertung.haengtWiederholungen % 10 === 0)) {
-        klemmteVorher = klemmt
-        optionen.aufHaengt?.(
-          klemmt ? { offset: auswertung.haengtBei, wiederholungen: auswertung.haengtWiederholungen } : null,
-        )
-      }
-    }
-    kind.stdout.on('data', (stueck: Buffer) => leser.hinzu(stueck).forEach(zeile))
-    kind.stderr.on('data', (stueck: Buffer) => leser.hinzu(stueck).forEach(zeile))
-
-    kind.on('error', (fehler) => {
-      optionen.abbruch?.removeEventListener('abort', abbrechen)
-      fertig({ status: 'error', fehler: String(fehler), lesefehler: false })
-    })
-
-    kind.on('close', (code) => {
-      optionen.abbruch?.removeEventListener('abort', abbrechen)
-      leser.schluss().forEach(zeile)
-      if (abgebrochen) {
-        fertig({ status: 'cancelled' })
-        return
-      }
-      let dateien: string[] = []
-      try {
-        dateien = readdirSync(optionen.zielOrdner)
-          .filter((name) => name.endsWith('.mkv'))
-          .sort()
-          .map((name) => join(optionen.zielOrdner, name))
-      } catch (fehler) {
-        fertig({ status: 'error', fehler: `Zielordner nicht lesbar: ${String(fehler)}`, lesefehler: auswertung.lesefehler })
-        return
-      }
-      if (code === 0 && dateien.length > 0) {
-        fertig({ status: 'success', dateien, lesefehler: auswertung.lesefehler })
-        return
-      }
-      fertig({
-        status: 'error',
-        fehler: auswertung.fehlerText(code, dateien.length > 0),
-        lesefehler: auswertung.lesefehler,
-      })
-    })
-  })
-}
+// makemkvcon ansprechen — Kommandobau und Lauf (KONZEPT § 6.2).
+// Die Auswertung der Ausgabe steckt in RipAuswertung (pur, testbar);
+// hier bleiben nur spawn, Zeilenzerlegung und Aufräumen.
+//
+// Was aus dem Docker-Zweig zwingend mitkommt (ripping.py, gemessen):
+//  - Robot-Mode: -r --noscan --progress=-same (--noscan: der Geräte-Scan
+//    hing bzw. stürzte — Befund 23.07.)
+//  - BINÄR lesen, je Zeile dekodieren (textVon): makemkvcon mischt
+//    Kodierungen; „Das Öffnen" war die Folge von text=True.
+//  - Lesefehler heißen Lesefehler: MakeMKV kann 1 von 2 Titeln sichern und
+//    sich trotzdem mit 0 beenden (30.08.2026, Spartacus Disc 2).
+//  - Kritische MSG-NUMMERN einsammeln — die letzte Zeile ist fast immer
+//    nur „Failed to open disc", die Ursache steht Zeilen davor.
+import { spawn } from 'node:child_process'
+import { mkdirSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import {
+  KRITISCHE_CODES,
+  KRITISCHE_TEXTE,
+  LESEFEHLER_MARKE,
+  offsetAusMeldung,
+  parseMsg,
+  parseStreamInfo,
+  parseTitelInfo,
+  progressAusPrgv,
+  quelle,
+  sprachenZusammenfassen,
+  textVon,
+  type SprachEintrag,
+  type TitelInfo,
+  type TitelStreams,
+} from './parser'
+
+export function buildInfoArgs(geraetepfad: string): string[] {
+  return ['-r', '--noscan', 'info', quelle(geraetepfad)]
+}
+
+export function buildRipArgs(geraetepfad: string, zielOrdner: string, titel: string): string[] {
+  return ['-r', '--noscan', '--progress=-same', 'mkv', quelle(geraetepfad), titel, zielOrdner]
+}
+
+/** Ab so vielen Meldungen an DERSELBEN Stelle gilt der Lauf als hängend.
+ *  Jeder Leseversuch wirft zwei Zeilen (SCSI-Fehler + Betriebssystemfehler),
+ *  zwölf sind also rund sechs Versuche — genug, um einen kurzen Aussetzer
+ *  von einem echten Defekt zu unterscheiden. */
+export const HAENGT_AB = 12
+
+/** Auswertung der Rip-Ausgabe — pur, eine Zeile nach der anderen. */
+export class RipAuswertung {
+  prozent = -1
+  letzteMeldung = ''
+  lesefehler = false
+  kritischeMeldungen: string[] = []
+  /** Die Stelle, an der es zuletzt klemmte — '' wenn keine. */
+  haengtBei = ''
+  /** Wie oft dieselbe Stelle schon gemeldet wurde. */
+  haengtWiederholungen = 0
+
+  /** Klemmt der Lauf an einer festen Stelle? Dann ist das ein Defekt auf
+   *  der Disc und kein Fortschrittsproblem — Weiterversuchen hilft nicht. */
+  haengt(): boolean {
+    return this.haengtBei.length > 0 && this.haengtWiederholungen >= HAENGT_AB
+  }
+
+  /** Verarbeitet eine Zeile; gibt einen neuen Prozentwert zurück oder null. */
+  verarbeite(zeile: string): { prozent?: number; meldung?: { code: number; text: string } } {
+    const p = progressAusPrgv(zeile)
+    if (p >= 0) {
+      if (p === this.prozent) return {}
+      // Es geht wieder voran — was vorher klemmte, klemmt nicht mehr.
+      this.haengtBei = ''
+      this.haengtWiederholungen = 0
+      this.prozent = p
+      return { prozent: p }
+    }
+    const meldung = parseMsg(zeile)
+    if (meldung === null) return {}
+    this.letzteMeldung = meldung.text
+    if (meldung.text.includes(LESEFEHLER_MARKE)) this.lesefehler = true
+    // Dieselbe Stelle wieder und wieder heißt: physischer Defekt.
+    const stelle = offsetAusMeldung(meldung.text)
+    if (stelle.length > 0) {
+      if (stelle === this.haengtBei) {
+        this.haengtWiederholungen += 1
+      } else {
+        this.haengtBei = stelle
+        this.haengtWiederholungen = 1
+      }
+    }
+    if (meldung.code in KRITISCHE_CODES) {
+      this.kritischeMeldungen.push(`${KRITISCHE_CODES[meldung.code]} (${meldung.text.trim()})`)
+    } else if (KRITISCHE_TEXTE.some((muster) => meldung.text.includes(muster))) {
+      this.kritischeMeldungen.push(meldung.text)
+    }
+    return { meldung }
+  }
+
+  fehlerText(returncode: number | null, dateienDa: boolean): string {
+    return (
+      `makemkvcon endete mit Code ${returncode ?? '?'}` +
+      (this.kritischeMeldungen.length > 0 ? ` — Ursache: ${this.kritischeMeldungen.join('; ')}` : '') +
+      (this.letzteMeldung.length > 0 ? ` — letzte Meldung: ${this.letzteMeldung}` : '') +
+      (dateienDa ? '' : ' — keine MKV-Datei entstanden')
+    )
+  }
+}
+
+/** Buffer-Ströme in Zeilen zerlegen — binär, die letzte halbe Zeile bleibt
+ *  liegen, bis ihr Rest kommt. Je Zeile wird einzeln dekodiert (textVon). */
+export class ZeilenLeser {
+  private rest: Buffer = Buffer.alloc(0)
+
+  hinzu(stueck: Buffer): string[] {
+    this.rest = this.rest.length === 0 ? stueck : Buffer.concat([this.rest, stueck])
+    const zeilen: string[] = []
+    for (;;) {
+      const umbruch = this.rest.indexOf(0x0a)
+      if (umbruch < 0) break
+      let ende = umbruch
+      if (ende > 0 && this.rest[ende - 1] === 0x0d) ende -= 1
+      zeilen.push(textVon(this.rest.subarray(0, ende)))
+      this.rest = this.rest.subarray(umbruch + 1)
+    }
+    return zeilen
+  }
+
+  schluss(): string[] {
+    if (this.rest.length === 0) return []
+    const letzte = textVon(this.rest)
+    this.rest = Buffer.alloc(0)
+    return letzte.trim().length > 0 ? [letzte] : []
+  }
+}
+
+export interface DiscInfo {
+  /** Was MakeMKV als URSACHE genannt hat, wenn nichts herauskam — die
+   *  kritischen MSG-Nummern im Klartext. Leer, wenn alles glatt lief.
+   *
+   *  Warum (01.09.2026 am Laufwerk gemessen): Beim Zustand 5042 („Das
+   *  Programm konnte keine verwendbaren optischen Laufwerke finden")
+   *  antwortet der Info-Lauf nach 0,7 s mit TCOUNT:0. Ohne diese Zeile
+   *  stünde im Fenster nur „keine Titel gefunden" — und niemand wüsste,
+   *  dass das Laufwerk gemeint ist und nicht die Disc. */
+  ursachen: string[]
+  titel: TitelInfo[]
+  streams: Map<number, TitelStreams>
+  sprachen: { audio: SprachEintrag[]; untertitel: SprachEintrag[] }
+}
+
+/** EIN Info-Lauf liefert Titel UND Sprachen — er dauert je Disc 20–120 s,
+ *  zweimal holen wäre eine Minute Wartezeit für nichts (ripping.py). */
+export function titelInfoLesen(
+  programm: string,
+  geraetepfad: string,
+  timeoutMs = 300_000,
+): Promise<DiscInfo> {
+  return new Promise((fertig, scheitert) => {
+    const kind = spawn(programm, buildInfoArgs(geraetepfad), {
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    const stuecke: Buffer[] = []
+    kind.stdout.on('data', (stueck: Buffer) => stuecke.push(stueck))
+    kind.stderr.on('data', (stueck: Buffer) => stuecke.push(stueck))
+    const zeiger = setTimeout(() => {
+      kind.kill()
+      scheitert(new Error(`makemkvcon info: keine Antwort nach ${Math.round(timeoutMs / 1000)} s`))
+    }, timeoutMs)
+    kind.on('error', (fehler) => {
+      clearTimeout(zeiger)
+      scheitert(fehler)
+    })
+    kind.on('close', () => {
+      clearTimeout(zeiger)
+      const ausgabe = textVon(Buffer.concat(stuecke))
+      const titel = parseTitelInfo(ausgabe)
+      const streams = parseStreamInfo(ausgabe)
+      // Die Ursache steht in den MSG-Nummern, nicht in der letzten Zeile.
+      const ursachen: string[] = []
+      for (const zeile of ausgabe.split('\n')) {
+        const meldung = parseMsg(zeile)
+        if (meldung === null) continue
+        if (meldung.code in KRITISCHE_CODES && !ursachen.includes(KRITISCHE_CODES[meldung.code])) {
+          ursachen.push(KRITISCHE_CODES[meldung.code])
+        }
+      }
+      fertig({ ursachen, titel, streams, sprachen: sprachenZusammenfassen(streams) })
+    })
+  })
+}
+
+export type RipErgebnis =
+  | { status: 'success'; dateien: string[]; lesefehler: boolean }
+  | { status: 'cancelled' }
+  | { status: 'error'; fehler: string; lesefehler: boolean }
+
+export interface RipLaufOptionen {
+  programm: string
+  geraetepfad: string
+  zielOrdner: string
+  /** 'all' oder eine Titel-Nummer als Text. */
+  titel: string
+  aufFortschritt?: (prozent: number) => void
+  aufMeldung?: (code: number, text: string) => void
+  /** Der Lauf klemmt an einer festen Stelle (oder klemmt nicht mehr) —
+   *  das ist ein Disc-Defekt, kein Fortschrittsproblem. */
+  aufHaengt?: (klemmt: { offset: string; wiederholungen: number } | null) => void
+  abbruch?: AbortSignal
+}
+
+/** Rippt verlustfrei. Löst NIE mit einer Ausnahme auf — das Ergebnis trägt
+ *  den Fehler als Wert (der Aufrufer meldet ihn weiter, R4). */
+export function rippen(optionen: RipLaufOptionen): Promise<RipErgebnis> {
+  return new Promise((fertig) => {
+    mkdirSync(optionen.zielOrdner, { recursive: true })
+
+    const kind = spawn(
+      optionen.programm,
+      buildRipArgs(optionen.geraetepfad, optionen.zielOrdner, optionen.titel),
+      { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] },
+    )
+
+    const auswertung = new RipAuswertung()
+    const leser = new ZeilenLeser()
+    let abgebrochen = false
+
+    const abbrechen = (): void => {
+      abgebrochen = true
+      kind.kill()
+    }
+    optionen.abbruch?.addEventListener('abort', abbrechen, { once: true })
+
+    // Ob es klemmt, wird gemeldet, sobald es sich ÄNDERT — nicht bei jeder
+    // Zeile, sonst rauscht dieselbe Nachricht hundertfach durchs Fenster.
+    let klemmteVorher = false
+    const zeile = (z: string): void => {
+      const ergebnis = auswertung.verarbeite(z)
+      if (ergebnis.prozent !== undefined) optionen.aufFortschritt?.(ergebnis.prozent)
+      if (ergebnis.meldung !== undefined) {
+        optionen.aufMeldung?.(ergebnis.meldung.code, ergebnis.meldung.text)
+      }
+      const klemmt = auswertung.haengt()
+      if (klemmt !== klemmteVorher || (klemmt && auswertung.haengtWiederholungen % 10 === 0)) {
+        klemmteVorher = klemmt
+        optionen.aufHaengt?.(
+          klemmt ? { offset: auswertung.haengtBei, wiederholungen: auswertung.haengtWiederholungen } : null,
+        )
+      }
+    }
+    kind.stdout.on('data', (stueck: Buffer) => leser.hinzu(stueck).forEach(zeile))
+    kind.stderr.on('data', (stueck: Buffer) => leser.hinzu(stueck).forEach(zeile))
+
+    kind.on('error', (fehler) => {
+      optionen.abbruch?.removeEventListener('abort', abbrechen)
+      fertig({ status: 'error', fehler: String(fehler), lesefehler: false })
+    })
+
+    kind.on('close', (code) => {
+      optionen.abbruch?.removeEventListener('abort', abbrechen)
+      leser.schluss().forEach(zeile)
+      if (abgebrochen) {
+        fertig({ status: 'cancelled' })
+        return
+      }
+      let dateien: string[] = []
+      try {
+        dateien = readdirSync(optionen.zielOrdner)
+          .filter((name) => name.endsWith('.mkv'))
+          .sort()
+          .map((name) => join(optionen.zielOrdner, name))
+      } catch (fehler) {
+        fertig({ status: 'error', fehler: `Zielordner nicht lesbar: ${String(fehler)}`, lesefehler: auswertung.lesefehler })
+        return
+      }
+      if (code === 0 && dateien.length > 0) {
+        fertig({ status: 'success', dateien, lesefehler: auswertung.lesefehler })
+        return
+      }
+      fertig({
+        status: 'error',
+        fehler: auswertung.fehlerText(code, dateien.length > 0),
+        lesefehler: auswertung.lesefehler,
+      })
+    })
+  })
+}