Live-TV: die Lineup-Kennung ist eine Adresse, keine Kennung

Der zweite Abzug zeigt den Pfad, der 404 ergab:

    /tv.plex.providers.epg.cloud:2/lineups/
      lineup://tv.plex.providers.epg.cloud/6228f7f2364e02fa5ec8e51c
      #Swisscom%20Blue%20TV%20%28Deutschschweiz%29%20%28521%20channels%29
      /channels

`Lineup.id` heißt zwar Kennung, ist aber eine vollständige Adresse: mit
Schema, Doppelschrägstrich, Prozentzeichen und einem Anhang hinter der
Raute. Die habe ich roh in den Pfad gespleißt.

Gebraucht wird der nackte Teil in der Mitte —
`6228f7f2364e02fa5ec8e51c`. `PlexLineup.pathIdentifier` packt ihn aus,
vier Tests halten die Fälle fest.

Da die Pfadform zwischen Serverfassungen schwankt und dieser Teil der
API keine Beschreibung hat, werden drei Adressen der Reihe nach
probiert. Welche gegriffen hat, steht in der Diagnose — damit aus dem
Durchprobieren beim nächsten Mal Wissen wird. Der Strukturabzug deckt
jetzt alle drei ab.

173 Tests.

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

Packages/FlixyKit/Sources/PlexKit/Endpoints/PlexServer+LiveTV.swift

@@ -48,41 +48,68 @@ extension PlexServer {
     public func channels(inDVR dvr: PlexDVR) async -> ChannelLookup {
         let enabled = dvr.enabledChannelKeys
 
-        // `??` mit einem asynchronen Aufruf rechts geht nicht — die
-        // Kurzschlussauswertung ist nicht nebenläufigkeitsfähig.
         var identifier = dvr.epgIdentifier
         if identifier == nil {
             identifier = await electronicProgramGuideIdentifier()
         }
-
-        guard let epgIdentifier = identifier, let lineup = dvr.lineups.first else {
+        guard let epgIdentifier = identifier else {
             return ChannelLookup(channels: [], source: .noLineup)
         }
 
-        do {
-            let container = try await client.send(
-                PlexRequest(
-                    path: "/\(epgIdentifier)/lineups/\(lineup.id)/channels",
-                    timeout: .seconds(30)
-                ),
-                as: PlexMediaContainer<PlexChannel>.self
-            )
+        var lastFailure: String?
+        for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
+            do {
+                let container = try await client.send(
+                    PlexRequest(path: path, timeout: .seconds(30)),
+                    as: PlexMediaContainer<PlexChannel>.self
+                )
+                guard !container.content.isEmpty else { continue }
 
-            // Ohne Zuordnung alles zeigen: besser die vollständige Liste als
-            // gar keine, wenn der Empfänger keine Auswahl meldet.
-            let channels = enabled.isEmpty
-                ? container.content
-                : container.content.filter { $0.matches(anyOf: enabled) }
+                // Ohne Zuordnung alles zeigen: besser die vollständige Liste
+                // als gar keine, wenn der Empfänger keine Auswahl meldet.
+                let channels = enabled.isEmpty
+                    ? container.content
+                    : container.content.filter { $0.matches(anyOf: enabled) }
 
-            return ChannelLookup(
-                channels: channels,
-                source: channels.isEmpty
-                    ? .lineupWithoutMatches(available: container.content.count, enabled: enabled.count)
-                    : .lineup(available: container.content.count)
-            )
-        } catch {
-            return ChannelLookup(channels: [], source: .failed(String(describing: error)))
+                if channels.isEmpty {
+                    return ChannelLookup(
+                        channels: [],
+                        source: .lineupWithoutMatches(
+                            available: container.content.count,
+                            enabled: enabled.count
+                        )
+                    )
+                }
+                return ChannelLookup(
+                    channels: channels,
+                    source: .lineup(available: container.content.count, path: path)
+                )
+            } catch {
+                lastFailure = "\(path): \(error)"
+            }
         }
+
+        return ChannelLookup(channels: [], source: .failed(lastFailure ?? "kein Weg lieferte Sender"))
+    }
+
+    /// Die Adressen, unter denen die Senderliste stehen könnte.
+    ///
+    /// Mehrere, weil dieser Teil der Plex-API keine Beschreibung hat und sich
+    /// die Form zwischen Serverfassungen unterscheidet. Sie werden der Reihe
+    /// nach probiert; welche gegriffen hat, steht in der Diagnose — damit aus
+    /// dem Durchprobieren beim nächsten Mal Wissen wird.
+    ///
+    /// Entscheidend ist `pathIdentifier`: die Kennung der Senderliste kommt
+    /// als vollständige Adresse mit Schema und Anhang. Roh eingesetzt ergibt
+    /// jeder dieser Pfade 404.
+    static func channelPaths(dvr: PlexDVR, epgIdentifier: String) -> [String] {
+        var paths: [String] = []
+        if let lineup = dvr.lineups.first {
+            paths.append("/\(epgIdentifier)/lineups/\(lineup.pathIdentifier)/channels")
+        }
+        paths.append("/\(epgIdentifier)/channels")
+        paths.append("/livetv/dvrs/\(dvr.key)/channels")
+        return paths
     }
 
     /// Die Kennung des Programmanbieters.
@@ -182,13 +209,13 @@ extension PlexServer {
             PlexRequest(path: "/livetv/dvrs", timeout: .seconds(10)),
             as: PlexMediaContainer<PlexDVR>.self
         ).content.first,
-           let epgIdentifier = dvr.epgIdentifier,
-           let lineup = dvr.lineups.first {
-            let path = "/\(epgIdentifier)/lineups/\(lineup.id)/channels"
-            report.append("\n=== \(path) ===")
-            report.append(await structure(ofPath: path))
+           let epgIdentifier = dvr.epgIdentifier {
+            for path in Self.channelPaths(dvr: dvr, epgIdentifier: epgIdentifier) {
+                report.append("\n=== \(path) ===")
+                report.append(await structure(ofPath: path))
+            }
         } else {
-            report.append("\n=== Senderliste ===\nKeine Kennung oder Senderliste am Empfänger")
+            report.append("\n=== Senderliste ===\nKeine Kennung des Programmanbieters am Empfänger")
         }
 
         return report.joined(separator: "\n")
@@ -246,8 +273,8 @@ extension PlexServer {
 /// Woher die Senderliste kam.
 public struct ChannelLookup: Sendable {
     public enum Source: Sendable, Equatable {
-        /// Aus der Senderliste des Programmanbieters.
-        case lineup(available: Int)
+        /// Aus der Senderliste des Programmanbieters, über diesen Pfad.
+        case lineup(available: Int, path: String)
         /// Die Senderliste kam an, aber keiner passte zur Zuordnung.
         case lineupWithoutMatches(available: Int, enabled: Int)
         /// Am Empfänger hängt keine Senderliste oder kein Programmanbieter.
@@ -266,8 +293,8 @@ public struct ChannelLookup: Sendable {
     /// Kurzbeschreibung für die Diagnose.
     public var description: String {
         switch source {
-        case .lineup(let available):
-            "\(channels.count) von \(available) Sendern eingeschaltet"
+        case .lineup(let available, let path):
+            "\(channels.count) von \(available) Sendern · \(path)"
         case .lineupWithoutMatches(let available, let enabled):
             "Senderliste hat \(available) Sender, \(enabled) sind zugeordnet — keiner passte zusammen"
         case .noLineup: