Beim Umpacken wird nach der Tonspur gefragt, nicht geraten

Mein Fehler, und ein vermeidbarer. Beim Umpacken legt der Server genau eine
Tonspur in die Datei, und welche, hat bisher allein die Abwägung entschieden
— bei einer Aufnahme mit Audiodeskription die falsche. Nach dem Herunterladen
gibt es nichts mehr zu korrigieren; drei Gigabyte Datenvolumen waren weg.

Wo eine Spur verlorengeht, wird jetzt gefragt. Nur dort: bei einer Datei, die
der Systemplayer ohnehin öffnet, kommt alles mit, und eine Frage ohne Folgen
ist nur ein Klick mehr.

**Der Vorschlag kommt aus dem, was schon bekannt ist.** Die gemerkte Sprache
der Serie zuerst, dann die Serieneinstellung, dann die allgemeine — dieselbe
Abwägung wie beim Abspielen (`AudioTrackChooser`), über denselben Weg. Sie
ist jetzt Vorschlag statt Entscheidung und steht als „· empfohlen" dabei.

Beim Stapel aus der Mehrfachauswahl wird einmal gefragt, nicht je Folge: die
Folgen einer Staffel sind gleich aufgebaut, und zwanzigmal dieselbe Frage
wäre keine Wahl, sondern eine Prüfung der Geduld.

**Was am Server gemessen wurde, und warum es nicht besser geht:**

- `static=true` liefert die Datei unverändert — alle Spuren, aber Matroska;
  die Magie am Dateianfang ist `1a45dfa3`, auch wenn im Pfad `.mp4` steht.
- `stream.mp4` bildet genau eine Tonspur ab.
- Die HLS-Liste des Servers führt **eine** Variante und **keine**
  `EXT-X-MEDIA`-Tonspuren.

Mehrere Tonspuren offline gibt dieser Server auf keinem seiner Wege her. Das
liegt nicht an MP4 — das kann mehrere — und nicht an AVFoundation, sondern am
Transcoder, der je Sitzung eine Spur abbildet.

iOS und tvOS bauen.

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

Flixy/Views/Detail/SeriesDetailView.swift

@@ -28,6 +28,8 @@ struct SeriesDetailView: View {
     @State private var selection: Set<String> = []
     @State private var sample: MediaItem?
     @State private var showsQualityChoice = false
+    /// Stufe steht, Tonspur fehlt — gefragt wird einmal für den ganzen Stapel.
+    @State private var pendingQuality: DownloadQuality?
     @State private var isWorking = false
     @State private var summary: String?
 
@@ -78,14 +80,41 @@ struct SeriesDetailView: View {
                 backend: session.backend
             )
             ForEach(choice.available) { quality in
-                Button(choice.label(for: quality)) {
-                    Task { await loadSelected(quality: quality) }
-                }
+                Button(choice.label(for: quality)) { chose(quality) }
             }
             Button("action.cancel", role: .cancel) {}
         } message: {
             Text("downloads.quality.hint")
         }
+        .confirmationDialog(
+            Text("downloads.audio.title"),
+            isPresented: Binding(
+                get: { pendingQuality != nil },
+                set: { if !$0 { pendingQuality = nil } }
+            ),
+            titleVisibility: .visible
+        ) {
+            // **Einmal für den Stapel.** Die Folgen einer Staffel sind gleich
+            // aufgebaut; zwanzigmal dieselbe Frage wäre keine Wahl, sondern
+            // eine Prüfung der Geduld.
+            if let muster = sample?.preferredVersion?.files.first {
+                let empfohlen = sample.map { downloadService.preferredAudioStream(in: muster, of: $0) }
+                ForEach(muster.audioStreams) { stream in
+                    Button(
+                        stream == empfohlen
+                            ? String(localized: "downloads.audio.recommended \(stream.name)")
+                            : stream.name
+                    ) {
+                        if let pendingQuality {
+                            Task { await loadSelected(quality: pendingQuality, audioStreamIndex: stream.index) }
+                        }
+                    }
+                }
+            }
+            Button("action.cancel", role: .cancel) {}
+        } message: {
+            Text("downloads.audio.hint")
+        }
         .alert(
             Text("downloads.batch.title"),
             isPresented: Binding(get: { summary != nil }, set: { if !$0 { summary = nil } })
@@ -292,14 +321,27 @@ struct SeriesDetailView: View {
         showsQualityChoice = true
     }
 
-    private func loadSelected(quality: DownloadQuality) async {
+    private var downloadService: DownloadService {
+        DownloadService(backend: session.backend, coordinator: downloads, languages: languages)
+    }
+
+    /// Nach der Stufe: fragen, wenn beim Umpacken eine Tonspur verlorenginge.
+    private func chose(_ quality: DownloadQuality) {
+        if let muster = sample, downloadService.needsAudioChoice(for: muster, quality: quality) {
+            pendingQuality = quality
+        } else {
+            Task { await loadSelected(quality: quality, audioStreamIndex: nil) }
+        }
+    }
+
+    private func loadSelected(quality: DownloadQuality, audioStreamIndex: Int?) async {
+        pendingQuality = nil
         isWorking = true
         defer { isWorking = false }
 
-        let service = DownloadService(
-            backend: session.backend, coordinator: downloads, languages: languages
+        let result = await downloadService.download(
+            selectedEpisodes, quality: quality, audioStreamIndex: audioStreamIndex
         )
-        let result = await service.download(selectedEpisodes, quality: quality)
 
         var zeilen = [String(localized: "downloads.batch.queued \(result.accepted)")]
         if let erster = result.refused.first {