@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/passkit-wallet/evals/evals.json

@@ -3,49 +3,50 @@
   "evals": [
     {
       "id": 1,
-      "prompt": "I'm adding Apple Pay checkout to a SwiftUI store for physical products. Show the capability setup, availability check, Apple Pay button, PKPaymentRequest with shipping, payment presentation, and authorization delegate shape. Include App Review boundary notes for StoreKit.",
-      "expected_output": "A source-grounded PassKit checkout plan that uses Apple Pay for physical goods, builds a valid payment request, handles authorization through a retained controller/delegate, and keeps StoreKit for digital goods.",
+      "name": "apple-pay-checkout-setup",
+      "prompt": "We sell bicycle parts and want Apple Pay in our SwiftUI app. Right now we draw our own black button with the Apple logo, compute prices as Double, present PKPaymentAuthorizationController from a local variable, and dismiss it inside didAuthorizePayment. A teammate also suggests using StoreKit instead. Walk us through a correct setup.",
+      "expected_output": "Lists the capability, Merchant ID, Payment Processing Certificate and entitlement; checks canMakePayments and canMakePayments(usingNetworks:capabilities:); uses PayWithApplePayButton or PKPaymentButton; uses NSDecimalNumber for items and shipping with the business-name total last; retains the controller and clears it after dismissing in didFinish; sends the token to the server and replies with PKPaymentAuthorizationResult; keeps physical goods on Apple Pay rather than StoreKit.",
       "files": [],
       "assertions": [
-        "States that Apple Pay capability, Merchant ID, payment processing certificate, and merchant entitlement must be configured.",
-        "Checks `PKPaymentAuthorizationController.canMakePayments()` and `canMakePayments(usingNetworks:capabilities:)` before presenting Apple Pay UI.",
-        "Uses system-provided `PayWithApplePayButton` or `PKPaymentButton` rather than a custom Apple Pay button.",
-        "Constructs payment summary items and shipping methods with `NSDecimalNumber`, not `Double` money literals.",
-        "Keeps the final `paymentSummaryItems` entry as the total Pay-line item with the merchant/business name.",
-        "Retains `PKPaymentAuthorizationController` while presented, assigns its weak delegate, and clears the retained controller after dismissal.",
-        "Sends `payment.token` or `payment.token.paymentData` to a payment processor/server and returns `PKPaymentAuthorizationResult` through the delegate handler.",
-        "Explains that StoreKit is for virtual goods, app features, and digital-content subscriptions while PassKit covers physical goods, real-world services, donations, and eligible recurring payments."
+        "Covers the Apple Pay capability, a Merchant ID, the Payment Processing Certificate and the merchant entitlement",
+        "Performs both canMakePayments checks before showing the button",
+        "Replaces the custom button with PayWithApplePayButton or PKPaymentButton",
+        "Uses NSDecimalNumber for summary items and shipping, with a final total labelled with the business name",
+        "Stores the controller (its delegate is weak), dismisses only in paymentAuthorizationControllerDidFinish and then releases it",
+        "Sends payment.token to the server and completes with a PKPaymentAuthorizationResult carrying errors on failure",
+        "Explains that physical goods use Apple Pay and StoreKit is for digital goods"
       ]
     },
     {
       "id": 2,
-      "prompt": "Review this Wallet pass plan: load a pkpass, show a normal SwiftUI Button that says Add to Wallet, use PKPassLibrary.isPassLibraryAvailable to decide if the device can add it, list all Wallet passes with passes(), and update the pass later with a new serial number. Fix it.",
-      "expected_output": "A correction-focused Wallet pass answer that uses system Add to Wallet UI, signed-pass checks, correct add-pass availability, pass-library access limits, and stable pass identifiers for updates.",
+      "name": "wallet-pass-add-and-update",
+      "prompt": "Our concert app downloads a .pkpass from the server and shows a custom 'Save to Wallet' button. We gate it with PKPassLibrary.isPassLibraryAvailable(), parse with try? PKPass(data:), and when a ticket changes we create a new serial number. Sometimes replacePass seems to do nothing. What should we fix?",
+      "expected_output": "Uses AddPassToWalletButton or PKAddPassButton/PKAddPassesViewController, gates adding on canAddPasses and library work on isPassLibraryAvailable, surfaces invalid-data and invalid-signature errors from signed data, notes passes() is limited by entitlements, keeps the same pass type and serial number for updates, and checks the Bool from replacePass(with:).",
       "files": [],
       "assertions": [
-        "Replaces the custom SwiftUI button with `AddPassToWalletButton` or routes review flows through `PKAddPassesViewController`/`PKAddPassButton`.",
-        "Uses `PKAddPassesViewController.canAddPasses()` to decide whether the device can add passes.",
-        "Uses `PKPassLibrary.isPassLibraryAvailable()` only for pass-library operations, not add-pass capability.",
-        "Mentions that `PKPass(data:)` expects signed `.pkpass` data and can throw invalid-data or invalid-signature errors.",
-        "Explains that `PKPassLibrary.passes()` returns only passes the app can access through entitlements.",
-        "Preserves the same `passTypeIdentifier` and `serialNumber` when updating an existing pass.",
-        "Checks the Boolean result from `PKPassLibrary.replacePass(with:)` and handles failure."
+        "Replaces the custom button with AddPassToWalletButton, PKAddPassButton or PKAddPassesViewController",
+        "Uses canAddPasses() to decide whether adding is possible and keeps isPassLibraryAvailable() for library operations",
+        "Requires signed pass data and reports invalid-data and invalid-signature errors instead of a bare try?",
+        "Notes that passes() only returns passes the app's entitlements allow",
+        "Keeps passTypeIdentifier and serialNumber unchanged when updating a pass",
+        "Checks the Bool returned by replacePass(with:) and handles false"
       ]
     },
     {
       "id": 3,
-      "prompt": "I need advanced Apple Pay support for a home-goods marketplace: recurring service membership, coupon entry in the payment sheet, two end merchants that need separate tokens, and a furniture pre-order charged later. Outline the PassKit APIs and gotchas without drifting into FinanceKit or StoreKit implementation.",
-      "expected_output": "An advanced PassKit outline using the optional request types and update callbacks correctly, with decimal amounts, management URLs, coupon update details, multi-token contexts, and sibling-skill boundaries.",
+      "name": "advanced-payment-requests",
+      "prompt": "For our furniture marketplace we need: a monthly protection plan, promo codes at checkout, separate payouts to each workshop in a basket, and pay-on-delivery for custom pieces. Can one PKPaymentRequest do all of that? We are also wondering whether FinanceKit or StoreKit should be involved.",
+      "expected_output": "Explains that only one advanced type fits per request; shows a PKRecurringPaymentRequest with a recurring item, interval, billing agreement and management URL; enables coupon codes with the delegate reply including shipping methods; uses PKPaymentTokenContext entries with merchant ids, name, domain and decimal amounts; builds a PKDeferredPaymentRequest with deferred date, free cancellation details and management URL; keeps FinanceKit and StoreKit out.",
       "files": [],
       "assertions": [
-        "Uses `PKRecurringPaymentRequest` with `PKRecurringPaymentSummaryItem`, interval unit/count, billing agreement or management URL, and `request.recurringPaymentRequest`.",
-        "Notes that a `PKPaymentRequest` can set only one optional payment request type such as recurring, automatic reload, deferred, Apple Pay Later availability, or multi-token contexts.",
-        "Enables coupon entry with `supportsCouponCode` and handles `paymentAuthorizationController(_:didChangeCouponCode:handler:)`.",
-        "Creates `PKPaymentRequestCouponCodeUpdate(errors:paymentSummaryItems:shippingMethods:)`, including shipping methods.",
-        "Uses `PKPaymentTokenContext` entries with merchant identifier, external identifier, merchant name/domain, and `NSDecimalNumber` amounts for multi-merchant tokens.",
-        "Uses `PKDeferredPaymentRequest` with `PKDeferredPaymentSummaryItem`, deferred date or cancellation date details, and a management URL.",
-        "Keeps FinanceKit financial-data access and StoreKit digital purchase implementation outside the PassKit answer."
+        "Builds a PKRecurringPaymentRequest with a PKRecurringPaymentSummaryItem, interval, billing agreement and management URL",
+        "States the one-advanced-type-per-request rule and splits the checkout into several requests",
+        "Sets supportsCouponCode and implements didChangeCouponCode",
+        "Replies with PKPaymentRequestCouponCodeUpdate including shippingMethods",
+        "Uses PKPaymentTokenContext with merchant identifier, external identifier, name, domain and NSDecimalNumber amounts",
+        "Uses PKDeferredPaymentRequest with a deferred date, free cancellation date and time zone, and a management URL",
+        "Does not implement FinanceKit or StoreKit for this flow"
       ]
     }
   ]
-}
+}

package/pipeline/skills/shared/external/passkit-wallet/references/wallet-passes.md

@@ -1,304 +1,237 @@
-# PassKit Extended Patterns
+# Wallet Passes and Advanced Apple Pay
 
-Overflow reference for the `passkit` skill. Contains advanced patterns that exceed the main skill file's scope.
+Reference for the `passkit-wallet` skill: advanced payment request types,
+pass bundles, pass updates and a complete SwiftUI checkout.
 
-A single `PKPaymentRequest` can set only one optional advanced payment request
-type, such as `recurringPaymentRequest`, `automaticReloadPaymentRequest`,
-`deferredPaymentRequest`, Apple Pay Later availability, or
-`multiTokenContexts`.
+## One advanced type per request
 
-## Contents
+Each `PKPaymentRequest` may set only one of these:
 
-- [Recurring Payment Requests](#recurring-payment-requests)
-- [Coupon Code Support](#coupon-code-support)
-- [Multi-Merchant Payments](#multi-merchant-payments)
-- [Deferred Payments](#deferred-payments)
-- [Building Pass Bundles](#building-pass-bundles)
-- [Updating Passes with Push Notifications](#updating-passes-with-push-notifications)
-- [SwiftUI Payment Flow](#swiftui-payment-flow)
+- `recurringPaymentRequest`
+- `automaticReloadPaymentRequest`
+- `deferredPaymentRequest`
+- the Apple Pay Later availability setting
+- `multiTokenContexts`
 
-## Recurring Payment Requests
+If a checkout needs two, split it into two requests.
 
-Set up subscription-style recurring payments with `PKRecurringPaymentRequest`.
+## Recurring payments
 
 ```swift
-import PassKit
-
-func createSubscriptionRequest() -> PKPaymentRequest {
-    let request = PKPaymentRequest()
-    request.merchantIdentifier = "merchant.com.example.app"
-    request.countryCode = "US"
-    request.currencyCode = "USD"
-    request.supportedNetworks = [.visa, .masterCard, .amex]
-    request.merchantCapabilities = .threeDSecure
-
-    let monthlyItem = PKRecurringPaymentSummaryItem(
-        label: "Monthly Subscription",
-        amount: NSDecimalNumber(string: "9.99")
+func membershipRequest() -> PKPaymentRequest {
+    let order = baseRequest()
+    let monthly = PKRecurringPaymentSummaryItem(label: "Studio Membership", amount: NSDecimalNumber(string: "29.00"))
+    monthly.intervalUnit = .month
+    monthly.intervalCount = 1
+
+    let plan = PKRecurringPaymentRequest(
+        paymentDescription: "Monthly studio membership",
+        regularBilling: monthly,
+        managementURL: URL(string: "https://studio.example.com/account/membership")!
     )
-    monthlyItem.intervalUnit = .month
-    monthlyItem.intervalCount = 1
-
-    request.paymentSummaryItems = [
-        monthlyItem,
-        PKPaymentSummaryItem(
-            label: "My Service",
-            amount: NSDecimalNumber(string: "9.99")
-        )
-    ]
-
-    let recurringRequest = PKRecurringPaymentRequest(
-        paymentDescription: "Monthly Premium",
-        regularBilling: monthlyItem,
-        managementURL: URL(string: "https://example.com/manage")!
-    )
-    recurringRequest.billingAgreement = "You will be charged $9.99/month."
-    request.recurringPaymentRequest = recurringRequest
+    plan.billingAgreement = "Billed monthly until you cancel. Cancel any time from your account page."
+    order.recurringPaymentRequest = plan
 
-    return request
+    let total = PKPaymentSummaryItem(label: "Clayworks Studio", amount: monthly.amount)
+    order.paymentSummaryItems = [monthly, total]
+    return order
 }
 ```
 
-## Coupon Code Support
+The recurring item appears in the summary list and the total follows it. The
+management URL is where the customer changes or cancels the plan. The literal
+URL is force-unwrapped only to keep the sample short.
 
-Enable coupon codes on the payment sheet and handle validation.
-`PKPaymentRequestCouponCodeUpdate` requires a `[PKShippingMethod]`; pass current
-or updated methods, or `[]` when unchanged.
+## Coupon codes
 
 ```swift
-func createRequestWithCoupons() -> PKPaymentRequest {
-    let request = createPaymentRequest()
-    request.supportsCouponCode = true
-    request.couponCode = "" // pre-fill if known
-    return request
-}
-
-// Handle coupon code entry in the delegate
-extension PaymentCoordinator: PKPaymentAuthorizationControllerDelegate {
-    func paymentAuthorizationController(
-        _ controller: PKPaymentAuthorizationController,
-        didChangeCouponCode couponCode: String,
-        handler completion: @escaping (PKPaymentRequestCouponCodeUpdate) -> Void
-    ) {
-        Task {
-            do {
-                let discount = try await validateCoupon(couponCode)
-                let updatedItems = applyDiscount(discount)
-                completion(PKPaymentRequestCouponCodeUpdate(
-                    errors: nil,
-                    paymentSummaryItems: updatedItems,
-                    shippingMethods: currentShippingMethods
-                ))
-            } catch {
-                let couponError = PKPaymentRequest.paymentCouponCodeInvalidError(
-                    localizedDescription: "Invalid coupon code."
-                )
-                completion(PKPaymentRequestCouponCodeUpdate(
-                    errors: [couponError],
-                    paymentSummaryItems: originalItems,
-                    shippingMethods: currentShippingMethods
-                ))
-            }
-        }
-    }
-}
+order.supportsCouponCode = true
+order.couponCode = savedPromo
 ```
 
-## Multi-Merchant Payments
-
-Request separate payment tokens for multiple merchants in one transaction using `PKPaymentTokenContext`.
+`couponCode` is optional and pre-fills the field. Validate changes in the
+delegate. Like the other delegate callbacks it runs on the main actor, so the
+`Task` it starts stays there and can call `reply` and touch `basket`:
 
 ```swift
-func createMultiMerchantRequest() -> PKPaymentRequest {
-    let request = PKPaymentRequest()
-    request.merchantIdentifier = "merchant.com.example.platform"
-    request.countryCode = "US"
-    request.currencyCode = "USD"
-    request.supportedNetworks = [.visa, .masterCard, .amex]
-    request.merchantCapabilities = .threeDSecure
-
-    request.paymentSummaryItems = [
-        PKPaymentSummaryItem(
-            label: "Furniture",
-            amount: NSDecimalNumber(string: "299.00")
-        ),
-        PKPaymentSummaryItem(
-            label: "Lighting",
-            amount: NSDecimalNumber(string: "89.00")
-        ),
-        PKPaymentSummaryItem(
-            label: "Home Goods Marketplace",
-            amount: NSDecimalNumber(string: "388.00")
-        )
-    ]
-
-    let furnitureContext = PKPaymentTokenContext(
-        merchantIdentifier: "merchant.com.example.furniture",
-        externalIdentifier: "furniture-order-123",
-        merchantName: "Example Furniture",
-        merchantDomain: "furniture.example.com",
-        amount: NSDecimalNumber(string: "299.00")
-    )
-
-    let lightingContext = PKPaymentTokenContext(
-        merchantIdentifier: "merchant.com.example.lighting",
-        externalIdentifier: "lighting-order-456",
-        merchantName: "Example Lighting",
-        merchantDomain: "lighting.example.com",
-        amount: NSDecimalNumber(string: "89.00")
-    )
-
-    request.multiTokenContexts = [furnitureContext, lightingContext]
-    return request
+func paymentAuthorizationController(
+    _ sheet: PKPaymentAuthorizationController,
+    didChangeCouponCode code: String,
+    handler reply: @escaping (PKPaymentRequestCouponCodeUpdate) -> Void
+) {
+    Task {
+        guard let discount = await Promotions.lookUp(code) else {
+            let problem = PKPaymentRequest.paymentCouponCodeInvalidError(localizedDescription: "That code is not valid.")
+            reply(PKPaymentRequestCouponCodeUpdate(
+                errors: [problem],
+                paymentSummaryItems: basket.summaryItems(),
+                shippingMethods: basket.shippingMethods
+            ))
+            return
+        }
+        basket.apply(discount)
+        reply(PKPaymentRequestCouponCodeUpdate(
+            errors: nil,
+            paymentSummaryItems: basket.summaryItems(),
+            shippingMethods: basket.shippingMethods
+        ))
+    }
 }
 ```
 
-## Deferred Payments
+`shippingMethods` is a required `[PKShippingMethod]` argument. Pass the
+current or recalculated methods, or `[]` when shipping is unchanged. On an
+invalid code, send the original items back with the coupon error.
+
+## Several merchants in one checkout
 
-Set up payments that charge later, such as pre-orders or made-to-order goods.
+A marketplace or booking platform can collect a separate token for each
+merchant it sells for:
 
 ```swift
-func createDeferredPaymentRequest() -> PKPaymentRequest {
-    let request = createPaymentRequest()
+let hotel = PKPaymentTokenContext(
+    merchantIdentifier: "merchant.com.harborhotel",
+    externalIdentifier: "harbor-hotel",
+    merchantName: "Harbor Hotel",
+    merchantDomain: "harborhotel.example",
+    amount: NSDecimalNumber(string: "240.00")
+)
+let tour = PKPaymentTokenContext(
+    merchantIdentifier: "merchant.com.baytours",
+    externalIdentifier: "bay-tours",
+    merchantName: "Bay Tours",
+    merchantDomain: "baytours.example",
+    amount: NSDecimalNumber(string: "65.00")
+)
+order.multiTokenContexts = [hotel, tour]
+```
 
-    let deferredDate = Calendar.current.date(
-        byAdding: .day, value: 14, to: Date()
-    )!
+The request itself keeps the platform's own merchant identifier; each context
+names the merchant that actually receives that part of the payment.
 
-    let deferredBilling = PKDeferredPaymentSummaryItem(
-        label: "Sofa (charged at shipment)",
-        amount: NSDecimalNumber(string: "299.00")
-    )
-    deferredBilling.deferredDate = deferredDate
+## Deferred payments
 
-    let deferredRequest = PKDeferredPaymentRequest(
-        paymentDescription: "Made-to-order Sofa - Shipment",
-        deferredBilling: deferredBilling,
-        managementURL: URL(string: "https://example.com/orders")!
-    )
-    deferredRequest.freeCancellationDate = deferredDate
-    deferredRequest.freeCancellationDateTimeZone = .current
+For charges taken later, such as pre-orders or made-to-order goods:
 
-    request.deferredPaymentRequest = deferredRequest
-    return request
-}
+```swift
+let balance = PKDeferredPaymentSummaryItem(label: "Custom Table (due at delivery)", amount: NSDecimalNumber(string: "480.00"))
+balance.deferredDate = deliveryDate
+
+let deferred = PKDeferredPaymentRequest(
+    paymentDescription: "Handmade oak table",
+    deferredBilling: balance,
+    managementURL: URL(string: "https://workshop.example.com/orders")!
+)
+deferred.freeCancellationDate = deliveryDate.addingTimeInterval(-7 * 24 * 60 * 60)
+deferred.freeCancellationDateTimeZone = TimeZone(identifier: "America/Chicago")
+order.deferredPaymentRequest = deferred
 ```
 
-## Building Pass Bundles
+State when the charge happens, until when the order can be cancelled for
+free, and where the customer manages it.
 
-A distributable pass is a signed `.pkpass` bundle. Keep the app-side PassKit
-code separate from server-side pass generation, but check these fields when a
-pass fails to add:
+## Pass bundles
 
-- `passTypeIdentifier` matches the Pass Type ID certificate.
-- `teamIdentifier` matches the Apple Developer team that owns the certificate.
-- `serialNumber` is unique for that pass type; updating a pass uses the same
-  `passTypeIdentifier` and `serialNumber`.
-- `manifest.json` includes SHA-1 hashes for every source file, and `signature`
-  is a PKCS #7 detached signature over the manifest.
-- `.pkpasses` bundles contain up to 10 `.pkpass` files and use the
-  `application/vnd.apple.pkpasses` MIME type.
+A pass that can be distributed is a signed `.pkpass` bundle. Generating and
+signing it is server work; keep that code out of the app.
 
-## Updating Passes with Push Notifications
+| Field or file | Rule |
+|---------------|------|
+| `passTypeIdentifier` | Must match the Pass Type ID certificate used to sign |
+| `teamIdentifier` | Must match the developer team that owns that Pass Type ID |
+| `serialNumber` | Unique within the pass type; an update keeps both the pass type and the serial |
+| `manifest.json` | SHA-1 hash of every file in the bundle |
+| `signature` | Detached PKCS #7 signature over the manifest |
 
-Passes in Wallet can receive push notifications to trigger an update. The flow:
+A `.pkpasses` bundle groups up to 10 `.pkpass` files and is served as
+`application/vnd.apple.pkpasses`.
 
-1. The pass JSON includes a `webServiceURL` and `authenticationToken`
-2. When the pass is added to Wallet, the device registers with your server
-3. To update, send a production APNs pass-update push with an empty JSON payload
-4. The device calls your `webServiceURL` to fetch the updated `.pkpass` bundle
+## Keeping passes current
 
-The pass-update web service authenticates registration, unregister, and pass
-download requests with `authenticationToken`; use the device library identifier
-when returning the serial numbers of updated passes. You can update any pass
-contents except the authentication token and serial number.
+1. The pass JSON includes `webServiceURL` and `authenticationToken`.
+2. When the user adds the pass, the device registers with your web service.
+3. When the pass changes, your server sends a pass-update push through
+   production APNs with an empty JSON payload.
+4. The device asks the web service which passes changed and downloads the new
+   `.pkpass` from `webServiceURL`.
 
-### Server Endpoints (your web service must implement)
+The web service checks `authenticationToken` on register, unregister and
+download calls, and uses the device library identifier to answer which serial
+numbers changed. Everything in a pass may change except its authentication
+token and serial number.
 
-| Method | Path | Purpose |
-|---|---|---|
-| POST | `/v1/devices/{deviceId}/registrations/{passTypeId}/{serialNumber}` | Register device for updates |
-| DELETE | `/v1/devices/{deviceId}/registrations/{passTypeId}/{serialNumber}` | Unregister device |
-| GET | `/v1/devices/{deviceId}/registrations/{passTypeId}` | Get serial numbers of updated passes |
-| GET | `/v1/passes/{passTypeId}/{serialNumber}` | Download the latest pass |
+| Method and path | Purpose |
+|-----------------|---------|
+| `POST /v1/devices/{deviceId}/registrations/{passTypeId}/{serialNumber}` | Register a device for a pass |
+| `DELETE /v1/devices/{deviceId}/registrations/{passTypeId}/{serialNumber}` | Unregister |
+| `GET /v1/devices/{deviceId}/registrations/{passTypeId}` | Serial numbers that changed |
+| `GET /v1/passes/{passTypeId}/{serialNumber}` | The latest version of a pass |
 
-### Checking for Updates In-App
+### Updating from inside the app
 
 ```swift
-import PassKit
-
-let library = PKPassLibrary()
-
-// Replace an existing pass with updated data
-func updatePass(newPassData: Data) {
-    guard let updatedPass = try? PKPass(data: newPassData) else { return }
-    if library.containsPass(updatedPass) {
-        let replaced = library.replacePass(with: updatedPass)
-        if !replaced {
-            // Fall back to add-pass UI or report a recoverable update failure.
+@MainActor
+func install(_ fresh: PKPass, presenter: UIViewController) {
+    let library = PKPassLibrary()
+    if library.containsPass(fresh) {
+        guard library.replacePass(with: fresh) else {
+            showRetryableWalletError()
+            return
         }
+    } else if let sheet = PKAddPassesViewController(pass: fresh) {
+        presenter.present(sheet, animated: true)
     }
 }
 ```
 
-## SwiftUI Payment Flow
+When `replacePass(with:)` returns `false`, fall back to the add-pass sheet or
+tell the user the update can be retried.
 
-A complete SwiftUI payment view with availability check, button, and processing.
+## SwiftUI checkout screen
 
 ```swift
-import SwiftUI
-import PassKit
+enum PaymentState: Equatable {
+    case idle, processing, paid
+    case failed(String)
+}
 
-struct PaymentView: View {
-    @State private var paymentStatus: PaymentStatus = .idle
-    @State private var coordinator: PaymentCoordinator?
+struct CheckoutScreen: View {
+    @State private var coordinator = PaymentCoordinator()
+    @State private var state: PaymentState = .idle
 
     private var canPay: Bool {
         PKPaymentAuthorizationController.canMakePayments(
-            usingNetworks: [.visa, .masterCard, .amex],
+            usingNetworks: Checkout.networks,
             capabilities: .threeDSecure
         )
     }
 
     var body: some View {
-        VStack {
-            OrderSummaryView()
-
+        VStack(spacing: 16) {
             if canPay {
-                PayWithApplePayButton(.buy) {
-                    processPayment()
-                }
-                .payWithApplePayButtonStyle(.black)
-                .frame(height: 48)
+                PayWithApplePayButton(.checkout) { startApplePay() }
+                    .frame(height: 50)
             } else {
-                Button("Checkout with Card") {
-                    // Fallback payment flow
-                }
-                .buttonStyle(.borderedProminent)
+                Button("Pay with Card") { showCardForm() }
+                    .buttonStyle(.borderedProminent)
             }
-
-            if case .error(let message) = paymentStatus {
-                Text(message)
-                    .foregroundStyle(.red)
-                    .font(.caption)
+            if case .failed(let reason) = state {
+                Text(reason).foregroundStyle(.red)
             }
         }
         .padding()
     }
 
     @MainActor
-    private func processPayment() {
-        coordinator = PaymentCoordinator { result in
-            paymentStatus = result
-        }
-        coordinator?.startPayment()
+    private func startApplePay() {
+        state = .processing
+        coordinator.pay()
     }
-}
 
-enum PaymentStatus {
-    case idle
-    case processing
-    case success
-    case error(String)
+    private func showCardForm() {}
 }
 ```
+
+The coordinator lives in `@State` so it, and the controller it retains, stay
+alive while the sheet is shown. `PaymentState` covers idle, processing, paid
+and a failure with a message.