How do you structure a StoreKit 2 integration: which object owns products, entitlements, the updates listener and restore, and where does the seam for testing go?

Predict first

Does the store object (catalogue, entitlements, updates listener, restore) compile against the iOS SDK?

import StoreKit
import Observation

protocol StoreBackend: Sendable {
    func products(for ids: [String]) async throws -> [Product]
    func entitledProductIDs() async -> Set<String>
}
struct LiveBackend: StoreBackend {
    func products(for ids: [String]) async throws -> [Product] { try await Product.products(for: ids) }
    func entitledProductIDs() async -> Set<String> {
        var ids = Set<String>()
        for await result in Transaction.currentEntitlements {
            if case .verified(let t) = result, t.revocationDate == nil { ids.insert(t.productID) }
        }
        return ids
    }
}

@MainActor @Observable final class Store {
    private(set) var products: [Product] = []
    private(set) var missingIDs: [String] = []
    private(set) var entitled: Set<String> = []
    private(set) var isLoading = false
    private let ids: [String]
    private let backend: StoreBackend
    @ObservationIgnored private var updates: Task<Void, Never>?

    init(ids: [String], backend: StoreBackend = LiveBackend()) {
        self.ids = ids; self.backend = backend
        updates = Task { [weak self] in
            for await result in Transaction.updates {
                guard case .verified(let t) = result else { continue }
                await self?.refreshEntitlements()
                await t.finish()
            }
        }
    }
    deinit { updates?.cancel() }

    func load() async {
        isLoading = true; defer { isLoading = false }
        do {
            let found = try await backend.products(for: ids)
            products = found.sorted { $0.price < $1.price }
            missingIDs = ids.filter { id in !found.contains { $0.id == id } }
        } catch { products = [] }
        await refreshEntitlements()
    }
    func refreshEntitlements() async { entitled = await backend.entitledProductIDs() }
    func restore() async throws { try await AppStore.sync(); await refreshEntitlements() }
    func isUnlocked(_ id: String) -> Bool { entitled.contains(id) }
}

• Yes, it compiles
• No: Transaction.updates is not available on iOS
• No: AppStore.sync cannot be called from a class