Die Apps können jetzt beides: Jellyfin oder Flaro

`FlaroServerKit` steht neben `JellyfinKit`, nicht darin — genau auf dem
Steckplatz, den Plex geräumt hat. Dass `MediaBackend` zwei Server zugleich
trägt, war schon einmal bewiesen; die Naht hat gehalten, und keine einzige
Ansicht musste dafür neu geschrieben werden.

`ServerKind` ist zurück. Es wurde beim Entfernen von Plex gestrichen, weil
ein Aufzählungstyp mit einem Fall ein umständliches Bool ist. Jetzt gibt es
wieder zwei, und es ist wieder eine Unterscheidung — einer zur Zeit, nicht
beide nebeneinander.

**Flaro steht oben auf dem Anmeldebildschirm.** Nicht aus Eitelkeit: dort
bringt ein Download alle Tonspuren mit und der Fortschritt wird ab der
ersten Sekunde gemerkt. Wer Jellyfin benutzt, sucht gezielt danach — wer neu
anfängt, soll nicht in der schwächeren Hälfte landen, weil ihr Knopf
auffälliger war. Am Fernseher steht bei beiden der sechsstellige Code voran.

---

**Der Zugang geht als Cookie, nicht in der Adresse.** Jellyfin hängt sein
Token an jede Bildadresse, weil eine Bildansicht keine Kopfzeilen schickt;
es steht damit in jedem Zugriffsprotokoll und jedem weitergegebenen Link.
Flaro tut das nicht, und deshalb legt der Client sein Token selbst im
gemeinsamen Keksspeicher ab — auch beim Wiederaufnehmen aus dem
Schlüsselbund, wo gar keine Anmeldung stattfindet und der Server es nie
setzen könnte.

`URLSession` schickt es von allein mit; **AVFoundation nicht**. Der
Systemplayer bekommt die Kekse jetzt ausdrücklich. Serverneutral: wo keine
liegen, ist die Liste leer.

**`BackendCapability.allTracksDownload`** statt einer Spurwahl, die ins
Leere führt. Die Frage „welche Tonspur?" gibt es nur, weil Jellyfins
Transcoder eine je Sitzung abbildet. Bei Flaro führen beide Antworten zum
selben Ergebnis — also wird nicht gefragt, und das Umpacken mit einer
einzigen Spur entfällt gleich mit.

**Die Adressraterei wandert nach `MediaKit`.** Sechzig Zeilen sorgfältig
begründeter Reihenfolge — IP-Adressen sprechen selten HTTPS, Domänennamen
fast immer — unterscheiden sich zwischen beiden Servern nur im Standardport.
Zweimal hingeschrieben wäre die eine Fassung beim nächsten Sonderfall
nachgezogen worden und die andere nicht. Jellyfins Prüfungen laufen
unverändert gegen die verschobene Fassung; das ist der Beweis.

**Nebenbei zwei Altlasten:** `player.jellyfinPending` war unerreichbar — der
Player zeigt diese Meldung nur, wenn gar kein Server da ist, dann aber nie
die mit Jellyfin. Und `signIn.jellyfin.userName` hiess „Benutzername"; der
Schlüssel heisst jetzt so neutral wie der Text.

---

**Der Fehler, den erst der Simulator zeigte:** „Stelle wird
wiederhergestellt", 0:00, für immer.

Muss der Server umpacken, antwortet er auf den Download mit 202 und fängt
an. AVPlayer bekommt darauf kein Video, sondern eine leere Antwort — und
wartet, unbegrenzt, ohne Fehler. Die Weboberfläche fragt in einer Schleife
nach; `preparePlayback` tat es nicht. Jetzt wartet es, mit Obergrenze und
einer Begründung, wenn sie reisst. Mit Prüfung, die zwei Runden erzwingt.

413 Tests grün. Im Simulator gegen den echten Server nachgewiesen: Adresse
eintippen, Server gefunden, angemeldet, Mediathek mit Plakaten, Neustart
ohne erneute Anmeldung — und eine MKV abgespielt, die der Server dafür erst
umpacken musste. Danach stand auf dem Server: Matrix, 2,0 s von 2,0 s,
gesehen, ein Durchlauf.

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

Packages/FlaroKit/Sources/FlaroServerKit/FlaroContracts.swift

@@ -0,0 +1,175 @@
+import Foundation
+
+/// Was Flaro über die Leitung schickt.
+///
+/// Ein Spiegel der `Contracts.cs` auf der Serverseite, und nur das: hier wird
+/// nichts gerechnet und nichts gedeutet. Die Übersetzung in die neutralen
+/// Typen steht in `FlaroBackend+Mapping`.
+///
+/// **Die Felder heissen wie dort.** Keine `CodingKeys`, keine Umbenennung:
+/// ASP.NET Core schreibt `camelCase`, Swift liest `camelCase`, und jede
+/// Abweichung wäre eine Stelle, an der beim nächsten Serverfeld jemand
+/// nachziehen müsste.
+enum Wire {
+    struct Page<T: Decodable & Sendable>: Decodable, Sendable {
+        let items: [T]
+        let total: Int
+    }
+
+    struct SystemInfo: Decodable, Sendable {
+        let version: String?
+        let serverName: String?
+        let needsSetup: Bool
+        let attributions: [Attribution]?
+    }
+
+    struct Attribution: Decodable, Sendable {
+        let text: String
+        let logoUrl: String
+        let url: String
+    }
+
+    struct LoginResponse: Decodable, Sendable {
+        let token: String
+        let user: User
+    }
+
+    struct User: Decodable, Sendable {
+        let id: String
+        let userName: String
+        let isAdministrator: Bool
+    }
+
+    struct Library: Decodable, Sendable {
+        let id: String
+        let name: String
+        let kind: String
+        let path: String
+    }
+
+    struct Stream: Decodable, Sendable {
+        let index: Int
+        let kind: String
+        let codec: String?
+        let language: String?
+        let title: String?
+        let isDefault: Bool
+        let isForced: Bool
+        let channels: Int?
+        let width: Int?
+        let height: Int?
+    }
+
+    struct File: Decodable, Sendable {
+        let id: String
+        let fileName: String
+        let sizeBytes: Int64
+        let container: String?
+        let durationSeconds: Double?
+        let streams: [Stream]
+    }
+
+    struct ItemState: Decodable, Sendable {
+        let positionSeconds: Double
+        let runtimeSeconds: Double?
+        let watched: Bool
+        let playCount: Int
+        let favourite: Bool
+        let rating: Int?
+        let dismissed: Bool
+        let lastPlayedAt: Date?
+    }
+
+    struct Movie: Decodable, Sendable {
+        let id: String
+        let title: String
+        let year: Int?
+        let overview: String?
+        let posterImage: String?
+        let backdropImage: String?
+        let files: [File]
+        let state: ItemState?
+    }
+
+    struct Series: Decodable, Sendable {
+        let id: String
+        let title: String
+        let year: Int?
+        let overview: String?
+        let posterImage: String?
+        let backdropImage: String?
+        let episodeCount: Int
+        let seasons: [Int]
+        let unwatchedCount: Int
+    }
+
+    struct Episode: Decodable, Sendable {
+        let id: String
+        let season: Int
+        let episode: Int
+        let title: String?
+        let overview: String?
+        let stillImage: String?
+        let files: [File]
+        let state: ItemState?
+    }
+
+    /// Eine Kachel aus „Weiterschauen" oder „Nächste Folge".
+    struct Started: Decodable, Sendable {
+        let id: String
+        let kind: String
+        let title: String
+        let subTitle: String?
+        let season: Int?
+        let episode: Int?
+        let year: Int?
+        let posterImage: String?
+        let backdropImage: String?
+        let state: ItemState
+    }
+
+    struct CodeResponse: Decodable, Sendable {
+        let code: String
+        let handle: String
+        let expiresAt: Date
+    }
+
+    /// `state` ist „pending", „approved" oder „expired".
+    struct CodeState: Decodable, Sendable {
+        let state: String
+        let login: LoginResponse?
+    }
+
+    struct CodeRequest: Encodable, Sendable {
+        let deviceName: String
+        let deviceId: String
+    }
+
+    struct Delivery: Decodable, Sendable {
+        let method: String
+        let reasons: [String]
+        let audioToEncode: [Int]
+        let subtitlesDropped: [Int]
+        let packageState: String
+        let progress: Double
+        let error: String?
+    }
+
+    // --- Was hinausgeht --------------------------------------------------
+
+    struct LoginRequest: Encodable, Sendable {
+        let userName: String
+        let password: String
+        let deviceName: String
+        let deviceId: String
+    }
+
+    struct ProgressRequest: Encodable, Sendable {
+        let positionSeconds: Double
+        let runtimeSeconds: Double?
+    }
+
+    struct WatchedRequest: Encodable, Sendable { let watched: Bool }
+    struct FavouriteRequest: Encodable, Sendable { let favourite: Bool }
+    struct RatingRequest: Encodable, Sendable { let rating: Int? }
+}