Wetter: Zwischenspeicher auf Platte, Zeitlimits auf alle Netzaufrufe

Das Protokoll zeigte das Wetter nach 185 ms erfolgreich geladen — und
danach nichts mehr. Dazwischen liegt genau ein Aufruf, der noch ins Netz
geht: die Abfrage der Namensnennung. Sie hatte kein Zeitlimit, und ohne
sie wurde der Schnappschuss nie gebaut. Ein Netzaufruf ohne Zeitlimit ist
ein Aufruf, der hängen darf.

Jetzt hat jeder ein Limit: Wetter zwölf Sekunden, Ortung acht, Umkehrsuche
fünf, Namensnennung drei. Die Namensnennung hält den Messwert ohnehin nicht
mehr auf — sie ist Pflicht für die Anzeige, nicht für das Laden — und wird
behalten, weil sie sich nicht ändert.

Der Zwischenspeicher lag nur im Arbeitsspeicher. Beim Start stand deshalb
ein Rädchen da, bis der erste Abruf durch war; hing der, für immer. Er
liegt jetzt in weather.json und wird beim Anlegen des Modells gelesen: das
Widget zeigt sofort, was zuletzt bekannt war, mit Zeitstempel, und lädt im
Hintergrund nach. Ein Wert von vor einer Stunde ist eine Auskunft, ein
Rädchen ist keine.

Nachgeprüft: Datei wird geschrieben, Hamburg mit zwölf Stundenwerten.

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

Packages/OnyxKit/Sources/WeatherProvider/WeatherKitSource.swift

@@ -84,7 +84,8 @@ public final class WeatherKitSource {
 
     private let service = WeatherService.shared
     private let location = LocationProvider()
-    private let geocoder = CLGeocoder()
+    /// Einmal geholt, dann behalten — sie ändert sich nicht.
+    private var cachedAttribution: WeatherAttribution?
 
     public init() {}
 
@@ -114,7 +115,11 @@ public final class WeatherKitSource {
                 log.notice("Wetter: Ortungsberechtigung noch nicht erteilt")
                 return .locationUndetermined
             }
-            guard let here = await location.currentLocation() else {
+            // Zeitlimit: CoreLocation kann auf eine Ortung warten, die nie
+            // kommt — etwa ohne Sicht auf WLAN-Netze.
+            guard let here = await withTimeout(seconds: 8, operation: {
+                await self.location.currentLocation()
+            }) ?? nil else {
                 let denied = location.isDenied
                 log.error("Wetter: keine Ortung erhalten (verweigert: \(denied, privacy: .public))")
                 return denied
@@ -129,27 +134,54 @@ public final class WeatherKitSource {
             placeName = name
         }
 
-        do {
-            let weather = try await service.weather(for: coordinate)
+        let service = self.service
+        let fetched = await withTimeout(seconds: 12) { () -> Result<Weather, Error> in
+            do { return .success(try await service.weather(for: coordinate)) }
+            catch { return .failure(error) }
+        }
+
+        switch fetched {
+        case .success(let weather):
             return .ready(Self.snapshot(from: weather,
                                         placeName: placeName,
-                                        attribution: try? await attribution()))
-        } catch {
+                                        attribution: await attribution()))
+        case .failure(let error):
             log.error("WeatherKit: \(error.localizedDescription, privacy: .public)")
             return .unavailable(lastKnown: nil, reason: error.localizedDescription)
+        case nil:
+            log.error("WeatherKit: Zeitlimit überschritten")
+            return .unavailable(lastKnown: nil, reason: String(
+                localized: "weather.error.timeout", bundle: .module))
         }
     }
 
     /// Apples Namensnennung. Keine Kür — sie ist Bedingung der Nutzung.
-    private func attribution() async throws -> WeatherAttribution {
-        let legal = try await service.attribution
-        return WeatherAttribution(name: "Apple Weather",
-                                  legalPageURL: legal.legalPageURL,
-                                  logoURL: legal.combinedMarkDarkURL)
+    ///
+    /// Aber sie darf den Wetterwert nicht aufhalten. Genau daran hing das
+    /// Widget: das Wetter war in 185 ms da, und dieser Aufruf kam nie zurück.
+    /// Also mit knappem Zeitlimit, und das Ergebnis wird behalten — die
+    /// Namensnennung ändert sich nicht.
+    private func attribution() async -> WeatherAttribution? {
+        if let cachedAttribution { return cachedAttribution }
+        let service = self.service
+        let fetched = await withTimeout(seconds: 3) { () -> WeatherAttribution? in
+            guard let legal = try? await service.attribution else { return nil }
+            return WeatherAttribution(name: "Apple Weather",
+                                      legalPageURL: legal.legalPageURL,
+                                      logoURL: legal.combinedMarkDarkURL)
+        } ?? nil
+        cachedAttribution = fetched
+        return fetched
     }
 
     private func name(for location: CLLocation) async -> String {
-        guard let placemark = try? await geocoder.reverseGeocodeLocation(location).first else {
+        // Auch hier ein Zeitlimit: ohne Netz wartet die Umkehrsuche lange.
+        // `CLGeocoder` ist nicht `Sendable`, also wird es im Aufruf angelegt
+        // statt eingefangen — es dient ohnehin nur diesem einen Zweck.
+        let found = await withTimeout(seconds: 5) {
+            try? await CLGeocoder().reverseGeocodeLocation(location).first
+        } ?? nil
+        guard let placemark = found else {
             return "Aktueller Ort"
         }
         return placemark.locality ?? placemark.subAdministrativeArea