imaging: rewrite EXIF facade against SwiftExif 0.1.0 typed API

Drop the ExifSnapshot adapter and the "Keywords"/coercion plumbing.
SwiftExif.Image.parse(at:) returns a Sendable ExifResult with typed
IptcFields, which is exactly what the adapter was hand-rolling.

Photo+Read switches from snapshot.iptcStrings[...] to iptc.city /
provinceState / countryCode / countryName, and from .iptcKeywords
to iptc.keywords. The .exif and .exifRaw dicts keep the same shape,
so per-IFD/per-tag reads are untouched.

readExif stays non-throws; ParseError.fileUnreadable is swallowed
to an empty result because the VIPS probe on the same path will
surface that condition with a richer error.

Author: kradalby

Sources/MuninKit/IO/Imaging/EXIF.swift

@@ -3,56 +3,24 @@ import SwiftExif
 import SystemPackage
 
 /// EXIF + IPTC reads on the same `Imaging` facade as the VIPS calls.
-/// Direct `SwiftExif.Image` use lives only in this file so the
-/// non-`Sendable` struct stays contained; callers only ever see the
-/// Sendable `ExifSnapshot` value type.
+/// `SwiftExif.Image.parse(at:)` already returns a Sendable `ExifResult`,
+/// so the facade is a thin wrapper — its only job is to keep the
+/// SwiftExif import contained inside `IO/Imaging/` (enforced by
+/// `ImagingFacadeTests`).
 extension Imaging {
 
-  /// Read EXIF + IPTC in one pass. Errors from SwiftExif surface as
-  /// empty sub-dictionaries, matching today's "no EXIF / no IPTC is
-  /// fine" behaviour — a source without a proper EXIF block is still a
-  /// valid photo, just one with fewer populated `Photo` fields.
-  static func readExif(source: FilePath) -> ExifSnapshot {
-    let image = SwiftExif.Image(imagePath: URL(fileURLWithPath: source.string))
-
-    var iptcStrings: [String: String] = [:]
-    var iptcKeywords: [String] = []
-    for (key, value) in image.Iptc() {
-      if let str = value as? String {
-        iptcStrings[key] = str
-      } else if key == iptcKeywordsKey, let list = value as? [String] {
-        iptcKeywords = list
-      }
+  /// Read EXIF + IPTC in one pass. `SwiftExif.parse(at:)` only throws
+  /// `ParseError.fileUnreadable`, which in Munin's flow is racing the
+  /// directory walker — the VIPS probe on the same path will surface
+  /// the same condition with a richer error, so we swallow it here
+  /// and return an empty result. A source without a proper EXIF block
+  /// is still a valid photo, just one with fewer populated `Photo`
+  /// fields.
+  static func readExif(source: FilePath) -> ExifResult {
+    do {
+      return try SwiftExif.Image.parse(at: URL(fileURLWithPath: source.string))
+    } catch {
+      return ExifResult(exif: [:], exifRaw: [:], iptc: IptcFields(), orientation: nil)
     }
-
-    return ExifSnapshot(
-      exif: image.Exif(),
-      exifRaw: image.ExifRaw(),
-      iptcStrings: iptcStrings,
-      iptcKeywords: iptcKeywords)
   }
-
-  /// SwiftExif's key for the IPTC "Keywords" field.
-  private static let iptcKeywordsKey = "Keywords"
-}
-
-/// Bundled EXIF + IPTC read from a single source. Sendable value type;
-/// can cross task boundaries without any unsafe escape hatches.
-struct ExifSnapshot: Sendable {
-  /// Human-readable EXIF values, keyed `[ifd][tag]`. Matches
-  /// `SwiftExif.Image.Exif()`.
-  let exif: [String: [String: String]]
-
-  /// Raw EXIF values, keyed `[ifd][tag]`. Matches
-  /// `SwiftExif.Image.ExifRaw()`.
-  let exifRaw: [String: [String: String]]
-
-  /// IPTC fields whose values are plain strings — City, Province/State,
-  /// Country Code, Country Name, etc. Pre-separated from `iptcKeywords`
-  /// so the caller doesn't have to do `as? String` / `as? [String]`
-  /// coercions on `Any`.
-  let iptcStrings: [String: String]
-
-  /// IPTC "Keywords" field, normalised to an array. Empty when absent.
-  let iptcKeywords: [String]
 }

Sources/MuninKit/Photo+Read.swift

@@ -93,9 +93,9 @@ func readPhotoFromPath(
   let dateFormatter = DateFormatter()
   dateFormatter.dateFormat = "yyyy:MM:dd HH:mm:ss"
 
-  let exifSnapshot = Imaging.readExif(source: filePath)
-  let exifDict = exifSnapshot.exif
-  let exifRawDict = exifSnapshot.exifRaw
+  let exifResult = Imaging.readExif(source: filePath)
+  let exifDict = exifResult.exif
+  let exifRawDict = exifResult.exifRaw
 
   var photo = Photo(
     name: name,
@@ -220,10 +220,10 @@ func readPhotoFromPath(
   }
 
   // Add location data if available
-  if let city = exifSnapshot.iptcStrings["City"],
-    let state = exifSnapshot.iptcStrings["Province/State"],
-    let locationCode = exifSnapshot.iptcStrings["Country Code"],
-    let locationName = exifSnapshot.iptcStrings["Country Name"]
+  if let city = exifResult.iptc.city,
+    let state = exifResult.iptc.provinceState,
+    let locationCode = exifResult.iptc.countryCode,
+    let locationName = exifResult.iptc.countryName
   {
     photo.location = LocationData(
       city: city,
@@ -250,7 +250,7 @@ func readPhotoFromPath(
     photo.keywords.append(locationNameKeyword)
   }
 
-  for keyword in exifSnapshot.iptcKeywords {
+  for keyword in exifResult.iptc.keywords {
     let keywordPointer = KeywordPointer(
       name: keyword,
       url: "\(ctx.config.outputPath)/keywords/\(urlifyName(keyword)).json"