MediaKit: die Grundschicht, auf der Plex und Jellyfin dasselbe meinen

Erster Schritt zu Jellyfin, und er besteht vor allem aus Wegnehmen.

`PlaybackDecider` nahm bisher Plex-Modelle entgegen und las daraus sechs
Felder. Das band die Entscheidung an einen bestimmten Server, obwohl an
der Frage „kann iOS das öffnen?" nichts serverspezifisch ist. Jetzt nimmt
er ein `MediaProfile` — Container, Codecs, Bitrate, ob die Datei
untersucht ist.

Wie ernst die Kopplung war, zeigte der Player selbst: für die
Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen — eine
Media mit Kennung 0, ein Part mit dem Dateinamen als Schlüssel,
zusammengesetzte Spurlisten —, nur damit die Signatur passte. Für eine
Datei, die längst auf dem Gerät lag und mit Plex nichts mehr zu tun
hatte. Dieser Hack ist weg.

Neu ist das Target `MediaKit`: Typen und Rechnungen, die für jeden Server
gelten, ohne eine einzige Abhängigkeit. Darin `MediaProfile` und die
`Duration`-Brücke, die bisher in PlexKit stand — „weil es die unterste
Schicht ist". Das stimmte, solange es nur einen Server gab.

Damit kennen Wiedergabe und Downloads Plex nicht mehr. Zwei der
Abhängigkeiten waren ohnehin tot; die dritte trug nur diese Brücke.

Die wichtigste Testtabelle des Projekts ist mitgewandert und dabei
kürzer geworden: dort steht jetzt, worauf es ankommt, statt vollständiger
Modelle mit Kennungen und Dateipfaden, von denen niemand etwas las.

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

Flixy/Views/Detail/TechnicalDetails.swift

@@ -15,7 +15,7 @@ struct TechnicalDetails: View {
     @Binding var isExpanded: Bool
 
     private var decision: PlaybackDecision {
-        PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+        PlaybackDecider().decide(profile: media.profile(part: part), policy: .directPlayOnly)
     }
 
     var body: some View {

Flixy/Views/Player/PlayerModel.swift

@@ -1,5 +1,6 @@
 import AVKit
 import Foundation
+import MediaKit
 import Observation
 import FlixyDownloads
 import FlixyPlayback
@@ -184,7 +185,7 @@ final class PlayerModel {
         currentMedia = media
         currentPart = part
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(profile: media.profile(part: part), policy: policy)
         self.decision = decision
 
         guard let source = await source(for: decision, item: item, media: media, part: part, server: server) else {
@@ -232,7 +233,10 @@ final class PlayerModel {
         phase = .preparing
 
         let newPolicy = newQuality.policy(basedOn: policy)
-        let newDecision = PlaybackDecider().decide(media: media, part: part, policy: newPolicy)
+        let newDecision = PlaybackDecider().decide(
+            profile: media.profile(part: part),
+            policy: newPolicy
+        )
         decision = newDecision
 
         guard let source = await source(
@@ -299,19 +303,19 @@ final class PlayerModel {
         let offline = downloads.offlineMedia(forRatingKey: request.ratingKey)
 
         let decision = PlaybackDecider().decide(
-            media: PlexMedia(
+            // Früher standen hier **erfundene** Plex-Modelle: eine Media mit
-                id: 0,
+            // Kennung 0, ein Part mit dem Dateinamen als Schlüssel und
+            // zusammengebaute Spuren — alles nur, damit die Signatur passte,
+            // für eine Datei, die längst auf dem Gerät lag. Genau daran war zu
+            // sehen, dass die Entscheidung nie etwas mit Plex zu tun hatte.
+            profile: MediaProfile(
                 container: offline?.container,
                 videoCodec: offline?.videoCodec,
                 audioCodec: offline?.audioCodec,
-                videoResolution: offline?.videoResolution,
+                bitrate: offline?.bitrate,
-                bitrate: offline?.bitrate
+                // Was heruntergeladen wurde, ist untersucht. Ohne diese Zusage
-            ),
+                // ginge jede Offline-Datei vorsichtshalber an VLC.
-            part: PlexPart(
+                hasKnownStreams: offline?.videoCodec != nil
-                id: 0,
-                key: url.lastPathComponent,
-                container: offline?.container,
-                streams: offline.map(localStreams) ?? []
             ),
             // Lokal gibt es nichts umzurechnen und keine Bandbreitengrenze.
             policy: .directPlayOnly
@@ -325,19 +329,6 @@ final class PlayerModel {
         )
     }
 
-    /// Baut künstliche Spuren aus dem Offline-Abzug.
-    ///
-    /// Der `PlaybackDecider` erwartet Spuren, um überhaupt zu entscheiden —
-    /// eine leere Liste hieße „noch nicht analysiert" und schickte jede
-    /// heruntergeladene Datei vorsichtshalber an VLC.
-    private func localStreams(from offline: OfflineMedia) -> [PlexStream] {
-        var streams = [PlexStream(id: 1, streamType: 1, codec: offline.videoCodec)]
-        if let audioCodec = offline.audioCodec {
-            streams.append(PlexStream(id: 2, streamType: 2, codec: audioCodec, selected: true))
-        }
-        return streams
-    }
-
     private func load(_ source: PlaybackSource, decision: PlaybackDecision) async {
         diagnostics.record(decision: decision, source: source.url)
 

Packages/FlixyKit/Package.swift

@@ -11,6 +11,7 @@ let package = Package(
     // Die App selbst ist iOS-only; das legt project.yml fest.
     platforms: [.iOS(.v26), .macOS(.v26)],
     products: [
+        .library(name: "MediaKit", targets: ["MediaKit"]),
         .library(name: "PlexKit", targets: ["PlexKit"]),
         .library(name: "FlixyDesign", targets: ["FlixyDesign"]),
         .library(name: "FlixyPlayback", targets: ["FlixyPlayback"]),
@@ -19,7 +20,14 @@ let package = Package(
     targets: [
         // Sprechen mit dem Server: Anmeldung, Endpunkte, Modelle. Kein SwiftUI,
         // damit die gesamte Protokoll-Schicht ohne Oberfläche testbar bleibt.
-        .target(name: "PlexKit"),
+        // Die neutrale Grundschicht: Typen und Rechnungen, die für jeden
+        // Server gelten. Hängt von nichts ab — genau das macht sie zur
+        // Grundlage, auf der Plex, Jellyfin und später das Web-Projekt
+        // dasselbe meinen.
+        .target(name: "MediaKit"),
+        .testTarget(name: "MediaKitTests", dependencies: ["MediaKit"]),
+
+        .target(name: "PlexKit", dependencies: ["MediaKit"]),
 
         // Ein Werkzeug für die Fragen, die reines HTTP sind — ohne Oberfläche,
         // ohne Gerät, ohne Upload. Eine Runde dauert damit Sekunden statt
@@ -44,12 +52,11 @@ let package = Package(
         // DirectPlay/Transcode. VLCKit steckt bewusst NICHT hier drin, sondern
         // in FlixyPlaybackVLC — sonst zöge jeder Testlauf ein 920 MB großes
         // xcframework hinter sich her.
-        .target(name: "FlixyPlayback", dependencies: ["PlexKit"]),
+        .target(name: "FlixyPlayback", dependencies: ["MediaKit"]),
         .testTarget(name: "FlixyPlaybackTests", dependencies: ["FlixyPlayback"]),
 
         // Warteschlange, Hintergrundübertragung, Offline-Bestand.
-        .target(name: "FlixyDownloads", dependencies: ["PlexKit"],
+        .target(name: "FlixyDownloads", dependencies: ["MediaKit"], resources: [.process("Localizable.xcstrings")]),
-                resources: [.process("Localizable.xcstrings")]),
         .testTarget(name: "FlixyDownloadsTests", dependencies: ["FlixyDownloads"]),
     ]
 )

Packages/FlixyKit/Sources/FlixyDownloads/Engine/DownloadCoordinator.swift

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 import Observation
 import SwiftData
 

Packages/FlixyKit/Sources/FlixyDownloads/Engine/DownloadRules.swift

@@ -1,5 +1,5 @@
 import Foundation
-import PlexKit
+import MediaKit
 
 /// Die Regeln, nach denen Downloads von selbst entstehen und verschwinden.
 ///

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift

@@ -1,5 +1,5 @@
 import Foundation
-import PlexKit
+import MediaKit
 
 /// Entscheidet, wie ein Titel abgespielt wird.
 ///
@@ -15,8 +15,7 @@ public struct PlaybackDecider: Sendable {
     }
 
     public func decide(
-        media: PlexMedia,
+        profile: MediaProfile,
-        part: PlexPart,
         policy: PlaybackPolicy
     ) -> PlaybackDecision {
         var rationale: [PlaybackDecision.Rationale] = []
@@ -36,7 +35,7 @@ public struct PlaybackDecider: Sendable {
         // 1. Reicht die Leitung? Das kommt zuerst, weil es unabhängig vom
         //    Format ist: eine 80-Mbit-Datei über Mobilfunk ist auch dann keine
         //    gute Idee, wenn AVPlayer sie problemlos öffnen könnte.
-        if let limit = policy.maximumBitrate, let bitrate = media.bitrate, bitrate > limit {
+        if let limit = policy.maximumBitrate, let bitrate = profile.bitrate, bitrate > limit {
             rationale.append(.bitrateExceedsLimit(mediaBitrate: bitrate, limit: limit))
             if policy.allowsTranscoding {
                 return PlaybackDecision(method: .transcode(maximumBitrate: limit), rationale: rationale)
@@ -48,8 +47,8 @@ public struct PlaybackDecider: Sendable {
         }
 
         // 2. Kennt der Server die Datei überhaupt?
-        let container = normalized(part.container ?? media.container)
+        let container = normalized(profile.container)
-        guard !part.streams.isEmpty, let videoCodec = normalized(media.videoCodec ?? part.videoStream?.codec) else {
+        guard profile.hasKnownStreams, let videoCodec = normalized(profile.videoCodec) else {
             rationale.append(.streamsUnknown)
             return fallback(policy: policy, rationale: rationale)
         }
@@ -62,10 +61,9 @@ public struct PlaybackDecider: Sendable {
         if !capabilities.videoCodecs.contains(videoCodec) {
             blockers.append(.videoCodecUnsupported(videoCodec))
         }
-        // Geprüft wird die Spur, die tatsächlich klingen soll. Eine Datei mit
+        // Geprüft wird die Spur, die tatsächlich klingen soll — welche das
-        // deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
+        // ist, hat der Aufrufer beim Bauen des Profils entschieden.
-        // solange Deutsch gewählt ist.
+        if let audioCodec = normalized(profile.audioCodec),
-        if let audioCodec = normalized(part.selectedAudioStream?.codec ?? media.audioCodec),
            !capabilities.audioCodecs.contains(audioCodec) {
             blockers.append(.audioCodecUnsupported(audioCodec))
         }

Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift

@@ -1,6 +1,6 @@
 import AVFoundation
 import Foundation
-import PlexKit
+import MediaKit
 
 /// Wiedergabe über den Systemplayer.
 ///

Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift

@@ -1,12 +1,11 @@
 import Foundation
-import PlexKit
 
 /// Eine wählbare Ton- oder Untertitelspur.
 ///
-/// Bewusst getrennt von `PlexStream`: VLCKit und AVPlayer nummerieren ihre
+/// Bewusst getrennt von den Spuren, die der Server meldet: VLCKit und
-/// Spuren selbst, und die Nummern stimmen nicht mit denen von Plex überein.
+/// AVPlayer nummerieren selbst, und ihre Nummern stimmen mit denen des Servers
-/// `engineIdentifier` hält deshalb fest, wie der jeweilige Engine die Spur
+/// nicht überein. `engineIdentifier` hält fest, wie die laufende Engine die
-/// nennt, während `plexStreamID` für den Server gedacht ist.
+/// Spur nennt, `serverStreamID`, wie der Server sie nennt.
 public struct MediaTrack: Sendable, Equatable, Identifiable {
     public enum Kind: Sendable, Equatable { case audio, subtitle }
 
@@ -14,7 +13,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
     public let kind: Kind
     public let displayName: String
     public let languageCode: String?
-    public let plexStreamID: Int?
+    public let serverStreamID: Int?
     /// Die Nummer, unter der der laufende Engine die Spur führt.
     public let engineIdentifier: Int?
     public let isForced: Bool
@@ -24,7 +23,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
         kind: Kind,
         displayName: String,
         languageCode: String? = nil,
-        plexStreamID: Int? = nil,
+        serverStreamID: Int? = nil,
         engineIdentifier: Int? = nil,
         isForced: Bool = false
     ) {
@@ -32,40 +31,9 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
         self.kind = kind
         self.displayName = displayName
         self.languageCode = languageCode
-        self.plexStreamID = plexStreamID
+        self.serverStreamID = serverStreamID
         self.engineIdentifier = engineIdentifier
         self.isForced = isForced
     }
 }
 
-extension MediaTrack {
-    /// Baut eine Spur aus dem, was Plex gemeldet hat.
-    ///
-    /// `displayTitle` ist das, was Plex selbst in seinen Oberflächen zeigt
-    /// (etwa „Deutsch (AC3 5.1)"). Fehlt es, wird aus Sprache und Codec etwas
-    /// Brauchbares gebaut, statt „Spur 3" anzuzeigen.
-    public init?(stream: PlexStream) {
-        guard let kind = stream.kind else { return nil }
-        let trackKind: Kind
-        switch kind {
-        case .audio: trackKind = .audio
-        case .subtitle: trackKind = .subtitle
-        case .video: return nil
-        }
-
-        let name = stream.displayTitle
-            ?? stream.title
-            ?? [stream.language, stream.codec?.uppercased()]
-                .compactMap(\.self)
-                .joined(separator: " · ")
-
-        self.init(
-            id: "plex-\(stream.id)",
-            kind: trackKind,
-            displayName: name.isEmpty ? "—" : name,
-            languageCode: stream.languageCode,
-            plexStreamID: stream.id,
-            isForced: stream.isForced
-        )
-    }
-}

Packages/FlixyKit/Sources/MediaKit/Duration+Units.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+extension Duration {
+    /// Die Dauer als Gleitkommazahl in Sekunden.
+    ///
+    /// Foundation und AVFoundation rechnen in `TimeInterval`; `Duration` ist
+    /// der genauere Typ, den der übrige Code verwendet.
+    ///
+    /// Diese Brücke stand bis eben in `PlexKit` — „weil es die unterste
+    /// Schicht ist". Das stimmte, solange es nur einen Server gab. Sie hier
+    /// zu haben ist der Grund, warum Downloads und Wiedergabe jetzt ohne
+    /// jeden Serverbezug übersetzen.
+    public var seconds: Double {
+        Double(components.seconds) + Double(components.attoseconds) / 1e18
+    }
+
+    /// Die Dauer in ganzen Millisekunden.
+    ///
+    /// Die Einheit, in der sowohl Plex als auch Jellyfin Fortschritt melden —
+    /// Jellyfin allerdings in Ticks zu 100 Nanosekunden, was der jeweilige
+    /// Server-Adapter umrechnet.
+    public var milliseconds: Int {
+        Int(components.seconds * 1000 + components.attoseconds / 1_000_000_000_000_000)
+    }
+}

Packages/FlixyKit/Sources/MediaKit/MediaProfile.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+/// Was der `PlaybackDecider` über eine Datei wissen muss — und nicht mehr.
+///
+/// Vorher nahm er die Plex-Modelle entgegen und las daraus sechs Felder.
+/// Das band die Entscheidung an einen bestimmten Server, obwohl an ihr nichts
+/// serverspezifisch ist: ob iOS eine Datei öffnen kann, hängt an Container und
+/// Codecs, nicht daran, wer sie ausliefert.
+///
+/// Wie ernst die Kopplung war, zeigt der Player selbst: für die
+/// Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen, nur um
+/// diese Signatur zu bedienen — für eine Datei, die längst auf dem Gerät lag
+/// und mit Plex nichts mehr zu tun hatte.
+public struct MediaProfile: Sendable, Equatable {
+    /// Der Behälter, etwa `mkv` oder `mp4`.
+    public let container: String?
+    public let videoCodec: String?
+    /// Der Codec der Tonspur, die tatsächlich klingen soll.
+    ///
+    /// Nicht irgendeiner: eine Datei mit deutschem AAC und englischem DTS ist
+    /// für AVPlayer in Ordnung, solange Deutsch gewählt ist.
+    public let audioCodec: String?
+    /// Gesamtbitrate in Kilobit je Sekunde.
+    public let bitrate: Int?
+    /// Ob der Server die Datei überhaupt schon untersucht hat.
+    ///
+    /// Ohne bekannte Spuren lässt sich nichts entscheiden — dann ist der
+    /// Ersatzplayer die sichere Wahl.
+    public let hasKnownStreams: Bool
+
+    public init(
+        container: String? = nil,
+        videoCodec: String? = nil,
+        audioCodec: String? = nil,
+        bitrate: Int? = nil,
+        hasKnownStreams: Bool = true
+    ) {
+        self.container = container
+        self.videoCodec = videoCodec
+        self.audioCodec = audioCodec
+        self.bitrate = bitrate
+        self.hasKnownStreams = hasKnownStreams
+    }
+}

Packages/FlixyKit/Sources/PlexKit/Auth/PlexAuthenticator.swift

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 /// Führt die Anmeldung bei plex.tv durch.
 public actor PlexAuthenticator {

Packages/FlixyKit/Sources/PlexKit/Client/PlexTransport.swift

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 /// Der schmale Spalt, durch den PlexKit ans Netz kommt.
 ///
@@ -89,14 +90,3 @@ public struct PlexRequest: Sendable, Equatable {
         return request
     }
 }
-
-extension Duration {
-    /// Die Dauer als Gleitkommazahl in Sekunden.
-    ///
-    /// Foundation und AVFoundation rechnen in `TimeInterval`; `Duration` ist
-    /// der genauere Typ, den der übrige Code verwendet. Diese Brücke steht in
-    /// PlexKit, weil es die unterste Schicht ist — die darüber erben sie.
-    public var seconds: Double {
-        Double(components.seconds) + Double(components.attoseconds) / 1e18
-    }
-}

Packages/FlixyKit/Sources/PlexKit/Discovery/PlexConnectionSelector.swift

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 /// Sucht den besten erreichbaren Weg zu einem Server.
 ///

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

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 /// Was beim Live-TV herauskommen kann.
 public enum LiveTVAvailability: Sendable, Equatable {

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

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 extension PlexServer {
     // MARK: - Transcoding
@@ -235,13 +236,6 @@ public enum PlaybackReportState: String, Sendable {
     case buffering
 }
 
-extension Duration {
-    /// Die Dauer in ganzen Millisekunden — die Einheit, in der Plex rechnet.
-    public var milliseconds: Int {
-        Int(components.seconds * 1000 + components.attoseconds / 1_000_000_000_000_000)
-    }
-}
-
 extension PlexServer {
     /// Die nächste Folge nach der angegebenen.
     ///

Packages/FlixyKit/Sources/PlexKit/Models/PlexLiveTV.swift

@@ -1,4 +1,5 @@
 import Foundation
+import MediaKit
 
 /// Ein Fernsehempfänger am Server.
 ///

Packages/FlixyKit/Sources/PlexKit/Models/PlexMedia+Profile.swift

@@ -0,0 +1,23 @@
+import Foundation
+import MediaKit
+
+extension PlexMedia {
+    /// Was die Wiedergabe-Entscheidung über diese Fassung wissen muss.
+    ///
+    /// Die eine Stelle, an der Plex-Modelle in die neutrale Form übersetzt
+    /// werden. Vorher stand diese Auswahl im Entscheider selbst — und band
+    /// ihn damit an einen bestimmten Server, obwohl an der Frage „kann iOS
+    /// das öffnen?" nichts serverspezifisch ist.
+    public func profile(part: PlexPart) -> MediaProfile {
+        MediaProfile(
+            container: part.container ?? container,
+            videoCodec: videoCodec ?? part.videoStream?.codec,
+            // Die **gewählte** Tonspur, nicht irgendeine: eine Datei mit
+            // deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
+            // solange Deutsch klingt.
+            audioCodec: part.selectedAudioStream?.codec ?? audioCodec,
+            bitrate: bitrate,
+            hasKnownStreams: !part.streams.isEmpty
+        )
+    }
+}

Packages/FlixyKit/Tests/FlixyPlaybackTests/PlaybackDeciderTests.swift

@@ -1,5 +1,5 @@
 import Testing
-import PlexKit
+import MediaKit
 @testable import FlixyPlayback
 
 /// Die Tabelle, die festhält, welche Datei auf welchem Weg landet.
@@ -9,27 +9,24 @@ import PlexKit
 @Suite("Wiedergabe-Entscheidung")
 struct PlaybackDeciderTests {
 
-    /// Baut eine Datei mit den angegebenen Eigenschaften.
+    /// Beschreibt eine Datei mit den angegebenen Eigenschaften.
-    private func media(
+    ///
+    /// Seit die Entscheidung `MediaProfile` entgegennimmt, steht hier genau
+    /// das, worauf es ankommt. Vorher mussten vollständige Plex-Modelle
+    /// gebaut werden — mit Kennungen, Dateipfaden und Spurlisten, von denen
+    /// die Entscheidung nichts las.
+    private func profile(
         container: String,
         video: String,
         audio: String,
         bitrate: Int? = nil
-    ) -> (PlexMedia, PlexPart) {
+    ) -> MediaProfile {
-        let streams = [
+        MediaProfile(
-            PlexStream(id: 1, streamType: 1, codec: video),
-            PlexStream(id: 2, streamType: 2, codec: audio, selected: true),
-        ]
-        let part = PlexPart(id: 10, key: "/library/parts/10/1/file", container: container, streams: streams)
-        let media = PlexMedia(
-            id: 100,
             container: container,
             videoCodec: video,
             audioCodec: audio,
-            bitrate: bitrate,
+            bitrate: bitrate
-            parts: [part]
         )
-        return (media, part)
     }
 
     // MARK: - Was AVPlayer nativ kann
@@ -47,8 +44,10 @@ struct PlaybackDeciderTests {
         ]
     )
     func nativeFormatsUseAVPlayer(container: String, video: String, audio: String) {
-        let (media, part) = media(container: container, video: video, audio: audio)
+        let decision = PlaybackDecider().decide(
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+            profile: profile(container: container, video: video, audio: audio),
+            policy: .directPlayOnly
+        )
 
         #expect(decision.method == .directPlay(engine: .avPlayer))
         #expect(decision.rationale.contains(.nativelySupported))
@@ -58,8 +57,10 @@ struct PlaybackDeciderTests {
 
     @Test("Matroska geht an VLC, auch bei nativen Codecs")
     func matroskaFallsBackToVLC() {
-        let (media, part) = media(container: "mkv", video: "h264", audio: "aac")
+        let decision = PlaybackDecider().decide(
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+            profile: profile(container: "mkv", video: "h264", audio: "aac"),
+            policy: .directPlayOnly
+        )
 
         #expect(decision.method == .directPlay(engine: .vlc))
         #expect(decision.rationale.contains(.containerUnsupported("mkv")))
@@ -70,8 +71,10 @@ struct PlaybackDeciderTests {
         arguments: ["dts", "dca", "truehd", "vorbis", "opus"]
     )
     func unsupportedAudioFallsBackToVLC(codec: String) {
-        let (media, part) = media(container: "mp4", video: "h264", audio: codec)
+        let decision = PlaybackDecider().decide(
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+            profile: profile(container: "mp4", video: "h264", audio: codec),
+            policy: .directPlayOnly
+        )
 
         #expect(decision.method == .directPlay(engine: .vlc))
         #expect(decision.rationale.contains(.audioCodecUnsupported(codec)))
@@ -82,8 +85,10 @@ struct PlaybackDeciderTests {
         arguments: ["av1", "vp9", "mpeg2video", "vc1", "wmv3"]
     )
     func unsupportedVideoFallsBackToVLC(codec: String) {
-        let (media, part) = media(container: "mp4", video: codec, audio: "aac")
+        let decision = PlaybackDecider().decide(
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+            profile: profile(container: "mp4", video: codec, audio: "aac"),
+            policy: .directPlayOnly
+        )
 
         #expect(decision.method == .directPlay(engine: .vlc))
         #expect(decision.rationale.contains(.videoCodecUnsupported(codec)))
@@ -94,24 +99,24 @@ struct PlaybackDeciderTests {
         // Deutsches AAC ist ausgewählt, englisches DTS liegt daneben. Würde
         // der Decider nur die erste Tonspur ansehen, ginge diese Datei
         // unnötig an VLC — und damit ohne Bild-in-Bild.
-        let streams = [
+        // Die Datei hat englisches DTS und deutsches AAC; gewählt ist
-            PlexStream(id: 1, streamType: 1, codec: "h264"),
+        // Deutsch. Entschieden wird über die Spur, die klingen soll — wer sie
-            PlexStream(id: 2, streamType: 2, codec: "dts", language: "English"),
+        // aussucht, hat der Aufrufer beim Bauen des Profils entschieden.
-            PlexStream(id: 3, streamType: 2, codec: "aac", language: "Deutsch", selected: true),
+        let decision = PlaybackDecider().decide(
-        ]
+            profile: profile(container: "mp4", video: "h264", audio: "aac"),
-        let part = PlexPart(id: 10, key: "/p", container: "mp4", streams: streams)
+            policy: .directPlayOnly
-        let media = PlexMedia(id: 100, container: "mp4", videoCodec: "h264", audioCodec: "dts", parts: [part])
+        )
-
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
         #expect(decision.method == .directPlay(engine: .avPlayer))
     }
 
     @Test("Unanalysierte Dateien gehen an den toleranteren Engine")
     func unknownStreamsFallBackToVLC() {
-        let part = PlexPart(id: 10, key: "/p", container: "mp4", streams: [])
+        // Der Server hat die Datei noch nicht untersucht: keine Spuren, kein
-        let media = PlexMedia(id: 100, container: "mp4", parts: [part])
+        // bekannter Codec. Dann ist Raten die falsche Antwort.
-
+        let decision = PlaybackDecider().decide(
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
+            profile: MediaProfile(container: "mp4", hasKnownStreams: false),
+            policy: .directPlayOnly
+        )
         #expect(decision.method == .directPlay(engine: .vlc))
         #expect(decision.rationale.contains(.streamsUnknown))
     }
@@ -120,10 +125,12 @@ struct PlaybackDeciderTests {
 
     @Test("Über der Grenze wird umgerechnet, sobald das erlaubt ist")
     func exceedingBitrateTranscodesWhenAllowed() {
-        let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000)
         let policy = PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 8_000)
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(
+            profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000),
+            policy: policy
+        )
 
         #expect(decision.method == .transcode(maximumBitrate: 8_000))
         #expect(decision.rationale.contains(.bitrateExceedsLimit(mediaBitrate: 80_000, limit: 8_000)))
@@ -133,10 +140,12 @@ struct PlaybackDeciderTests {
     func exceedingBitrateStillPlaysInPhaseOne() {
         // Das ist die Lage in Phase 1. Abbrechen wäre falsch: im WLAN läuft
         // auch ein 80-Mbit-Remux, die Grenze ist nur eine Vorsichtsmaßnahme.
-        let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000)
         let policy = PlaybackPolicy(allowsTranscoding: false, maximumBitrate: 8_000)
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(
+            profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000),
+            policy: policy
+        )
 
         #expect(decision.isDirectPlay)
         #expect(decision.rationale.contains(.transcodingUnavailable))
@@ -144,19 +153,23 @@ struct PlaybackDeciderTests {
 
     @Test("Unter der Grenze bleibt alles beim Direktabspielen")
     func withinBitrateLimitPlaysDirectly() {
-        let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 4_000)
         let policy = PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 8_000)
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(
+            profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 4_000),
+            policy: policy
+        )
         #expect(decision.method == .directPlay(engine: .avPlayer))
     }
 
     @Test("Ohne VLC übernimmt der Transcoder")
     func withoutFallbackEngineTranscodingTakesOver() {
-        let (media, part) = media(container: "mkv", video: "h264", audio: "dts")
         let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(
+            profile: profile(container: "mkv", video: "h264", audio: "dts"),
+            policy: policy
+        )
         #expect(decision.method == .transcode(maximumBitrate: nil))
     }
 
@@ -164,10 +177,12 @@ struct PlaybackDeciderTests {
     func transcodingUsesAVPlayer() {
         // HLS ist genau die Kost, für die AVPlayer gebaut ist — inklusive
         // automatischem Bitratenwechsel. Deshalb darf VLC hier nicht greifen.
-        let (media, part) = media(container: "mkv", video: "h264", audio: "dts")
         let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
 
-        let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
+        let decision = PlaybackDecider().decide(
+            profile: profile(container: "mkv", video: "h264", audio: "dts"),
+            policy: policy
+        )
         #expect(decision.engine == .avPlayer)
     }
 
@@ -176,22 +191,8 @@ struct PlaybackDeciderTests {
         // Ohne das verpuffte die Wahl im Player: wer für eine 8-Mbit-Datei
         // „12 Mbit" wählt, bekam DirectPlay, weil die Datei ja unter der
         // Grenze liegt. Gemeint ist aber „rechne es mir auf diese Stufe um".
-        let media = PlexMedia(
-            id: 1,
-            container: "mp4",
-            videoCodec: "h264",
-            audioCodec: "aac",
-            bitrate: 8_000,
-            parts: []
-        )
-        let part = PlexPart(id: 1, key: "/library/parts/1", container: "mp4", streams: [
-            PlexStream(id: 1, streamType: 1, codec: "h264"),
-            PlexStream(id: 2, streamType: 2, codec: "aac", selected: true),
-        ])
-
         let decision = PlaybackDecider().decide(
-            media: media,
+            profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 8_000),
-            part: part,
             policy: PlaybackPolicy(
                 allowsTranscoding: true,
                 allowsFallbackEngine: false,
@@ -206,22 +207,8 @@ struct PlaybackDeciderTests {
 
     @Test("Ohne ausdrückliche Wahl bleibt es bei DirectPlay")
     func leavesAutomaticAlone() {
-        let media = PlexMedia(
-            id: 1,
-            container: "mp4",
-            videoCodec: "h264",
-            audioCodec: "aac",
-            bitrate: 8_000,
-            parts: []
-        )
-        let part = PlexPart(id: 1, key: "/library/parts/1", container: "mp4", streams: [
-            PlexStream(id: 1, streamType: 1, codec: "h264"),
-            PlexStream(id: 2, streamType: 2, codec: "aac", selected: true),
-        ])
-
         let decision = PlaybackDecider().decide(
-            media: media,
+            profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 8_000),
-            part: part,
             policy: PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 12_000)
         )
 

Packages/FlixyKit/Tests/MediaKitTests/DurationUnitsTests.swift

@@ -0,0 +1,28 @@
+import Foundation
+import Testing
+@testable import MediaKit
+
+/// Die Umrechnung von `Duration` in die Einheiten der Server.
+@Suite("Dauer in Zahlen")
+struct DurationUnitsTests {
+
+    @Test("Sekunden als Kommazahl")
+    func convertsToSeconds() {
+        #expect(Duration.seconds(90).seconds == 90.0)
+        #expect(Duration.milliseconds(1_500).seconds == 1.5)
+    }
+
+    @Test("Millisekunden ganzzahlig")
+    func convertsToMilliseconds() {
+        #expect(Duration.seconds(2).milliseconds == 2_000)
+        #expect(Duration.milliseconds(1_234).milliseconds == 1_234)
+    }
+
+    @Test("Bruchteile gehen nicht verloren")
+    func keepsFractions() {
+        // Der Fortschritt wird in Millisekunden gemeldet; würde hier
+        // abgeschnitten, verlöre man bei jedem Bericht bis zu einer Sekunde.
+        #expect(Duration.milliseconds(1).milliseconds == 1)
+        #expect(Duration.milliseconds(1).seconds == 0.001)
+    }
+}

project.yml

@@ -40,6 +40,11 @@ targets:
         type: file
     dependencies:
       - target: DownloadWidget
+      # Die neutrale Grundschicht. Ausdrücklich genannt, obwohl sie über
+      # PlexKit ohnehin im Baum hängt: die App soll sie direkt benutzen und
+      # nicht davon abhängen, dass ein bestimmter Server sie mitschleppt.
+      - package: FlixyKit
+        product: MediaKit
       - package: FlixyKit
         product: PlexKit
       - package: FlixyKit