feat(offline): text-only Cleanup + ζ-1 Offline-Sync

Drei zusammenhängende Blöcke in einem Commit (Files überlappen sich
zwischen den Themen — sauberer Split nicht ohne Friktion möglich):

1. Wordeck-Text-Only-Cleanup
   Image-Occlusion + Audio-Front-Code raus. Server ist seit Migration
   0004_wordeck_text_only.sql text-only (in Prod waren 0 Karten der
   Typen, 0 Media-Files). Native-Code war Build-11-Altlast.
   - Gelöscht: MediaCache, MediaEnvironment, RemoteImage,
     AudioPlayerButton, MaskEditorView, CardEditorMediaFields,
     CardEditorPayload, Media.swift
   - CardType-Enum auf 5 Werte: basic / basic-reverse / cloze /
     typing / multiple-choice
   - media_refs aus Card, CardCreateBody, CardUpdateBody, call-sites
   - WordeckAPI.uploadMedia / .fetchMedia / .deleteMedia + Single-File-
     makeMultipartBody gestrichen
   - MarketplaceCardConverter ohne Media-Cases
   - CardRenderer ohne imageOcclusionView / audioFrontView

2. AI-Media-Mode raus
   /decks/from-image-Endpoint existiert serverseitig nicht (server
   registriert nur /decks/generate für Text-Prompts). Native-Aufrufe
   wären 404 — toter Code.
   - aiMedia-Case aus DeckEditorView.CreateMode, ModePicker auf
     3 Optionen (Leer / KI / CSV)
   - AIMediaFormSections, MediaFileRow, mediaPickers, thumbnail,
     ingestPhotoItems, handlePDFImport raus
   - generateDeckFromMedia + makeFromImageMultipartBody raus
   - GenerationMediaFile-Struct + PhotosUI-Import + PlatformImage-
     typealias raus
   - NSPhotoLibraryUsageDescription aus project.yml entfernt (es gibt
     keinen Photo-Library-Zugriff mehr)
   - maxMediaFiles/maxImageBytes/maxPDFBytes + inferImageMimeType +
     imageExtension aus DeckEditorHelpers raus

3. ζ-1 Offline-Sync
   Konzept in docs/OFFLINE_SYNC.md. Server-authoritative-FSRS bleibt —
   kein lokales FSRS, nur Snapshot-Modell.
   - Neue SwiftData-Models: CachedCard + CachedDueReview, beide mit
     userId/deckId-Indizes
   - ModelContainer um die zwei Models erweitert (additive Migration,
     sollte automatisch laufen — vor TestFlight verifizieren)
   - DueReview bekommt programmatischen init(review:card:) für die
     Cache-Rekonstruktion
   - DeckListStore.refresh() zieht Cards + Due-Reviews pro Deck
     parallel in einer TaskGroup; applyToCache in drei Helpers
     gesplittet (applyDecks / applyCards / applyDueReviews)
   - Karten: Upsert mit Orphan-Cleanup
   - Due-Reviews: voll ersetzt pro Refresh (Server-`due`-Zeiten
     ändern sich, Merge wäre falsch)
   - StudySession.start() fällt bei Netz-Fehler auf
     CachedDueReview-Snapshot zurück, setzt isOfflineSession-Flag
   - StudySessionView zeigt offline-Banner und am Ende der Session
     einen Hinweis „Weitere Karten erst nach Verbindung verfügbar"
   - AccountView.wipeLocalCache(): DSGVO-Wipe vor signOut() und nach
     deleteAccount → CachedDeck + CachedCard + CachedDueReview +
     PendingGrade werden gelöscht

Plus: Keychain-Test in WordeckNativeTests.swift fix — erwartete
"ev.mana.wordeck", muss seit Cross-App-SSO-Commit 19fee75
ManaSharedKeychainGroup nutzen. Auf Konstant-Reference umgestellt,
damit's nicht wieder driftet.

Verifikation:
- xcodebuild iOS-Simulator: BUILD SUCCEEDED
- swiftlint --strict: 0 violations in 68 files
- swiftformat: clean
- 37/37 Tests grün (inkl. fix-Keychain-Test)
- macOS-Build scheitert an pre-existing .topBarTrailing in
  StudySessionView (iOS-only API seit 2026-05-13, nicht durch
  diesen Commit verursacht)

Pflicht-Verifikation vor TestFlight (in PLAN.md verewigt):
- SwiftData-Migration auf Bestandsbuilder
- Offline-Endurance (50+ Karten Flugmodus)
- Logout-Wipe mit Account-Switch
- Cross-Check Web ↔ Native nach Offline-Grade

Diff: 35 files, +869 / -1622, netto ~−750 LOC.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Sources/Core/Sync/DeckListStore.swift

@@ -6,6 +6,10 @@ import WidgetKit
 
 /// Orchestriert API + SwiftData-Cache für die Deck-Liste.
 /// View bindet sich an `state` und `errorMessage`.
+///
+/// Seit ζ-1 (2026-05-18) zieht der Store auch Karten + Due-Reviews
+/// pro Deck mit (offline-Read für die Study-View). Siehe
+/// `docs/OFFLINE_SYNC.md`.
 @MainActor
 @Observable
 final class DeckListStore {
@@ -29,10 +33,9 @@ final class DeckListStore {
         self.auth = auth
     }
 
-    /// Holt Decks vom Server, aktualisiert Cache. Bei Netzfehler bleibt
-    /// der Cache (offline-readable). Im Guest-Mode wird kein Server-Call
-    /// versucht — der Cache (leer oder über Marketplace-Klone gefüllt)
-    /// wird so wie er ist gerendert.
+    /// Holt Decks + Karten + Due-Reviews vom Server, aktualisiert Cache.
+    /// Bei Netzfehler bleibt der Cache (offline-readable). Im Guest-Mode
+    /// wird kein Server-Call versucht.
     func refresh() async {
         guard case .signedIn = auth.status else {
             state = .idle
@@ -45,7 +48,8 @@ final class DeckListStore {
 
         do {
             let decks = try await api.listDecks()
-            try await applyToCache(decks: decks)
+            let perDeck = try await fetchPerDeckPayloads(decks: decks)
+            try await applyToCache(decks: decks, perDeck: perDeck)
             updateWidgetSnapshot()
             state = .loaded
             Log.sync.info("Loaded \(decks.count, privacy: .public) decks from server")
@@ -60,58 +64,103 @@ final class DeckListStore {
         }
     }
 
-    private func applyToCache(decks remoteDecks: [Deck]) async throws {
-        let remoteIDs = Set(remoteDecks.map(\.id))
+    /// Snapshot pro Deck, geholt in einer parallelen TaskGroup.
+    private struct PerDeckPayload {
+        let cards: [Card]
+        let dueReviews: [DueReview]
+    }
 
-        // 1. Bestehende Cache-Entries finden
-        let descriptor = FetchDescriptor<CachedDeck>()
-        let cached = (try? context.fetch(descriptor)) ?? []
-        let cachedByID = Dictionary(uniqueKeysWithValues: cached.map { ($0.id, $0) })
-
-        // 2. Gelöschte Decks aus Cache entfernen
-        for cachedDeck in cached where !remoteIDs.contains(cachedDeck.id) {
-            context.delete(cachedDeck)
-        }
-
-        // 3. Counts parallel holen
-        let counts = await withTaskGroup(of: (String, Int, Int).self) { group in
-            for deck in remoteDecks {
+    private func fetchPerDeckPayloads(decks: [Deck]) async throws -> [String: PerDeckPayload] {
+        try await withThrowingTaskGroup(of: (String, PerDeckPayload).self) { group in
+            for deck in decks {
                 group.addTask { [api] in
-                    async let cards = api.cardCount(deckId: deck.id)
-                    async let due = api.dueCount(deckId: deck.id)
-                    let cardCount = await (try? cards) ?? 0
-                    let dueCount = await (try? due) ?? 0
-                    return (deck.id, cardCount, dueCount)
+                    async let cards = api.listCards(deckId: deck.id)
+                    async let due = api.dueReviews(deckId: deck.id, limit: 500)
+                    return try await (deck.id, PerDeckPayload(cards: cards, dueReviews: due))
                 }
             }
-            var result: [String: (cardCount: Int, dueCount: Int)] = [:]
-            for await (id, c, d) in group {
-                result[id] = (c, d)
+            var result: [String: PerDeckPayload] = [:]
+            for try await (id, payload) in group {
+                result[id] = payload
             }
             return result
         }
+    }
 
-        // 4. Neue/aktualisierte Decks einarbeiten
-        for deck in remoteDecks {
-            let counts = counts[deck.id] ?? (0, 0)
-            if let existing = cachedByID[deck.id] {
-                existing.update(from: deck, cardCount: counts.cardCount, dueCount: counts.dueCount)
-            } else {
-                let cachedDeck = CachedDeck(
-                    deck: deck,
-                    cardCount: counts.cardCount,
-                    dueCount: counts.dueCount
-                )
-                context.insert(cachedDeck)
-            }
-        }
-
+    private func applyToCache(
+        decks remoteDecks: [Deck],
+        perDeck: [String: PerDeckPayload]
+    ) async throws {
+        applyDecks(remoteDecks, perDeck: perDeck)
+        applyCards(remoteDecks, perDeck: perDeck)
+        applyDueReviews(remoteDecks, perDeck: perDeck)
         try context.save()
     }
 
+    private func applyDecks(_ remoteDecks: [Deck], perDeck: [String: PerDeckPayload]) {
+        let remoteIDs = Set(remoteDecks.map(\.id))
+        let cachedDecks = (try? context.fetch(FetchDescriptor<CachedDeck>())) ?? []
+        let cachedDeckByID = Dictionary(uniqueKeysWithValues: cachedDecks.map { ($0.id, $0) })
+
+        for cachedDeck in cachedDecks where !remoteIDs.contains(cachedDeck.id) {
+            context.delete(cachedDeck)
+        }
+
+        for deck in remoteDecks {
+            let cardCount = perDeck[deck.id]?.cards.count ?? 0
+            let dueCount = perDeck[deck.id]?.dueReviews.count ?? 0
+            if let existing = cachedDeckByID[deck.id] {
+                existing.update(from: deck, cardCount: cardCount, dueCount: dueCount)
+            } else {
+                context.insert(CachedDeck(deck: deck, cardCount: cardCount, dueCount: dueCount))
+            }
+        }
+    }
+
+    /// Karten: Upsert pro remoteDeck, Orphans (Karten von gelöschten
+    /// Decks oder serverseits gelöschte Karten) löschen.
+    private func applyCards(_ remoteDecks: [Deck], perDeck: [String: PerDeckPayload]) {
+        let allCachedCards = (try? context.fetch(FetchDescriptor<CachedCard>())) ?? []
+        let cachedCardByID = Dictionary(uniqueKeysWithValues: allCachedCards.map { ($0.id, $0) })
+        var remoteCardIDs: Set<String> = []
+
+        for deck in remoteDecks {
+            guard let cards = perDeck[deck.id]?.cards else { continue }
+            for card in cards {
+                remoteCardIDs.insert(card.id)
+                if let existing = cachedCardByID[card.id] {
+                    existing.update(from: card)
+                } else {
+                    context.insert(CachedCard(card: card))
+                }
+            }
+        }
+        for cachedCard in allCachedCards where !remoteCardIDs.contains(cachedCard.id) {
+            context.delete(cachedCard)
+        }
+    }
+
+    /// Due-Reviews: Snapshot überschreibt komplett. Server-`due`-Zeiten
+    /// können sich ändern, also kein Merge — voll ersetzen.
+    private func applyDueReviews(_ remoteDecks: [Deck], perDeck: [String: PerDeckPayload]) {
+        let allCachedDues = (try? context.fetch(FetchDescriptor<CachedDueReview>())) ?? []
+        for cached in allCachedDues {
+            context.delete(cached)
+        }
+        for deck in remoteDecks {
+            guard let dues = perDeck[deck.id]?.dueReviews else { continue }
+            for due in dues {
+                context.insert(CachedDueReview(
+                    dueReview: due,
+                    deckId: deck.id,
+                    userId: due.review.userId
+                ))
+            }
+        }
+    }
+
     /// Schreibt einen WidgetSnapshot in den shared App-Group-Container
-    /// und fordert WidgetKit auf, alle Widgets neu zu rendern. Wird nach
-    /// jedem erfolgreichen Refresh aufgerufen.
+    /// und fordert WidgetKit auf, alle Widgets neu zu rendern.
     private func updateWidgetSnapshot() {
         let descriptor = FetchDescriptor<CachedDeck>(
             sortBy: [SortDescriptor(\.dueCount, order: .reverse)]

Sources/Core/Sync/MediaCache.swift

@@ -1,81 +0,0 @@
-import Foundation
-import ManaCore
-
-/// Persistenter Disk-Cache für Cards-Media-Files. Bilder/Audio werden
-/// einmal vom Server geladen und danach lokal serviert — der Server
-/// setzt `Cache-Control: private, immutable`, das honorieren wir hier.
-///
-/// LRU-Verdrängung mit Soft-Limit (Default 200 MB).
-actor MediaCache {
-    private let root: URL
-    private let api: WordeckAPI
-    private let maxBytes: Int
-
-    init(api: WordeckAPI, maxBytes: Int = 200 * 1024 * 1024) {
-        self.api = api
-        self.maxBytes = maxBytes
-        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
-        root = caches.appendingPathComponent("cards-media", isDirectory: true)
-        try? FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
-    }
-
-    /// Liefert die lokale URL eines Media-Files. Lädt vom Server, falls
-    /// nicht im Cache. Wirft `AuthError`, wenn der Download scheitert.
-    func localURL(for mediaId: String) async throws -> URL {
-        let target = root.appendingPathComponent(mediaId)
-        if FileManager.default.fileExists(atPath: target.path) {
-            try? FileManager.default.setAttributes([.modificationDate: Date.now], ofItemAtPath: target.path)
-            return target
-        }
-        let data = try await api.fetchMedia(id: mediaId)
-        try data.write(to: target, options: .atomic)
-        try? await pruneIfNeeded()
-        return target
-    }
-
-    /// Direktes Lesen — für UI-Komponenten, die `Data` brauchen (z.B. AVAudioPlayer).
-    func data(for mediaId: String) async throws -> Data {
-        try await Data(contentsOf: localURL(for: mediaId))
-    }
-
-    /// LRU-Eviction: bei Überschreitung des Limits ältesten zuerst löschen.
-    private struct CacheEntry {
-        let url: URL
-        let size: Int
-        let date: Date
-    }
-
-    private func pruneIfNeeded() async throws {
-        let resourceKeys: Set<URLResourceKey> = [.fileSizeKey, .contentModificationDateKey]
-        guard let items = try? FileManager.default.contentsOfDirectory(
-            at: root,
-            includingPropertiesForKeys: Array(resourceKeys)
-        ) else { return }
-
-        let withMeta = items.compactMap { url -> CacheEntry? in
-            let values = try? url.resourceValues(forKeys: resourceKeys)
-            guard let size = values?.fileSize, let date = values?.contentModificationDate else { return nil }
-            return CacheEntry(url: url, size: size, date: date)
-        }
-
-        let totalBytes = withMeta.reduce(0) { $0 + $1.size }
-        guard totalBytes > maxBytes else { return }
-
-        let sortedOldestFirst = withMeta.sorted { $0.date < $1.date }
-        var remaining = totalBytes
-        for item in sortedOldestFirst {
-            if remaining <= maxBytes { break }
-            try? FileManager.default.removeItem(at: item.url)
-            remaining -= item.size
-            let name = item.url.lastPathComponent
-            let size = item.size
-            Log.sync.info("MediaCache evicted \(name, privacy: .public) (\(size, privacy: .public)B)")
-        }
-    }
-
-    /// Wipe — für Sign-out o.ä.
-    func clear() {
-        try? FileManager.default.removeItem(at: root)
-        try? FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
-    }
-}

Sources/Core/Sync/MediaEnvironment.swift

@@ -1,5 +0,0 @@
-import SwiftUI
-
-extension EnvironmentValues {
-    @Entry var mediaCache: MediaCache?
-}