v0.5.0 — Phase β-4 Media + Advanced Card-Types

Alle 7 Card-Types werden gerendert und können erstellt werden.
image-occlusion mit Touch-Drag-Mask-Editor (kein PencilKit — Server-
Schema erlaubt nur Rechtecke), audio-front mit AVAudioPlayer und
File-Picker.

- MediaUploadResponse-DTO, MaskRegion-Codable mit 0..1-Coordinates
- MaskRegions.parse/encode (1:1-Port aus cards-domain, Sortierung
  nach ID lexikographisch)
- CardFieldsBuilder.imageOcclusion mit stringified-JSON-mask_regions
  + audioFront
- CardsAPI.uploadMedia (Multipart, 25 MiB) + fetchMedia (streamed)
- MediaCache actor mit LRU 200 MB (contentModificationDate-Eviction)
- mediaCache Environment-Key
- RemoteImage + AudioPlayerButton SwiftUI-Views
- CardRenderer: imageOcclusion (Mask-Overlay über RemoteImage) +
  audioFront (AudioPlayerButton + back-Text auf Flip)
- MaskEditorView: Touch-Drag-Rechteck, Label-Edit, Delete
- CardEditorView erweitert: PhotosPicker für Image, fileImporter
  für Audio, Magic-Byte-MIME-Detection
- 6 neue Tests für MaskRegions (30 Total grün)

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

Sources/Core/Sync/MediaCache.swift

@@ -0,0 +1,73 @@
+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: CardsAPI
+    private let maxBytes: Int
+
+    init(api: CardsAPI, 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 Data(contentsOf: try await localURL(for: mediaId))
+    }
+
+    /// LRU-Eviction: bei Überschreitung des Limits ältesten zuerst löschen.
+    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 -> (url: URL, size: Int, date: Date)? in
+            let values = try? url.resourceValues(forKeys: resourceKeys)
+            guard let size = values?.fileSize, let date = values?.contentModificationDate else { return nil }
+            return (url, size, 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
+            Log.sync.info("MediaCache evicted \(item.url.lastPathComponent, privacy: .public) (\(item.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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// Environment-Key, der den shared `MediaCache` durch die View-Hierarchie
+/// reicht. App-Entrypoint setzt den Wert; Views lesen via
+/// `@Environment(\.mediaCache)`.
+private struct MediaCacheKey: EnvironmentKey {
+    static let defaultValue: MediaCache? = nil
+}
+
+extension EnvironmentValues {
+    var mediaCache: MediaCache? {
+        get { self[MediaCacheKey.self] }
+        set { self[MediaCacheKey.self] = newValue }
+    }
+}