Suchen am Fernseher — und die Leiste, die es dafür braucht

Das Backend konnte die Suche längst; es fehlte die Oberfläche.

**`.searchable`, keine eigene Tastatur.** tvOS macht daraus einen eigenen
Bildschirm mit Rastertastatur oben und Ergebnissen darunter — die
Bedienung, die jeder von Apples Apps kennt. Etwas Eigenes zu bauen hiesse,
sie nachzuahmen und dabei die Diktierfunktion zu verlieren.

**Herausgelöst statt kopiert**, wie schon bei Start und Mediathek:
`SearchFeed` trägt das Entprellen, die Mindestlänge und die zuletzt
gesuchten Begriffe. Drei Stellen, an denen es nicht offensichtlich ist —
und die dritte ist die wichtigste: geprüft wird auf `Task.isCancelled`
und nicht auf `CancellationError`, weil eine abgebrochene Netzanfrage als
Übertragungsfehler zurückkommt. Die naheliegende Prüfung lief ins Leere,
und jeder Tastendruck leerte kurz die Liste.

**Und erst jetzt eine Reiterleiste.** Bis hierher gab es genau einen
Bildschirm, und eine Leiste mit einem Eintrag wäre Zierrat gewesen. Der
Suchreiter trägt `role: .search`: tvOS stellt ihn dadurch ans Ende und
gibt ihm die Lupe, dieselbe Stelle wie überall sonst. Keinen dritten
Reiter für die Mediatheken — die stehen als Reihe auf der Startseite, und
ein Reiter verspräche einen eigenen Bereich, hinter dem dasselbe Raster
läge.

Der offene Reiter wird ausdrücklich gehalten, nicht dem System
überlassen: ein Link aus dem Regal über der App führt zur Startseite, und
stünde gerade die Suche offen, passierte sichtbar nichts.

Nebenbei bekommt die iOS-Suche einen Knopf zum Vergessen des Verlaufs.
Wischen zum Löschen gab es dort, am Fernseher gibt es das nicht — und
eine Liste, die sich nur auf einer Plattform leeren lässt, ist keine.

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

Flixy/Session/SearchFeed.swift

@@ -0,0 +1,80 @@
+import Foundation
+import MediaKit
+import Observation
+
+/// Die Suche als Modell: entprellen, fragen, merken.
+///
+/// **Herausgelöst wie `HomeFeed` und `LibraryFeed`**, und aus demselben
+/// Grund: der Fernseher stellt dieselben Fragen an denselben Server, nur ganz
+/// anders dargestellt. Kopiert wären dabei die drei Stellen, an denen es
+/// nicht offensichtlich ist — die Pause vor der Anfrage, die Mindestlänge und
+/// vor allem die Prüfung auf `Task.isCancelled`, ohne die jeder Tastendruck
+/// die Ergebnisse des vorigen löscht.
+@MainActor
+@Observable
+final class SearchFeed {
+    /// Wie viele zuletzt gesuchte Begriffe gemerkt werden.
+    private static let recentLimit = 8
+    private static let recentKey = "flixy.search.recent"
+
+    private(set) var hubs: [MediaRowGroup] = []
+    private(set) var isSearching = false
+    private(set) var recent: [String]
+
+    private let defaults: UserDefaults
+
+    init(defaults: UserDefaults = .standard) {
+        self.defaults = defaults
+        self.recent = defaults.stringArray(forKey: Self.recentKey) ?? []
+    }
+
+    /// Sucht — nach einer kurzen Pause.
+    ///
+    /// Die Pause ist der Kern: aufgerufen wird das bei **jedem** Tastendruck,
+    /// und ohne sie liefe für „Nachtzug" eine Anfrage je Buchstabe. Ein
+    /// neuer Tastendruck bricht die laufende Aufgabe ab, und der Abbruch
+    /// landet im `catch` der Pause — deshalb steht dort kein Fehler, sondern
+    /// ein `return`.
+    func search(_ text: String, from backend: (any MediaBackend)?) async {
+        let bereinigt = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let backend, bereinigt.count >= 2 else {
+            hubs = []
+            return
+        }
+
+        do {
+            try await Task.sleep(for: .milliseconds(300))
+        } catch {
+            return
+        }
+
+        isSearching = true
+        defer { isSearching = false }
+
+        do {
+            hubs = try await backend.search(bereinigt, limit: 30)
+            if !hubs.isEmpty { remember(bereinigt) }
+        } catch {
+            // **`Task.isCancelled` statt `catch is CancellationError`.** Eine
+            // abgebrochene Netzanfrage kommt als Übertragungsfehler zurück,
+            // nicht als Abbruch; die naheliegende Prüfung lief deshalb ins
+            // Leere, und jeder Tastendruck leerte kurz die Liste.
+            if Task.isCancelled { return }
+            hubs = []
+        }
+    }
+
+    // MARK: - Zuletzt gesucht
+
+    private func remember(_ eintrag: String) {
+        recent.removeAll { $0.caseInsensitiveCompare(eintrag) == .orderedSame }
+        recent.insert(eintrag, at: 0)
+        recent = Array(recent.prefix(Self.recentLimit))
+        defaults.set(recent, forKey: Self.recentKey)
+    }
+
+    func forgetRecent() {
+        recent = []
+        defaults.removeObject(forKey: Self.recentKey)
+    }
+}