Flixy heißt ab hier Halo

Reine Umbenennung, kein Verhalten geändert — bewusst als eigener Commit,
damit „umbenannt" und „umgebaut" im Nachhinein auseinanderzuhalten sind.

712 mal `Flixy`, 778 mal `flixy`, 7 mal `FLIXY` in 169 Dateien, dazu 25
Pfade. Ziele: `Halo`, `HaloTV`, `HaloTopShelf`, `HaloUITests`, `HaloKit` mit
`HaloDesign`, `HaloDownloads`, `HaloPlayback` und `HaloProbe`. `MediaKit`,
`JellyfinKit` und `DownloadWidget` tragen den Namen nicht und bleiben.

`docs/superpowers/specs/` ist ausgenommen. Datierte Entwurfsdokumente sind
ein Protokoll getroffener Entscheidungen; sie nachträglich umzuschreiben
hiesse, die Vergangenheit zu glätten.

**Die Bundle-ID wandert mit** — ausdrücklich so gewollt, mit bekanntem Preis:
`com.scarriffleservices.halo` ist für iOS eine *andere* App. Die installierte
Fassung bleibt daneben stehen, mit Downloads und Anmeldung in ihrem Container;
Halo startet leer. Einmal neu anmelden, heruntergeladene Folgen einmal neu
laden. Dasselbe gilt für die App-Gruppe, die sich TV-App und Top Shelf teilen.

**Eine Folge davon, die beim Entscheiden noch nicht auf dem Tisch lag:** der
Aufräumschritt aus dem vorigen Commit kommt an die alten Plex-Token nicht mehr
heran. Der Schlüsselbund grenzt nach Team und Bundle-Kennung ab — was unter
`…flixy` liegt, ist für `…halo` unerreichbar. Erledigt wird es trotzdem, nur
anders: **die alte App löschen.** iOS räumt deren Schlüsselbund-Einträge beim
Deinstallieren mit ab. Der Code bleibt stehen, weil er für jeden Stand vor
dieser Umbenennung richtig ist und im Jahr einen Startvergleich kostet.

Die Projektdatei ist aus `project.yml` neu erzeugt, der alte Ordner gelöscht
statt umbenannt — sie steht ohnehin nicht im Repo.

Das Verzeichnis des Repos selbst heißt weiter `Flixy`; das umzubenennen ist
ein Handgriff ausserhalb des Projekts.

368 Tests grün. iOS und tvOS bauen.

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

HaloTV/Views/Home/TVHomeView.swift

@@ -0,0 +1,148 @@
+import SwiftUI
+import HaloDesign
+import MediaKit
+
+/// Die Startseite auf dem Fernseher.
+///
+/// **Dasselbe Modell wie am Telefon.** `HomeFeed` lädt, ordnet und lost den
+/// Aufmacher aus; hier steht nur, wie das aussieht. Der Unterschied ist die
+/// Bedienart, nicht der Inhalt.
+struct TVHomeView: View {
+    /// Wohin ein Link aus dem Regal führen soll.
+    ///
+    /// **Als Bindung von aussen**, nicht als eigener Zustand: das Regal
+    /// erreicht die Wurzel, der Navigationsstapel liegt hier. Einen zweiten
+    /// Stapel eine Ebene höher anzulegen, nur um ein Ziel durchzureichen,
+    /// hiesse zwei Stapel gleich zu halten.
+    @Binding var deepLinkTarget: MediaRoute?
+
+    @Environment(HaloSession.self) private var session
+    @Environment(HomeLayoutSettings.self) private var layout
+    @Environment(PlaybackCoordinator.self) private var playback
+    @Environment(QuickPlay.self) private var quickPlay
+
+    @State private var feed = HomeFeed()
+    @State private var pfad = NavigationPath()
+    /// Welcher Titel gerade oben gross steht.
+    ///
+    /// **Der Fokus bestimmt ihn, nicht eine Uhr.** Am Telefon wechselt der
+    /// Aufmacher alle sieben Sekunden von selbst — dort blättert man ihn auch
+    /// mit dem Daumen. Vor einem Fernseher wäre ein Bild, das sich von allein
+    /// austauscht, während man es ansieht, eine Zumutung: man verliert den
+    /// Titel, den man gerade lesen wollte.
+    @State private var aufmacher: MediaItem?
+
+    var body: some View {
+        NavigationStack(path: $pfad) {
+            inhalt
+                .navigationDestination(for: MediaRoute.self) { route in
+                    TVDetailView(route: route)
+                }
+        }
+        .task(id: session.serverName) { await feed.load(from: session.backend) }
+        .onChange(of: deepLinkTarget) { _, neu in
+            guard let neu else { return }
+            pfad.append(neu)
+            deepLinkTarget = nil
+        }
+    }
+
+    @ViewBuilder
+    private var inhalt: some View {
+        switch feed.state {
+        case .loading:
+            ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
+
+        case .failed(let meldung):
+            VStack(spacing: HaloSpacing.regular) {
+                Text(meldung).font(.haloBody).foregroundStyle(.white)
+                Button("action.retry") {
+                    Task { await feed.load(from: session.backend) }
+                }
+            }
+
+        case .loaded:
+            let reihen = feed.rows(for: layout)
+            if reihen.isEmpty && session.libraries.isEmpty {
+                Text("home.empty.title").font(.haloRowHeader).foregroundStyle(.white)
+            } else {
+                seite(reihen: reihen)
+            }
+        }
+    }
+
+    private func seite(reihen: [MediaRowGroup]) -> some View {
+        ScrollView {
+            LazyVStack(alignment: .leading, spacing: HaloSpacing.section) {
+                if let gezeigt = aufmacher ?? feed.heroItems(for: layout).first {
+                    TVHeroSection(
+                        item: gezeigt,
+                        onPlay: { spiele(gezeigt) },
+                        onDetails: { zeige(gezeigt) }
+                    )
+                    .frame(height: 720)
+                }
+
+                ForEach(reihen) { reihe in
+                    // **Der Fokus setzt den Aufmacher.** Wer durch „Zuletzt
+                    // hinzugefügt" wandert, sieht oben, was er gerade
+                    // anschaut — ohne irgendwo hindrücken zu müssen.
+                    TVMediaRow(
+                        row: reihe,
+                        onSelect: { spiele($0) },
+                        onFocus: { aufmacher = $0 }
+                    )
+                }
+            }
+            .padding(.bottom, HaloSpacing.screenMargin)
+        }
+        .scrollIndicators(.never)
+        // **Bildfüllend, und der Rand steckt in `screenMargin`.** Der
+        // Aufmacher muss bis an die Bildschirmkante reichen; ein Bild, das
+        // achtzig Punkte davor aufhört, sieht nach Fehler aus.
+        .ignoresSafeArea()
+        // Als Überlagerung und nicht als letzte Zeile der Liste: dorthin
+        // müsste man erst an allen Reihen vorbeiscrollen, und wer nachsieht,
+        // warum das Regal leer ist, soll es sofort sehen.
+        .overlay(alignment: .bottom) { regalStatus }
+    }
+
+    /// Was das Regal über der App zuletzt bekommen hat.
+    ///
+    /// **Nur im Entwicklerbau.** Es gehört nicht in die fertige App — aber
+    /// solange das Regal leer bleibt, sieht man von aussen nicht, woran es
+    /// liegt: fehlende App-Gruppe, fehlende Datei und ein System, das nicht
+    /// fragt, sehen alle gleich aus. Diese Zeile unterscheidet sie.
+    @ViewBuilder
+    private var regalStatus: some View {
+        #if DEBUG
+        VStack(alignment: .leading, spacing: HaloSpacing.tight) {
+            Text("topShelf.title")
+                .font(.haloCaption)
+                .foregroundStyle(Color.haloTextMuted)
+            Text(TopShelfWriter.status)
+                .font(.haloCaption)
+                .foregroundStyle(Color.haloTextSecondary)
+        }
+        .padding(.horizontal, HaloSpacing.screenMargin)
+        .padding(.bottom, HaloSpacing.regular)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(Color.black.opacity(0.6))
+        #endif
+    }
+
+    // MARK: - Was ein Druck auslöst
+
+    /// **Über QuickPlay, nicht unmittelbar.** Steht in der Reihe eine Serie —
+    /// und Jellyfins „Zuletzt hinzugefügt" liefert neue Folgen als ihre Serie
+    /// —, schickte der direkte Weg deren eigene Kennung an den Player, und der
+    /// scheiterte mit „keine abspielbare Datei". Eine Serie hat keine
+    /// Fassungen.
+    private func spiele(_ item: MediaItem) {
+        quickPlay.start(item, backend: session.backend, coordinator: playback)
+    }
+
+    private func zeige(_ item: MediaItem) {
+        pfad.append(MediaRoute(ratingKey: item.id, title: item.title))
+    }
+}