@mmerterden/multi-agent-pipeline 20.6.0 → 20.8.0

package/pipeline/skills/shared/external/swiftui-uikit-interop/references/representable-recipes.md

@@ -1,363 +1,327 @@
 # Representable Recipes
 
-Complete working recipes for common UIKit wrapping scenarios. Each recipe includes the full `UIViewRepresentable` or `UIViewControllerRepresentable` struct, the Coordinator with delegate methods, a SwiftUI usage example, and gotchas specific to that wrapper.
-
----
+Nine wrappers for UIKit surfaces that SwiftUI apps still reach for. Every recipe
+gives the representable itself, its Coordinator and the delegate methods that
+matter, a short SwiftUI call site, and the traps specific to that wrapper. Many
+recipes end with a "Prefer native" note: when a SwiftUI equivalent exists for
+your deployment target, start there and only wrap when you need what it lacks.
+
+Web content is deliberately absent. On iOS 26 and later the native WebKit for
+SwiftUI types replace a wrapped web view; see the `swiftui-webkit` skill. This
+file sticks to general representable technique.
+
+All recipes assume a deployment target of iOS 16 or later, so `sizeThatFits`
+needs no availability annotation here. Each coordinator keeps a `parent`
+reference and each update method starts by refreshing it with
+`context.coordinator.parent = self`, so callbacks always write through the
+current bindings and closures.
 
 ## Contents
 
-- [1. MKMapView Wrapper](#1-mkmapview-wrapper)
-- [2. UITextView Wrapper (Attributed Text)](#2-uitextview-wrapper-attributed-text)
-- [3. AVCaptureVideoPreviewLayer Wrapper](#3-avcapturevideopreviewlayer-wrapper)
-- [4. PHPickerViewController Wrapper](#4-phpickerviewcontroller-wrapper)
-- [5. MFMailComposeViewController Wrapper](#5-mfmailcomposeviewcontroller-wrapper)
-- [6. UIActivityViewController Wrapper (Share Sheet)](#6-uiactivityviewcontroller-wrapper-share-sheet)
-- [7. UISearchBar Wrapper](#7-uisearchbar-wrapper)
-- [8. PDFView Wrapper (PDFKit)](#8-pdfview-wrapper-pdfkit)
-- [9. MFMessageComposeViewController Wrapper](#9-mfmessagecomposeviewcontroller-wrapper)
-
-> Native WebKit for SwiftUI now covers modern embedded web content on iOS 26+. See the `swiftui-webkit` skill for `WebView`, `WebPage`, navigation policies, JavaScript calls, and migration guidance. Keep this file focused on generic representable patterns.
+1. [Map](#1-mkmapview-wrapper)
+2. [Attributed text view](#2-uitextview-wrapper-attributed-text)
+3. [Camera preview](#3-avcapturevideopreviewlayer-wrapper)
+4. [Photo picker](#4-phpickerviewcontroller-wrapper)
+5. [Mail composer](#5-mfmailcomposeviewcontroller-wrapper)
+6. [Share sheet](#6-uiactivityviewcontroller-wrapper-share-sheet)
+7. [Search bar](#7-uisearchbar-wrapper)
+8. [PDF viewer](#8-pdfview-wrapper-pdfkit)
+9. [Text message composer](#9-mfmessagecomposeviewcontroller-wrapper)
 
 ## 1. MKMapView Wrapper
 
-Display a map with annotations, track region changes, and toggle map type.
-
 ```swift
 import SwiftUI
 import MapKit
 
-struct MapViewRepresentable: UIViewRepresentable {
-    @Binding var region: MKCoordinateRegion
-    @Binding var mapType: MKMapType
-    var annotations: [MKPointAnnotation]
-    var onRegionChanged: ((MKCoordinateRegion) -> Void)?
+struct TrailMapView: UIViewRepresentable {
+    @Binding var visibleArea: MKCoordinateRegion
+    @Binding var baseMap: MKMapType
+    var pins: [MKPointAnnotation]
+    var onAreaChanged: ((MKCoordinateRegion) -> Void)?
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    private static let centerTolerance = 0.0001
+
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
     func makeUIView(context: Context) -> MKMapView {
-        let mapView = MKMapView()
-        mapView.delegate = context.coordinator
-        mapView.showsUserLocation = true
-        return mapView
+        let map = MKMapView(frame: .zero)
+        map.showsUserLocation = true
+        map.delegate = context.coordinator
+        return map
     }
 
-    func updateUIView(_ uiView: MKMapView, context: Context) {
-        // Update map type
-        if uiView.mapType != mapType {
-            uiView.mapType = mapType
-        }
+    func updateUIView(_ map: MKMapView, context: Context) {
+        context.coordinator.parent = self
+        if map.mapType != baseMap { map.mapType = baseMap }
 
-        // Update region -- guard against tiny differences to avoid feedback loops
-        let currentCenter = uiView.region.center
-        let threshold = 0.0001
-        if abs(currentCenter.latitude - region.center.latitude) > threshold ||
-           abs(currentCenter.longitude - region.center.longitude) > threshold {
-            uiView.setRegion(region, animated: true)
+        let shown = map.region.center
+        let wanted = visibleArea.center
+        if abs(shown.latitude - wanted.latitude) > Self.centerTolerance
+            || abs(shown.longitude - wanted.longitude) > Self.centerTolerance {
+            map.setRegion(visibleArea, animated: true)
         }
 
-        // Diff annotations
-        let existing = Set(uiView.annotations.compactMap { $0 as? MKPointAnnotation })
-        let incoming = Set(annotations)
-        let toRemove = existing.subtracting(incoming)
-        let toAdd = incoming.subtracting(existing)
-        uiView.removeAnnotations(Array(toRemove))
-        uiView.addAnnotations(Array(toAdd))
+        let onMap = Set(map.annotations.compactMap { item in item as? MKPointAnnotation })
+        let requested = Set(pins)
+        map.removeAnnotations(Array(onMap.subtracting(requested)))
+        map.addAnnotations(Array(requested.subtracting(onMap)))
     }
 
+    @MainActor
     final class Coordinator: NSObject, MKMapViewDelegate {
-        var parent: MapViewRepresentable
-
-        init(_ parent: MapViewRepresentable) { self.parent = parent }
+        init(parent: TrailMapView) { self.parent = parent }
+        var parent: TrailMapView
 
-        func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
-            parent.region = mapView.region
-            parent.onRegionChanged?(mapView.region)
+        func mapView(_ map: MKMapView, regionDidChangeAnimated isAnimated: Bool) {
+            parent.visibleArea = map.region
+            parent.onAreaChanged?(map.region)
         }
 
-        func mapView(
-            _ mapView: MKMapView,
-            viewFor annotation: MKAnnotation
-        ) -> MKAnnotationView? {
-            guard !(annotation is MKUserLocation) else { return nil }
-            let id = "pin"
-            let view = mapView.dequeueReusableAnnotationView(withIdentifier: id)
-                ?? MKMarkerAnnotationView(annotation: annotation, reuseIdentifier: id)
-            view.annotation = annotation
-            return view
+        func mapView(_ map: MKMapView, viewFor marker: MKAnnotation) -> MKAnnotationView? {
+            guard !(marker is MKUserLocation) else { return nil }
+            let reuseID = "trailhead"
+            guard let recycled = map.dequeueReusableAnnotationView(withIdentifier: reuseID) else {
+                return MKMarkerAnnotationView(annotation: marker, reuseIdentifier: reuseID)
+            }
+            recycled.annotation = marker
+            return recycled
         }
     }
 }
 ```
 
-### Usage
+Call site:
 
 ```swift
-struct MapScreen: View {
-    @State private var region = MKCoordinateRegion(
-        center: CLLocationCoordinate2D(latitude: 37.7749, longitude: -122.4194),
-        span: MKCoordinateSpan(latitudeDelta: 0.05, longitudeDelta: 0.05)
+struct TrailScreen: View {
+    @State private var area = MKCoordinateRegion(
+        center: CLLocationCoordinate2D(latitude: 46.55, longitude: 7.98),
+        span: MKCoordinateSpan(latitudeDelta: 0.08, longitudeDelta: 0.08)
     )
-    @State private var mapType: MKMapType = .standard
+    @State private var style = MKMapType.hybrid
 
     var body: some View {
-        MapViewRepresentable(
-            region: $region,
-            mapType: $mapType,
-            annotations: []
-        )
-        .ignoresSafeArea()
+        TrailMapView(visibleArea: $area, baseMap: $style, pins: [])
+            .ignoresSafeArea()
     }
 }
 ```
 
-### Gotchas
-
-- **Region update loops.** The delegate writes to `@Binding region`, which triggers `updateUIView`, which calls `setRegion`, which triggers the delegate again. The threshold guard is essential.
-- **Annotation diffing.** MKMapView does not handle duplicate annotations well. Always diff before adding/removing.
-- **Native SwiftUI Map.** For iOS 17+, prefer the native `Map` view unless you need delegate-level control (custom overlays, clustering, etc.).
+Pitfalls:
 
----
+- The region can loop: the delegate writes the binding, update calls
+  `setRegion`, which fires the delegate again. The tolerance check on the
+  center coordinate is what stops it; do not remove it.
+- `MKMapView` copes poorly with the same annotation added twice. Diff with sets
+  before adding or removing.
+- Prefer native: from iOS 17 the SwiftUI `Map` covers most needs. Keep this
+  wrapper for delegate-level control such as custom overlays or clustering.
 
 ## 2. UITextView Wrapper (Attributed Text)
 
-Wrap `UITextView` for rich text editing with `NSAttributedString` binding and placeholder support.
-
 ```swift
-import SwiftUI
+struct RichNoteEditor: UIViewRepresentable {
+    @Binding var content: NSAttributedString
+    @Binding var isFocused: Bool
+    var hint: String
 
-struct RichTextEditor: UIViewRepresentable {
-    @Binding var attributedText: NSAttributedString
-    var placeholder: String = ""
-    @Binding var isFirstResponder: Bool
+    fileprivate static let hintTag = 999
+    private static let verticalInset: CGFloat = 8
+    private static let horizontalInset: CGFloat = 4
+    private static let minimumHeight: CGFloat = 44
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
     func makeUIView(context: Context) -> UITextView {
-        let textView = UITextView()
-        textView.delegate = context.coordinator
-        textView.font = .preferredFont(forTextStyle: .body)
-        textView.adjustsFontForContentSizeCategory = true
-        textView.backgroundColor = .clear
-        textView.textContainerInset = UIEdgeInsets(top: 8, left: 4, bottom: 8, right: 4)
-
-        // Placeholder label
-        let label = UILabel()
-        label.text = placeholder
-        label.font = .preferredFont(forTextStyle: .body)
-        label.textColor = .placeholderText
-        label.tag = 999
-        label.translatesAutoresizingMaskIntoConstraints = false
-        textView.addSubview(label)
+        let editor = UITextView(frame: .zero)
+        editor.delegate = context.coordinator
+        editor.backgroundColor = .clear
+        editor.adjustsFontForContentSizeCategory = true
+        editor.textContainerInset = UIEdgeInsets(top: Self.verticalInset,
+                                                 left: Self.horizontalInset,
+                                                 bottom: Self.verticalInset,
+                                                 right: Self.horizontalInset)
+
+        let hintLabel = UILabel()
+        hintLabel.tag = Self.hintTag
+        hintLabel.text = hint
+        hintLabel.font = .preferredFont(forTextStyle: .body)
+        hintLabel.textColor = .placeholderText
+        hintLabel.translatesAutoresizingMaskIntoConstraints = false
+        editor.addSubview(hintLabel)
         NSLayoutConstraint.activate([
-            label.topAnchor.constraint(equalTo: textView.topAnchor, constant: 8),
-            label.leadingAnchor.constraint(equalTo: textView.leadingAnchor, constant: 8),
+            hintLabel.leadingAnchor.constraint(equalTo: editor.leadingAnchor, constant: 8),
+            hintLabel.topAnchor.constraint(equalTo: editor.topAnchor, constant: 8)
         ])
-
-        return textView
+        return editor
     }
 
-    func updateUIView(_ uiView: UITextView, context: Context) {
-        if uiView.attributedText != attributedText {
-            uiView.attributedText = attributedText
-        }
-
-        // Update placeholder visibility
-        if let label = uiView.viewWithTag(999) as? UILabel {
-            label.isHidden = !uiView.text.isEmpty
+    func updateUIView(_ editor: UITextView, context: Context) {
+        context.coordinator.parent = self
+        if editor.attributedText != content {
+            editor.attributedText = content
         }
+        editor.viewWithTag(Self.hintTag)?.isHidden = editor.hasText
 
-        // First responder management
-        if isFirstResponder && !uiView.isFirstResponder {
-            uiView.becomeFirstResponder()
-        } else if !isFirstResponder && uiView.isFirstResponder {
-            uiView.resignFirstResponder()
+        switch (isFocused, editor.isFirstResponder) {
+        case (true, false): editor.becomeFirstResponder()
+        case (false, true): editor.resignFirstResponder()
+        default: break
         }
     }
 
-    @available(iOS 16.0, *)
-    func sizeThatFits(
-        _ proposal: ProposedViewSize,
-        uiView: UITextView,
-        context: Context
-    ) -> CGSize? {
-        let width = proposal.width ?? UIView.layoutFittingExpandedSize.width
-        let size = uiView.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude))
-        return CGSize(width: width, height: max(size.height, 44))
+    func sizeThatFits(_ proposal: ProposedViewSize,
+                      uiView editor: UITextView,
+                      context: Context) -> CGSize? {
+        let targetWidth = proposal.width ?? UIView.layoutFittingExpandedSize.width
+        let targetHeight = max(proposal.height ?? Self.minimumHeight, Self.minimumHeight)
+        return CGSize(width: targetWidth, height: targetHeight)
     }
 
+    @MainActor
     final class Coordinator: NSObject, UITextViewDelegate {
-        var parent: RichTextEditor
+        init(parent: RichNoteEditor) { self.parent = parent }
+        var parent: RichNoteEditor
 
-        init(_ parent: RichTextEditor) { self.parent = parent }
-
-        func textViewDidChange(_ textView: UITextView) {
-            parent.attributedText = textView.attributedText ?? NSAttributedString()
-            if let label = textView.viewWithTag(999) as? UILabel {
-                label.isHidden = !textView.text.isEmpty
-            }
+        func textViewDidChange(_ editor: UITextView) {
+            parent.content = editor.attributedText ?? NSAttributedString()
+            editor.viewWithTag(RichNoteEditor.hintTag)?.isHidden = editor.hasText
         }
 
-        func textViewDidBeginEditing(_ textView: UITextView) {
-            parent.isFirstResponder = true
+        func textViewDidBeginEditing(_ editor: UITextView) {
+            parent.isFocused = true
         }
 
-        func textViewDidEndEditing(_ textView: UITextView) {
-            parent.isFirstResponder = false
+        func textViewDidEndEditing(_ editor: UITextView) {
+            parent.isFocused = false
         }
     }
 }
 ```
 
-### Usage
+Call site: `RichNoteEditor(content: $note, isFocused: $editing, hint: "Add a note").frame(minHeight: 100)`.
 
-```swift
-struct NotesEditorView: View {
-    @State private var text = NSAttributedString()
-    @State private var isFocused = false
+Pitfalls:
 
-    var body: some View {
-        RichTextEditor(
-            attributedText: $text,
-            placeholder: "Write something...",
-            isFirstResponder: $isFocused
-        )
-        .frame(minHeight: 100)
-    }
-}
-```
-
-### Gotchas
-
-- **`NSAttributedString` comparison.** The equality check in `updateUIView` is critical -- without it, every keystroke triggers a full re-render loop.
-- **First responder management.** Avoid calling `becomeFirstResponder()` unconditionally in `updateUIView` -- it steals focus from other fields.
-- **iOS 26 alternative.** `TextEditor` in iOS 26 supports `AttributedString` natively. Prefer it unless you need `NSAttributedString` or delegate-level control.
-
----
+- Drop the `NSAttributedString` comparison and every keystroke starts a render
+  loop.
+- Calling `becomeFirstResponder()` unconditionally in update pulls focus away
+  from whatever field the user is typing in; only change focus when the binding
+  and the actual state disagree.
+- Prefer native: on iOS 26 `TextEditor` edits `AttributedString` directly. Wrap
+  only when you need `NSAttributedString` or delegate hooks.
 
 ## 3. AVCaptureVideoPreviewLayer Wrapper
 
-Display a live camera preview. The preview layer requires a `UIView` host.
+The preview layer needs a view to live in. Making the layer the view's backing
+layer is simpler than adding a sublayer.
 
 ```swift
-import SwiftUI
 import AVFoundation
 
-struct CameraPreview: UIViewRepresentable {
-    let session: AVCaptureSession
-
-    func makeUIView(context: Context) -> CameraPreviewUIView {
-        let view = CameraPreviewUIView()
-        view.previewLayer.session = session
-        view.previewLayer.videoGravity = .resizeAspectFill
-        return view
+final class CapturePreviewUIView: UIView {
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        captureLayer.frame = bounds
     }
 
-    func updateUIView(_ uiView: CameraPreviewUIView, context: Context) {
-        // Session is reference type -- no update needed unless swapping sessions
-        if uiView.previewLayer.session !== session {
-            uiView.previewLayer.session = session
-        }
+    override class var layerClass: AnyClass { AVCaptureVideoPreviewLayer.self }
+
+    var captureLayer: AVCaptureVideoPreviewLayer {
+        layer as! AVCaptureVideoPreviewLayer
     }
 }
 
-final class CameraPreviewUIView: UIView {
-    override class var layerClass: AnyClass { AVCaptureVideoPreviewLayer.self }
+struct CapturePreview: UIViewRepresentable {
+    let captureSession: AVCaptureSession
 
-    var previewLayer: AVCaptureVideoPreviewLayer {
-        layer as! AVCaptureVideoPreviewLayer
+    func makeUIView(context: Context) -> CapturePreviewUIView {
+        let preview = CapturePreviewUIView(frame: .zero)
+        preview.captureLayer.videoGravity = .resizeAspectFill
+        preview.captureLayer.session = captureSession
+        return preview
     }
 
-    override func layoutSubviews() {
-        super.layoutSubviews()
-        previewLayer.frame = bounds
+    func updateUIView(_ preview: CapturePreviewUIView, context: Context) {
+        guard preview.captureLayer.session !== captureSession else { return }
+        preview.captureLayer.session = captureSession
     }
 }
 ```
 
-### Usage
+Call site:
 
 ```swift
-struct CameraScreen: View {
-    @State private var cameraManager = CameraManager()
+struct ReceiptCameraScreen: View {
+    @State private var camera = ReceiptCamera()
 
     var body: some View {
-        CameraPreview(session: cameraManager.session)
+        CapturePreview(captureSession: camera.session)
             .ignoresSafeArea()
-            .task { await cameraManager.start() }
+            .task { await camera.start() }
     }
 }
 ```
 
-### Gotchas
+Notes:
 
-- **Use a custom UIView subclass with `layerClass`.** Overriding `layerClass` avoids adding a sublayer and ensures the preview layer resizes automatically with the view.
-- **Session management belongs outside the representable.** Create and manage `AVCaptureSession` in a separate model. The representable only displays it.
-- **Orientation.** Set `previewLayer.connection?.videoRotationAngle` if supporting device rotation.
-
----
+- The `layerClass` override means no extra sublayer, and the layer resizes with
+  the view automatically. The forced cast is safe because `layerClass`
+  guarantees the type.
+- Build and run the `AVCaptureSession` in a separate model object (here
+  `ReceiptCamera`). The representable only shows it.
+- For rotation, set `captureLayer.connection?.videoRotationAngle`.
 
 ## 4. PHPickerViewController Wrapper
 
-Multi-select photo picker that loads selected images asynchronously.
-
 ```swift
-import SwiftUI
 import PhotosUI
 
-struct PhotoPicker: UIViewControllerRepresentable {
-    @Binding var selectedImages: [UIImage]
-    var selectionLimit: Int = 0  // 0 = unlimited
-    @Environment(\.dismiss) private var dismiss
+struct GalleryPicker: UIViewControllerRepresentable {
+    @Environment(\.dismiss) var close
+    @Binding var picked: [UIImage]
+    var maxSelection: Int
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
     func makeUIViewController(context: Context) -> PHPickerViewController {
-        var config = PHPickerConfiguration(photoLibrary: .shared())
-        config.filter = .images
-        config.selectionLimit = selectionLimit
-        config.preferredAssetRepresentationMode = .current
-
-        let picker = PHPickerViewController(configuration: config)
-        picker.delegate = context.coordinator
-        return picker
+        var options = PHPickerConfiguration(photoLibrary: .shared())
+        options.selectionLimit = maxSelection
+        options.preferredAssetRepresentationMode = .current
+        options.filter = .images
+        let sheet = PHPickerViewController(configuration: options)
+        sheet.delegate = context.coordinator
+        return sheet
     }
 
-    func updateUIViewController(_ uiViewController: PHPickerViewController, context: Context) {
-        // Nothing to update -- configuration is immutable after creation
+    func updateUIViewController(_ sheet: PHPickerViewController, context: Context) {
+        context.coordinator.parent = self
     }
 
+    @MainActor
     final class Coordinator: NSObject, PHPickerViewControllerDelegate {
-        let parent: PhotoPicker
-
-        init(_ parent: PhotoPicker) { self.parent = parent }
-
-        func picker(
-            _ picker: PHPickerViewController,
-            didFinishPicking results: [PHPickerResult]
-        ) {
-            parent.dismiss()
-
-            guard !results.isEmpty else { return }
+        init(parent: GalleryPicker) { self.parent = parent }
+        var parent: GalleryPicker
 
+        func picker(_ sheet: PHPickerViewController, didFinishPicking picks: [PHPickerResult]) {
+            parent.close()
+            if picks.isEmpty { return }
+            let providers = picks.map(\.itemProvider)
             Task { @MainActor in
                 var images: [UIImage] = []
-                for result in results {
-                    if let image = await loadImage(from: result.itemProvider) {
-                        images.append(image)
-                    }
+                for provider in providers {
+                    if let image = await Self.loadImage(provider) { images.append(image) }
                 }
-                parent.selectedImages = images
+                self.parent.picked = images
             }
         }
 
-        private func loadImage(from provider: NSItemProvider) async -> UIImage? {
-            await withCheckedContinuation { continuation in
-                if provider.canLoadObject(ofClass: UIImage.self) {
-                    provider.loadObject(ofClass: UIImage.self) { image, _ in
-                        continuation.resume(returning: image as? UIImage)
-                    }
-                } else {
-                    continuation.resume(returning: nil)
+        private static func loadImage(_ provider: NSItemProvider) async -> UIImage? {
+            guard provider.canLoadObject(ofClass: UIImage.self) else { return nil }
+            return await withCheckedContinuation { continuation in
+                provider.loadObject(ofClass: UIImage.self) { object, _ in
+                    continuation.resume(returning: object as? UIImage)
                 }
             }
         }
@@ -365,584 +329,406 @@ struct PhotoPicker: UIViewControllerRepresentable {
 }
 ```
 
-### Usage
+A `selectionLimit` of 0 means no limit. There is nothing to push in the update
+method beyond the parent refresh, because a picker's configuration is fixed
+once the controller exists.
 
-```swift
-struct ImagePickerDemo: View {
-    @State private var images: [UIImage] = []
-    @State private var showPicker = false
+Call site:
 
-    var body: some View {
-        VStack {
-            ScrollView(.horizontal) {
-                HStack {
-                    ForEach(images.indices, id: \.self) { i in
-                        Image(uiImage: images[i])
-                            .resizable()
-                            .scaledToFill()
-                            .frame(width: 100, height: 100)
-                            .clipShape(.rect(cornerRadius: 8))
-                    }
-                }
-            }
-            Button("Pick Photos") { showPicker = true }
-        }
-        .sheet(isPresented: $showPicker) {
-            PhotoPicker(selectedImages: $images, selectionLimit: 5)
-        }
-    }
+```swift
+.sheet(isPresented: $showingPicker) {
+    GalleryPicker(picked: $attachments, maxSelection: 5)
 }
-```
 
-### Gotchas
+// thumbnail grid cell
+Image(uiImage: image)
+    .resizable()
+    .scaledToFill()
+    .frame(width: 96, height: 96)
+    .clipShape(.rect(cornerRadius: 10))
+```
 
-- **Always dismiss in the delegate.** `picker(_:didFinishPicking:)` is called for both selection and cancellation (with empty results). Dismiss in both cases.
-- **Async image loading.** `NSItemProvider.loadObject` is completion-based. Wrap in `withCheckedContinuation` for async/await usage. Load images after dismissal to avoid blocking the picker UI.
-- **iOS 17 alternative.** `PhotosUI.PhotosPicker` is a native SwiftUI view. Prefer it unless you need custom picker UI or advanced filtering.
+Pitfalls:
 
----
+- `didFinishPicking` fires for a selection and for a cancel; a cancel delivers
+  an empty array. Dismiss in both cases.
+- Load images after dismissing so the picker does not stall.
+- Prefer native: `PhotosPicker` from PhotosUI (iOS 17 guidance) covers ordinary
+  picking. Reach for `PHPickerViewController` when you need your own picker
+  presentation or filters the native control lacks.
 
 ## 5. MFMailComposeViewController Wrapper
 
-Present the system email composer with pre-filled fields and handle the result.
-
 ```swift
-import SwiftUI
 import MessageUI
 
-struct MailComposer: UIViewControllerRepresentable {
-    let subject: String
-    let recipients: [String]
-    let body: String
-    var isHTML: Bool = false
-    var onResult: ((MFMailComposeResult) -> Void)?
-    @Environment(\.dismiss) private var dismiss
+struct SupportMailView: UIViewControllerRepresentable {
+    @Environment(\.dismiss) var close
+    var subject: String
+    var recipients: [String]
+    var message: String
+    var completion: (MFMailComposeResult) -> Void
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
     func makeUIViewController(context: Context) -> MFMailComposeViewController {
-        let controller = MFMailComposeViewController()
-        controller.mailComposeDelegate = context.coordinator
-        controller.setSubject(subject)
-        controller.setToRecipients(recipients)
-        controller.setMessageBody(body, isHTML: isHTML)
-        return controller
+        let composer = MFMailComposeViewController()
+        composer.setToRecipients(recipients)
+        composer.setSubject(subject)
+        composer.setMessageBody(message, isHTML: false)
+        composer.mailComposeDelegate = context.coordinator
+        return composer
     }
 
-    func updateUIViewController(_ uiViewController: MFMailComposeViewController, context: Context) {
-        // Cannot update mail compose after presentation
+    func updateUIViewController(_ composer: MFMailComposeViewController, context: Context) {
+        context.coordinator.parent = self
     }
 
-    final class Coordinator: NSObject, MFMailComposeViewControllerDelegate {
-        let parent: MailComposer
-
-        init(_ parent: MailComposer) { self.parent = parent }
+    @MainActor
+    final class Coordinator: NSObject, @preconcurrency MFMailComposeViewControllerDelegate {
+        init(parent: SupportMailView) { self.parent = parent }
+        var parent: SupportMailView
 
-        func mailComposeController(
-            _ controller: MFMailComposeViewController,
-            didFinishWith result: MFMailComposeResult,
-            error: Error?
-        ) {
-            parent.onResult?(result)
-            parent.dismiss()
+        func mailComposeController(_ composer: MFMailComposeViewController,
+                                   didFinishWith outcome: MFMailComposeResult,
+                                   error failure: Error?) {
+            parent.completion(outcome)
+            parent.close()
         }
     }
 }
 ```
 
-### Usage
+Present it only after `MFMailComposeViewController.canSendMail()` returns true:
 
 ```swift
-struct FeedbackView: View {
-    @State private var showMail = false
-
-    var body: some View {
-        Button("Send Feedback") {
-            guard MFMailComposeViewController.canSendMail() else { return }
-            showMail = true
-        }
-        .sheet(isPresented: $showMail) {
-            MailComposer(
-                subject: "App Feedback",
-                recipients: ["support@example.com"],
-                body: "I have feedback about..."
-            ) { result in
-                print("Mail result: \(result.rawValue)")
-            }
-        }
-    }
+Button("Contact support") {
+    showingMail = MFMailComposeViewController.canSendMail()
+}
+.sheet(isPresented: $showingMail) {
+    SupportMailView(subject: "Order help", recipients: ["help@example.com"],
+                    message: "", completion: { _ in })
 }
 ```
 
-### Gotchas
+Notes:
 
-- **Check `canSendMail()` before presenting.** The app crashes if `MFMailComposeViewController` is presented on a device with no mail account configured.
-- **Cannot update after presentation.** `updateUIViewController` is intentionally empty -- the mail compose API does not support changing fields after the controller is shown.
-- **The delegate protocol name is `MFMailComposeViewControllerDelegate`**, not `MFMailComposeDelegate`.
-
----
+- Presenting the composer on a device without a configured mail account
+  crashes. Always check `canSendMail()` first.
+- Subject, recipients and body are fixed once the composer is on screen, so
+  the update method does nothing beyond refreshing `parent`.
+- The delegate protocol is `MFMailComposeViewControllerDelegate`. A type named
+  `MFMailComposeDelegate` does not exist, and code that uses it will not
+  compile.
 
 ## 6. UIActivityViewController Wrapper (Share Sheet)
 
-Present the system share sheet. This is a `UIViewControllerRepresentable` because `UIActivityViewController` is a controller, not a view.
+The share sheet is a view controller, so it needs
+`UIViewControllerRepresentable`.
 
 ```swift
-import SwiftUI
-
-struct ShareSheet: UIViewControllerRepresentable {
-    let items: [Any]
-    var activities: [UIActivity]? = nil
-    var excludedTypes: [UIActivity.ActivityType]? = nil
+struct ActivitySheet: UIViewControllerRepresentable {
+    var items: [Any]
+    var extraActivities: [UIActivity]? = nil
+    var hiddenTypes: [UIActivity.ActivityType] = []
 
     func makeUIViewController(context: Context) -> UIActivityViewController {
-        let controller = UIActivityViewController(
-            activityItems: items,
-            applicationActivities: activities
-        )
-        controller.excludedActivityTypes = excludedTypes
-        return controller
+        let sheet = UIActivityViewController(activityItems: items,
+                                             applicationActivities: extraActivities)
+        sheet.excludedActivityTypes = hiddenTypes
+        return sheet
     }
 
-    func updateUIViewController(_ uiViewController: UIActivityViewController, context: Context) {
-        // Cannot update after presentation
-    }
+    func updateUIViewController(_ sheet: UIActivityViewController, context: Context) {}
 }
 ```
 
-### Usage
+Call site:
 
 ```swift
-struct ContentView: View {
-    @State private var showShare = false
-
-    var body: some View {
-        Button("Share") { showShare = true }
-            .sheet(isPresented: $showShare) {
-                ShareSheet(items: ["Check out this app!", URL(string: "https://example.com")!])
-                    .presentationDetents([.medium])
-            }
-    }
+.sheet(isPresented: $sharing) {
+    ActivitySheet(items: [exportURL], hiddenTypes: [.assignToContact])
+        .presentationDetents([.medium])
 }
 ```
 
-### Gotchas
+Notes:
 
-- **Present via `.sheet`.** Do not try to use `UIActivityViewController` as an inline view -- it is a modal controller.
-- **iPad requires `popoverPresentationController`.** When using on iPad outside of `.sheet`, set the source view/rect on the popover controller. SwiftUI's `.sheet` handles this automatically.
-- **iOS 16+ alternative.** `ShareLink` is a native SwiftUI view for Transferable items. Prefer it for simple sharing.
-
----
+- Present it with `.sheet`. It does not work as an inline view.
+- On iPad, presenting outside a `.sheet` requires setting the
+  `popoverPresentationController` source view and rect. `.sheet` takes care of
+  that for you.
+- Prefer native: from iOS 16 `ShareLink` shares `Transferable` items with no
+  wrapper for the simple cases.
 
 ## 7. UISearchBar Wrapper
 
-Wrap `UISearchBar` with delegate-based callbacks, debounce support, and cancel button handling.
-
 ```swift
-import SwiftUI
-import Combine
-
-struct SearchBar: UIViewRepresentable {
-    @Binding var text: String
-    var placeholder: String = "Search"
-    var onSearch: ((String) -> Void)?
-    var onCancel: (() -> Void)?
+struct DirectorySearchBar: UIViewRepresentable {
+    @Binding var query: String
+    var prompt: String
+    var onSearch: (String) -> Void
+    var onClear: () -> Void
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
     func makeUIView(context: Context) -> UISearchBar {
-        let searchBar = UISearchBar()
-        searchBar.delegate = context.coordinator
-        searchBar.placeholder = placeholder
-        searchBar.searchBarStyle = .minimal
-        searchBar.autocapitalizationType = .none
-        return searchBar
+        let field = UISearchBar(frame: .zero)
+        field.placeholder = prompt
+        field.searchBarStyle = .minimal
+        field.autocapitalizationType = .none
+        field.delegate = context.coordinator
+        return field
     }
 
-    func updateUIView(_ uiView: UISearchBar, context: Context) {
-        if uiView.text != text {
-            uiView.text = text
-        }
+    func updateUIView(_ field: UISearchBar, context: Context) {
+        context.coordinator.parent = self
+        if field.text != query { field.text = query }
     }
 
+    @MainActor
     final class Coordinator: NSObject, UISearchBarDelegate {
-        var parent: SearchBar
-        private var debounceTask: Task<Void, Never>?
-
-        init(_ parent: SearchBar) { self.parent = parent }
-
-        func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
-            parent.text = searchText
-            searchBar.showsCancelButton = !searchText.isEmpty
-
-            // Debounce search
-            debounceTask?.cancel()
-            debounceTask = Task { @MainActor in
-                try? await Task.sleep(for: .milliseconds(300))
+        init(parent: DirectorySearchBar) { self.parent = parent }
+        var parent: DirectorySearchBar
+
+        private var pending: Task<Void, Never>?
+        private static let quietPeriod: Duration = .milliseconds(300)
+
+        func searchBar(_ field: UISearchBar, textDidChange typed: String) {
+            parent.query = typed
+            field.setShowsCancelButton(!typed.isEmpty, animated: true)
+            pending?.cancel()
+            pending = Task { @MainActor [weak self] in
+                do {
+                    try await Task.sleep(for: Coordinator.quietPeriod)
+                } catch {
+                    return
+                }
                 guard !Task.isCancelled else { return }
-                parent.onSearch?(searchText)
+                self?.parent.onSearch(typed)
             }
         }
 
-        func searchBarSearchButtonClicked(_ searchBar: UISearchBar) {
-            debounceTask?.cancel()
-            parent.onSearch?(parent.text)
-            searchBar.resignFirstResponder()
+        func searchBarSearchButtonClicked(_ field: UISearchBar) {
+            pending?.cancel()
+            parent.onSearch(field.text ?? "")
+            field.resignFirstResponder()
         }
 
-        func searchBarCancelButtonClicked(_ searchBar: UISearchBar) {
-            parent.text = ""
-            parent.onCancel?()
-            searchBar.resignFirstResponder()
-            searchBar.showsCancelButton = false
-        }
-    }
-}
-```
-
-### Usage
-
-```swift
-struct SearchableList: View {
-    @State private var query = ""
-    @State private var results: [String] = []
-
-    var body: some View {
-        VStack(spacing: 0) {
-            SearchBar(text: $query, placeholder: "Search items") { text in
-                results = performSearch(text)
-            }
-            List(results, id: \.self) { Text($0) }
+        func searchBarCancelButtonClicked(_ field: UISearchBar) {
+            parent.query = ""
+            parent.onClear()
+            field.resignFirstResponder()
+            field.setShowsCancelButton(false, animated: true)
         }
     }
 }
 ```
 
-### Gotchas
-
-- **Native `.searchable` modifier.** Prefer SwiftUI's `.searchable(text:)` modifier for standard search patterns. Use this wrapper only when you need precise control over search bar appearance or delegate timing.
-- **Debounce with `Task.sleep`.** Cancel the previous task before starting a new one to debounce. `Combine` is not needed.
-- **Cancel button state.** Toggle `showsCancelButton` in the delegate, not in `updateUIView`, to avoid layout jumps.
+Notes:
 
----
+- The debounce is a stored `Task` that is cancelled on each keystroke and
+  sleeps 300 ms before searching. No Combine is needed; `Task.sleep` plus a
+  cancellation check does the job.
+- The search button cancels any pending debounce, searches at once and drops
+  the keyboard. The cancel button clears the query, reports it, drops the
+  keyboard and hides itself.
+- Show and hide the cancel button from the delegate, not from `updateUIView`,
+  or the bar jumps during layout.
+- Prefer native: `.searchable(text:)` for standard search. Wrap `UISearchBar`
+  only when you need exact appearance control or delegate timing.
 
 ## 8. PDFView Wrapper (PDFKit)
 
-Display PDF documents in SwiftUI using `PDFView` from PDFKit. Supports loading from URL, Data, or file path, with configurable display mode and auto-scaling.
+`PDFView` is a `UIView`, so this is a `UIViewRepresentable`.
 
 ```swift
-import SwiftUI
 import PDFKit
 
-struct PDFViewer: UIViewRepresentable {
-    let document: PDFDocument?
-    var displayMode: PDFDisplayMode = .singlePageContinuous
-    var autoScales: Bool = true
-    var displayDirection: PDFDisplayDirection = .vertical
-    var pageShadowsEnabled: Bool = true
+struct ManualPDFView: UIViewRepresentable {
+    let file: PDFDocument?
+    @Binding var pageIndex: Int
+    var layout: PDFDisplayMode = .singlePageContinuous
+    var direction: PDFDisplayDirection = .vertical
+    var fitsWidth = true
+    var showsPageShadows = true
 
-    func makeUIView(context: Context) -> PDFView {
-        let pdfView = PDFView()
-        pdfView.displayMode = displayMode
-        pdfView.displayDirection = displayDirection
-        pdfView.autoScales = autoScales
-        pdfView.pageShadowsEnabled = pageShadowsEnabled
-        pdfView.document = document
-        return pdfView
-    }
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
-    func updateUIView(_ uiView: PDFView, context: Context) {
-        // Update document if it changed (reference comparison)
-        if uiView.document !== document {
-            uiView.document = document
-        }
-
-        if uiView.displayMode != displayMode {
-            uiView.displayMode = displayMode
-        }
+    func makeUIView(context: Context) -> PDFView {
+        let viewer = PDFView(frame: .zero)
+        viewer.document = file
+        viewer.displayMode = layout
+        viewer.displayDirection = direction
+        viewer.autoScales = fitsWidth
+        viewer.pageShadowsEnabled = showsPageShadows
 
-        if uiView.autoScales != autoScales {
-            uiView.autoScales = autoScales
-        }
+        let center = NotificationCenter.default
+        center.addObserver(context.coordinator,
+                           selector: #selector(Coordinator.pageDidChange(_:)),
+                           name: .PDFViewPageChanged,
+                           object: viewer)
+        return viewer
     }
-}
-```
 
-### Convenience Initializers
+    func updateUIView(_ viewer: PDFView, context: Context) {
+        context.coordinator.parent = self
+        if viewer.document !== file { viewer.document = file }
+        if viewer.displayMode != layout { viewer.displayMode = layout }
+        if viewer.autoScales != fitsWidth { viewer.autoScales = fitsWidth }
 
-```swift
-extension PDFViewer {
-    /// Load a PDF from a URL (local file or remote).
-    init(url: URL, displayMode: PDFDisplayMode = .singlePageContinuous) {
-        self.document = PDFDocument(url: url)
-        self.displayMode = displayMode
+        guard let pdf = viewer.document,
+              let target = pdf.page(at: pageIndex),
+              viewer.currentPage != target else { return }
+        viewer.go(to: target)
     }
 
-    /// Load a PDF from raw data.
-    init(data: Data, displayMode: PDFDisplayMode = .singlePageContinuous) {
-        self.document = PDFDocument(data: data)
-        self.displayMode = displayMode
+    static func dismantleUIView(_ viewer: PDFView, coordinator: Coordinator) {
+        NotificationCenter.default.removeObserver(coordinator,
+                                                  name: .PDFViewPageChanged,
+                                                  object: viewer)
     }
-}
-```
 
-### Usage
-
-```swift
-struct DocumentView: View {
-    let pdfURL: URL
+    @MainActor
+    final class Coordinator: NSObject {
+        init(parent: ManualPDFView) { self.parent = parent }
+        var parent: ManualPDFView
 
-    var body: some View {
-        PDFViewer(url: pdfURL)
-            .ignoresSafeArea(edges: .bottom)
-            .navigationTitle("Document")
-            .navigationBarTitleDisplayMode(.inline)
+        @objc func pageDidChange(_ note: Notification) {
+            guard let viewer = note.object as? PDFView,
+                  let pdf = viewer.document,
+                  let page = viewer.currentPage else { return }
+            let position = pdf.index(for: page)
+            if position != parent.pageIndex { parent.pageIndex = position }
+        }
     }
 }
 ```
 
-### With Async Loading
+`PDFDocument(url:)` and `PDFDocument(data:)` create documents from a file URL
+or from bytes. For remote files, load asynchronously:
 
 ```swift
-struct RemotePDFView: View {
-    let url: URL
-    @State private var document: PDFDocument?
-    @State private var isLoading = true
-    @State private var errorMessage: String?
+struct RemoteManualScreen: View {
+    let source: URL
+    @State private var loaded: PDFDocument?
+    @State private var loadFailed = false
+    @State private var page = 0
 
     var body: some View {
-        Group {
-            if let document {
-                PDFViewer(document: document)
-            } else if isLoading {
-                ProgressView("Loading PDF...")
-            } else if let errorMessage {
-                ContentUnavailableView(
-                    "Could Not Load PDF",
-                    systemImage: "doc.text.fill",
-                    description: Text(errorMessage)
-                )
+        ZStack {
+            if let loaded {
+                ManualPDFView(file: loaded, pageIndex: $page)
+            } else if loadFailed {
+                ContentUnavailableView("Manual unavailable",
+                                       systemImage: "doc.questionmark")
+            } else {
+                ProgressView()
             }
         }
         .task {
             do {
-                let (data, _) = try await URLSession.shared.data(from: url)
-                document = PDFDocument(data: data)
+                let (bytes, _) = try await URLSession.shared.data(from: source)
+                loaded = PDFDocument(data: bytes)
             } catch {
-                errorMessage = error.localizedDescription
-            }
-            isLoading = false
-        }
-    }
-}
-```
-
-### PDFView with Page Navigation
-
-```swift
-struct NavigablePDFView: UIViewRepresentable {
-    let document: PDFDocument?
-    @Binding var currentPageIndex: Int
-
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
-
-    func makeUIView(context: Context) -> PDFView {
-        let pdfView = PDFView()
-        pdfView.displayMode = .singlePageContinuous
-        pdfView.autoScales = true
-        pdfView.document = document
-
-        NotificationCenter.default.addObserver(
-            context.coordinator,
-            selector: #selector(Coordinator.pageChanged(_:)),
-            name: .PDFViewPageChanged,
-            object: pdfView
-        )
-
-        return pdfView
-    }
-
-    func updateUIView(_ uiView: PDFView, context: Context) {
-        if uiView.document !== document {
-            uiView.document = document
-        }
-
-        // Navigate to page if binding changed externally
-        if let doc = uiView.document,
-           let page = doc.page(at: currentPageIndex),
-           uiView.currentPage != page {
-            uiView.go(to: page)
-        }
-    }
-
-    static func dismantleUIView(_ uiView: PDFView, coordinator: Coordinator) {
-        NotificationCenter.default.removeObserver(coordinator)
-    }
-
-    final class Coordinator: NSObject {
-        var parent: NavigablePDFView
-
-        init(_ parent: NavigablePDFView) { self.parent = parent }
-
-        @objc func pageChanged(_ notification: Notification) {
-            guard let pdfView = notification.object as? PDFView,
-                  let currentPage = pdfView.currentPage,
-                  let document = pdfView.document else { return }
-            let index = document.index(for: currentPage)
-            if parent.currentPageIndex != index {
-                parent.currentPageIndex = index
+                loadFailed = true
             }
         }
     }
 }
 ```
 
-### Gotchas
-
-- **`PDFView` inherits from `UIView`.** Use `UIViewRepresentable`, not `UIViewControllerRepresentable`.
-- **Document is a reference type.** Use `!==` for identity comparison in `updateUIView` to avoid unnecessary reloads.
-- **Page change notifications.** Use `NotificationCenter` with `.PDFViewPageChanged` -- `PDFView` does not use a delegate pattern for page changes.
-- **Remove observers in `dismantleUIView`.** Failing to remove `NotificationCenter` observers causes crashes after the view is removed.
-- **`autoScales`** fits the PDF to the view width. Disable it if you want the user to start at a specific zoom level.
-- **Thread safety.** `PDFDocument` loading can be expensive. Load asynchronously and assign on the main thread.
+`ContentUnavailableView` needs iOS 17; on an iOS 16 target show a `Label` or
+`Text` there instead.
 
-> **Docs:** [PDFView](https://sosumi.ai/documentation/pdfkit/pdfview) | [PDFKit](https://sosumi.ai/documentation/pdfkit)
+Notes:
 
----
+- `PDFView` has no delegate callback for page changes. Observe
+  `.PDFViewPageChanged` instead, and remove the observer in `dismantleUIView`;
+  a leftover observer can crash after the view is gone.
+- `autoScales` fits the page width. Turn it off when the document should open
+  at a zoom factor you choose.
+- Building a `PDFDocument` can be expensive. Load it off the main path and
+  assign it on the main actor.
+- Apple: [PDFView](https://developer.apple.com/documentation/pdfkit/pdfview),
+  [PDFKit](https://developer.apple.com/documentation/pdfkit)
 
 ## 9. MFMessageComposeViewController Wrapper
 
-Present the system SMS/MMS composer with pre-filled recipients, body, and optional attachments. Companion to Recipe 6 (MFMailComposeViewController).
+This is the text-message counterpart to the mail wrapper in
+[recipe 5](#5-mfmailcomposeviewcontroller-wrapper), and it follows the same
+structure.
 
 ```swift
-import SwiftUI
 import MessageUI
+import UniformTypeIdentifiers
 
-struct MessageComposer: UIViewControllerRepresentable {
-    let recipients: [String]
-    let body: String
-    var attachments: [MessageAttachment] = []
-    var onResult: ((MessageComposeResult) -> Void)?
-    @Environment(\.dismiss) private var dismiss
+struct OutgoingAttachment {
+    let payload: Data
+    let uti: String
+    let name: String
+}
 
-    func makeCoordinator() -> Coordinator { Coordinator(self) }
+struct InviteMessageView: UIViewControllerRepresentable {
+    @Environment(\.dismiss) var close
+    var recipients: [String]
+    var text: String
+    var attachments: [OutgoingAttachment] = []
+    var completion: (MessageComposeResult) -> Void
 
-    func makeUIViewController(context: Context) -> MFMessageComposeViewController {
-        let controller = MFMessageComposeViewController()
-        controller.messageComposeDelegate = context.coordinator
-        controller.recipients = recipients
-        controller.body = body
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
 
+    func makeUIViewController(context: Context) -> MFMessageComposeViewController {
+        let composer = MFMessageComposeViewController()
+        composer.recipients = recipients
+        composer.body = text
+        composer.messageComposeDelegate = context.coordinator
+        guard MFMessageComposeViewController.canSendAttachments() else { return composer }
         for attachment in attachments {
-            controller.addAttachmentData(
-                attachment.data,
-                typeIdentifier: attachment.typeIdentifier,
-                filename: attachment.filename
-            )
+            composer.addAttachmentData(attachment.payload,
+                                       typeIdentifier: attachment.uti,
+                                       filename: attachment.name)
         }
-
-        return controller
+        return composer
     }
 
-    func updateUIViewController(
-        _ uiViewController: MFMessageComposeViewController,
-        context: Context
-    ) {
-        // Cannot update message compose after presentation
+    func updateUIViewController(_ composer: MFMessageComposeViewController, context: Context) {
+        context.coordinator.parent = self
     }
 
-    final class Coordinator: NSObject, MFMessageComposeViewControllerDelegate {
-        let parent: MessageComposer
-
-        init(_ parent: MessageComposer) { self.parent = parent }
-
-        func messageComposeViewController(
-            _ controller: MFMessageComposeViewController,
-            didFinishWith result: MessageComposeResult
-        ) {
-            parent.onResult?(result)
-            parent.dismiss()
-        }
-    }
-}
+    @MainActor
+    final class Coordinator: NSObject, @preconcurrency MFMessageComposeViewControllerDelegate {
+        init(parent: InviteMessageView) { self.parent = parent }
+        var parent: InviteMessageView
 
-struct MessageAttachment {
-    let data: Data
-    let typeIdentifier: String // UTI, e.g., "public.jpeg"
-    let filename: String
-}
-```
-
-### Usage
-
-```swift
-struct InviteView: View {
-    @State private var showMessage = false
-
-    var body: some View {
-        Button("Send Invite via SMS") {
-            guard MFMessageComposeViewController.canSendText() else { return }
-            showMessage = true
-        }
-        .sheet(isPresented: $showMessage) {
-            MessageComposer(
-                recipients: ["+1234567890"],
-                body: "Join me on this app!"
-            ) { result in
-                switch result {
-                case .sent:
-                    print("Message sent")
-                case .cancelled:
-                    print("User cancelled")
-                case .failed:
-                    print("Message failed")
-                @unknown default:
-                    break
-                }
-            }
-        }
-    }
-}
-```
-
-### With Image Attachment
-
-```swift
-struct SharePhotoView: View {
-    @State private var showMessage = false
-    let image: UIImage
-
-    var body: some View {
-        Button("Send Photo") {
-            guard MFMessageComposeViewController.canSendText(),
-                  MFMessageComposeViewController.canSendAttachments() else {
-                return
+        func messageComposeViewController(_ composer: MFMessageComposeViewController,
+                                          didFinishWith outcome: MessageComposeResult) {
+            switch outcome {
+            case .sent, .cancelled, .failed:
+                parent.completion(outcome)
+            @unknown default:
+                parent.completion(outcome)
             }
-            showMessage = true
-        }
-        .sheet(isPresented: $showMessage) {
-            MessageComposer(
-                recipients: [],
-                body: "Check out this photo!",
-                attachments: [
-                    MessageAttachment(
-                        data: image.jpegData(compressionQuality: 0.8) ?? Data(),
-                        typeIdentifier: "public.jpeg",
-                        filename: "photo.jpg"
-                    )
-                ]
-            )
+            parent.close()
         }
     }
 }
 ```
 
-### Gotchas
-
-- **Check `canSendText()` before presenting.** The app crashes if `MFMessageComposeViewController` is presented on a device that cannot send texts (e.g., iPod touch without iMessage).
-- **Check `canSendAttachments()` before adding attachments.** Not all devices or carriers support MMS attachments.
-- **The delegate protocol is `MFMessageComposeViewControllerDelegate`**, not `MFMessageComposeDelegate`. It has a single required method.
-- **Cannot update after presentation.** Like `MFMailComposeViewController`, the message composer API does not support changing fields after the controller is shown.
-- **iMessage vs. SMS.** The controller automatically uses iMessage when available. You cannot force one protocol over the other.
-- **Simulator limitation.** `canSendText()` returns `false` on the simulator. Test on a physical device.
-
-> **Docs:** [MFMessageComposeViewController](https://sosumi.ai/documentation/messageui/mfmessagecomposeviewcontroller) | [MFMessageComposeViewControllerDelegate](https://sosumi.ai/documentation/messageui/mfmessagecomposeviewcontrollerdelegate)
+Attaching a photo: `photo.jpegData(compressionQuality: 0.8)` supplies the
+bytes, `UTType.jpeg.identifier` (the string `public.jpeg`) the type, and a name
+such as `invite.jpg` the filename.
+
+Notes:
+
+- Check `MFMessageComposeViewController.canSendText()` before presenting; if it
+  is false, presenting crashes. Check `canSendAttachments()` before adding
+  attachments, because MMS support varies by device and carrier.
+- `MFMessageComposeViewControllerDelegate` has one required method,
+  `messageComposeViewController(_:didFinishWith:)`.
+- As with mail in recipe 5, the fields cannot be edited after presentation.
+- The system chooses iMessage when it is available. The app cannot force SMS or
+  iMessage.
+- `canSendText()` returns false in the Simulator, so test on a device.
+- Apple: [MFMessageComposeViewController](https://developer.apple.com/documentation/messageui/mfmessagecomposeviewcontroller),
+  [MFMessageComposeViewControllerDelegate](https://developer.apple.com/documentation/messageui/mfmessagecomposeviewcontrollerdelegate)