Die fremde Info.plist war es, nicht der Build-Ordner

Beide App-Ziele lesen denselben Ordner ein. XcodeGen nimmt nur die eigene
Info.plist aus den Quellen heraus — die des jeweils anderen Ziels bleibt drin
und landet unverarbeitet als Ressource im Bündel, mitsamt dem wörtlichen
$(PRODUCT_BUNDLE_IDENTIFIER).

Wer die Datei danach liest, liest die falsche: codesign stempelte
Identifier=$(PRODUCT_BUNDLE_IDENTIFIER) auf die App, und das iPad lehnte sie
als „not a valid bundle" ab. „Clean Build Folder" konnte daran nichts ändern —
der Rat war falsch, der Fehler kam aus project.yml.

Dazu: Bilder laden jetzt über ArtworkLoader statt AsyncImage. AsyncImage lädt
bei jedem Erscheinen neu und kennt keinen Zwischenspeicher; bei sechzig Kacheln
plus einem großen Aufmacher stauen sich die Anfragen hinter sechs Verbindungen.
Auf dem iPad fiel das nicht auf, auf dem Mac blieb der Aufmacher grau.

Und die beiden #if os(macOS) um die Breite der Seitenleiste liefen unter
Catalyst ins Leere — dort ist os(iOS) wahr.

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

Packages/FlixyKit/Sources/FlixyDesign/Components/FlixyArtwork.swift

@@ -2,10 +2,11 @@ import SwiftUI
 
 /// Ein Bild vom Server mit Lade- und Fehlerzustand.
 ///
-/// Kapselt `AsyncImage`, damit der Austausch gegen einen eigenen, zwischen-
-/// speichernden Lader später genau eine Datei betrifft. Die Startseite zeigt
-/// dutzende Bilder gleichzeitig; ohne Zwischenspeicher lädt `AsyncImage` sie
-/// bei jedem Erscheinen neu.
+/// Der Austausch, den die frühere Notiz hier angekündigt hat, ist vollzogen:
+/// statt `AsyncImage` lädt `ArtworkLoader`. Der Grund stand schon da — eine
+/// Startseite zeigt dutzende Bilder gleichzeitig, und `AsyncImage` lädt sie bei
+/// jedem Erscheinen neu. Auf dem Mac wurde daraus ein sichtbarer Fehler: der
+/// Aufmacher und die Hälfte der Plakate blieben grau.
 public struct FlixyArtwork: View {
     private let url: URL?
     private let aspectRatio: CGFloat
@@ -30,31 +31,62 @@ public struct FlixyArtwork: View {
         self.contentMode = contentMode
     }
 
+    @State private var loaded: PlatformImage?
+    @State private var hasFailed = false
+
     public var body: some View {
         Rectangle()
             .fill(Color.flixyPlaceholder)
             .aspectRatio(aspectRatio, contentMode: .fit)
             .overlay {
-                AsyncImage(url: url, transaction: Transaction(animation: .easeOut(duration: 0.2))) { phase in
-                    switch phase {
-                    case .success(let image):
-                        switch contentMode {
-                        case .fill: image.resizable().scaledToFill()
-                        case .fit: image.resizable().scaledToFit()
-                        }
-                    case .failure:
-                        // Kein Fehlertext: bei einer Reihe aus zwanzig Kacheln
-                        // wäre das mehr Lärm als Hilfe. Das Symbol sagt genug.
-                        Image(systemName: fallbackSymbol)
-                            .font(.title2)
-                            .foregroundStyle(Color.flixyTextMuted)
-                    case .empty:
-                        ShimmerPlaceholder()
-                    @unknown default:
-                        ShimmerPlaceholder()
-                    }
-                }
+                content
             }
             .clipped()
+            .task(id: url) { await load() }
+    }
+
+    @ViewBuilder
+    private var content: some View {
+        if let loaded {
+            switch contentMode {
+            case .fill: Image(platform: loaded).resizable().scaledToFill()
+            case .fit: Image(platform: loaded).resizable().scaledToFit()
+            }
+        } else if hasFailed {
+            // Kein Fehlertext: bei einer Reihe aus zwanzig Kacheln wäre das
+            // mehr Lärm als Hilfe. Das Symbol sagt genug.
+            Image(systemName: fallbackSymbol)
+                .font(.title2)
+                .foregroundStyle(Color.flixyTextMuted)
+        } else {
+            ShimmerPlaceholder()
+        }
+    }
+
+    private func load() async {
+        guard let url else {
+            hasFailed = false
+            loaded = nil
+            return
+        }
+
+        // Liegt es schon im Arbeitsspeicher, gibt es kein Aufblitzen: ohne
+        // diesen Schritt wäre jede zurückscrollende Kachel kurz grau.
+        if let cached = await ArtworkLoader.shared.cached(url) {
+            loaded = cached
+            hasFailed = false
+            return
+        }
+
+        loaded = nil
+        hasFailed = false
+
+        let image = await ArtworkLoader.shared.image(for: url)
+        guard !Task.isCancelled else { return }
+
+        withAnimation(.easeOut(duration: 0.2)) {
+            loaded = image
+            hasFailed = image == nil
+        }
     }
 }