feat(v5): Etappe W-2 — Rippen: Parser, makemkvcon-Lauf, Werkzeug-Katalog

rip/parser.ts: die reine Textverarbeitung mit allen bezahlten Fallen aus
dem Docker-Zweig — quelle() (dev:G: statt dev:\.\G:, der 404-Verwandte),
textVon() (UTF-8 streng, sonst cp1252 — nie wieder 'Öffnen'), parseMsg
(Regex statt split — Meldungen mit Komma), PRGV (-1 vs. echtes 0 %),
TINFO/SINFO (Sprache aus Attr 3/4, NICHT 28/29), laengsterTitel mit
Play-All-Schutz, episodenTitel, KRITISCHE_CODES (sprachfeste NUMMERN).

rip/makemkv.ts: Kommandobau + Lauf — ZeilenLeser (binaer, halbe Zeilen,
je Zeile dekodiert), RipAuswertung (pur), rippen() mit AbortSignal,
Lesefehler-Flag AUCH bei Rueckgabewert 0. werkzeuge/katalog.ts: die
Suchreihenfolge samt %VAR%-Gross/Klein-Falle und Registry-Rueckfall.
ablauf/rippen.ts: ein Rip je Laufwerk, Status-Push, 'erst nachsehen,
dann rippen' (unbekannt heisst trotzdem rippen). Fenster: Rippen-Knopf,
Fortschrittsbalken, Abbrechen; Auswurf waehrend des Rips abgelehnt.

Gemessen am echten System (30.08.2026): Katalog findet
makemkvcon64 (Program Files x86), HandBrakeCLI und flac (beide im
rc11-Werkzeugordner LOCALAPPDATA\Rippy\tools). NEUER BEFUND: Nach dem
abgebrochenen rc11-Rip vom Mittag sieht MakeMKV GAR KEIN Laufwerk mehr
(MSG 5042, leere DRV-Liste, mit und ohne --noscan), waehrend die
Storage-IOCTLs sauber antworten — MakeMKV spricht SCSI direkt. 5042 ist
jetzt ein KRITISCHER_CODE mit Klartext-Abhilfe. Der volle Rip-Beweis
(messung.rip.test.ts liegt bereit) braucht deshalb erst eine Hand am
Geraet: Disc neu einlegen oder USB ab-/anstecken.

96 Tests gruen, Smoke gruen.

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

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

@@ -0,0 +1,225 @@
+// 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,
+  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]
+}
+
+/** Auswertung der Rip-Ausgabe — pur, eine Zeile nach der anderen. */
+export class RipAuswertung {
+  prozent = -1
+  letzteMeldung = ''
+  lesefehler = false
+  kritischeMeldungen: string[] = []
+
+  /** 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 {}
+      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
+    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
+  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 })
+
+    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)
+      }
+    }
+    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,
+      })
+    })
+  })
+}