@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SafariServices/SafariServices.swift

@@ -0,0 +1,106 @@
+// `import SafariServices` for the browser: `SFSafariViewController`, the
+// in-app Safari sheet, becomes a new tab. Presenting one (any view
+// controller's `present`) asks the page to open its URL as a link would (an
+// `openURL` host request; docs/ops-protocol.md, "Rich text"), and the
+// controller is then done: it dismisses itself and tells its delegate
+// `safariViewControllerDidFinish`, since the tab is the viewer's own from
+// there. A URL that is not http(s) is refused, as on iOS (where the
+// initializer raises). The configuration and tint colors are kept with
+// nothing to style; Reader mode is the browser's own.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+
+/// The in-app browser: a new tab on the page (see the top of this file).
+@MainActor
+open class SFSafariViewController: UIViewController {
+    /// How the controller is set up; kept, with nothing in a tab to apply it to.
+    @MainActor
+    open class Configuration {
+        open var entersReaderIfAvailable = false
+        open var barCollapsingEnabled = true
+        public init() {}
+    }
+
+    public enum DismissButtonStyle: Int, Sendable {
+        case done = 0, close, cancel
+    }
+
+    /// Opens a URL on the page; tests replace it.
+    static var openOnPage: @MainActor (URL) -> Void = { url in
+        _Runtime.shared._openLinkOnPage(url.absoluteString)
+    }
+
+    public let url: URL
+    public let configuration: Configuration
+    open weak var delegate: (any SFSafariViewControllerDelegate)?
+    open var preferredBarTintColor: UIColor?
+    open var preferredControlTintColor: UIColor?
+    open var dismissButtonStyle: DismissButtonStyle = .done
+    private var opened = false
+
+    public init(url URL: URL, configuration: Configuration = Configuration()) {
+        self.url = URL
+        self.configuration = configuration
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    @available(*, deprecated, renamed: "init(url:configuration:)")
+    public convenience init(url URL: URL, entersReaderIfAvailable: Bool) {
+        let configuration = Configuration()
+        configuration.entersReaderIfAvailable = entersReaderIfAvailable
+        self.init(url: URL, configuration: configuration)
+    }
+
+    public required init?(coder: NSCoder) { nil }
+
+    /// Presented: the URL opens in a new tab, and the controller finishes.
+    open override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        guard !opened else { return }
+        opened = true
+        if let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" {
+            Self.openOnPage(url)
+            delegate?.safariViewControllerWillOpenInBrowser(self)
+        }
+        dismiss(animated: animated)
+        delegate?.safariViewControllerDidFinish(self)
+    }
+
+    /// Nothing to warm up: the browser loads the page when the tab opens.
+    public static func prewarmConnections(to URLs: [URL]) -> PrewarmingToken { PrewarmingToken() }
+
+    public final class PrewarmingToken: Sendable {
+        public func invalidate() {}
+    }
+}
+
+/// What a Safari view controller tells its owner. Every method is optional.
+@MainActor
+public protocol SFSafariViewControllerDelegate: AnyObject {
+    /// The controller is done: in the browser, right after it opened its tab.
+    func safariViewControllerDidFinish(_ controller: SFSafariViewController)
+    /// Never called: the page cannot see another site's tab load.
+    func safariViewController(_ controller: SFSafariViewController, didCompleteInitialLoad didLoadSuccessfully: Bool)
+    /// Never called, for the same reason.
+    func safariViewController(_ controller: SFSafariViewController, initialLoadDidRedirectTo URL: URL)
+    /// Called as the URL opens in its tab.
+    func safariViewControllerWillOpenInBrowser(_ controller: SFSafariViewController)
+}
+
+extension SFSafariViewControllerDelegate {
+    public func safariViewControllerDidFinish(_ controller: SFSafariViewController) {}
+    public func safariViewController(_ controller: SFSafariViewController, didCompleteInitialLoad didLoadSuccessfully: Bool) {}
+    public func safariViewController(_ controller: SFSafariViewController, initialLoadDidRedirectTo URL: URL) {}
+    public func safariViewControllerWillOpenInBrowser(_ controller: SFSafariViewController) {}
+}
+
+// MARK: - Authentication sessions (deprecated)
+
+/// `SFAuthenticationSession`, iOS 11's sign-in session, deprecated for
+/// AuthenticationServices' `ASWebAuthenticationSession`: not here. An app
+/// that still uses it fails to compile with this message.
+@available(*, unavailable, message: "use AuthenticationServices' ASWebAuthenticationSession, which the browser has")
+public final class SFAuthenticationSession {}

package/Sources/Security/Security.swift

@@ -0,0 +1,332 @@
+// `import Security` for the browser: the keychain's item functions
+// (`SecItemAdd`, `SecItemCopyMatching`, `SecItemUpdate`, `SecItemDelete`) over
+// a store of generic and internet passwords. The store is a file in the app's
+// home (`$HOME/Library/Keychains/keychain.json`, `/data` in the browser),
+// which the page keeps across launches like the app's other files. That makes
+// it as private as the rest of the page's storage for its origin, not
+// encrypted, and with one access group: the app's.
+//
+// Queries are dictionaries keyed by the `kSec…` constants, as on Apple
+// platforms, and the constants have Apple's values ("acct", "svce", …), so
+// code that spells them as strings works too. Certificates, keys, identities
+// and access control are not here.
+
+import Foundation
+// `OSStatus`, `CFString`, `CFDictionary`…
+@_exported import CoreFoundationTypes
+
+public let errSecSuccess: OSStatus = 0
+public let noErr: OSStatus = 0
+public let errSecUnimplemented: OSStatus = -4
+public let errSecParam: OSStatus = -50
+public let errSecAllocate: OSStatus = -108
+public let errSecDuplicateItem: OSStatus = -25299
+public let errSecInvalidValue: OSStatus = -67695
+public let errSecItemNotFound: OSStatus = -25300
+public let errSecInteractionNotAllowed: OSStatus = -25308
+public let errSecDecode: OSStatus = -26275
+public let errSecAuthFailed: OSStatus = -25293
+public let errSecMissingEntitlement: OSStatus = -34018
+
+// Item classes.
+public let kSecClass: CFString = "class"
+public let kSecClassGenericPassword: CFString = "genp"
+public let kSecClassInternetPassword: CFString = "inet"
+
+// Attributes.
+public let kSecAttrAccount: CFString = "acct"
+public let kSecAttrService: CFString = "svce"
+public let kSecAttrServer: CFString = "srvr"
+public let kSecAttrProtocol: CFString = "ptcl"
+public let kSecAttrPort: CFString = "port"
+public let kSecAttrPath: CFString = "path"
+public let kSecAttrLabel: CFString = "labl"
+public let kSecAttrDescription: CFString = "desc"
+public let kSecAttrComment: CFString = "icmt"
+public let kSecAttrGeneric: CFString = "gena"
+public let kSecAttrAccessGroup: CFString = "agrp"
+public let kSecAttrSynchronizable: CFString = "sync"
+public let kSecAttrSynchronizableAny: CFString = "syna"
+public let kSecAttrCreationDate: CFString = "cdat"
+public let kSecAttrModificationDate: CFString = "mdat"
+public let kSecAttrAccessible: CFString = "pdmn"
+public let kSecAttrAccessibleWhenUnlocked: CFString = "ak"
+public let kSecAttrAccessibleAfterFirstUnlock: CFString = "ck"
+public let kSecAttrAccessibleWhenUnlockedThisDeviceOnly: CFString = "aku"
+public let kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly: CFString = "cku"
+public let kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly: CFString = "akpu"
+public let kSecAttrAccessibleAlways: CFString = "dk"
+public let kSecAttrAccessibleAlwaysThisDeviceOnly: CFString = "dku"
+
+// Values, returns and search.
+public let kSecValueData: CFString = "v_Data"
+public let kSecValueRef: CFString = "v_Ref"
+public let kSecValuePersistentRef: CFString = "v_PersistentRef"
+public let kSecReturnData: CFString = "r_Data"
+public let kSecReturnAttributes: CFString = "r_Attributes"
+public let kSecReturnRef: CFString = "r_Ref"
+public let kSecReturnPersistentRef: CFString = "r_PersistentRef"
+public let kSecMatchLimit: CFString = "m_Limit"
+public let kSecMatchLimitOne: CFString = "m_LimitOne"
+public let kSecMatchLimitAll: CFString = "m_LimitAll"
+public let kSecUseDataProtectionKeychain: CFString = "nleg"
+public let kSecUseAuthenticationUI: CFString = "u_AuthUI"
+
+/// Adds an item; `result` receives what the attributes' `kSecReturn…` keys ask for.
+public func SecItemAdd(_ attributes: CFDictionary, _ result: UnsafeMutablePointer<CFTypeRef?>?) -> OSStatus {
+    _Keychain.shared.add(attributes, result)
+}
+
+/// Finds the items matching the query; `result` receives what its `kSecReturn…` keys ask for.
+public func SecItemCopyMatching(_ query: CFDictionary, _ result: UnsafeMutablePointer<CFTypeRef?>?) -> OSStatus {
+    _Keychain.shared.copyMatching(query, result)
+}
+
+/// Changes the attributes (and data) of every item matching the query.
+public func SecItemUpdate(_ query: CFDictionary, _ attributesToUpdate: CFDictionary) -> OSStatus {
+    _Keychain.shared.update(query, attributesToUpdate)
+}
+
+/// Deletes every item matching the query.
+public func SecItemDelete(_ query: CFDictionary) -> OSStatus {
+    _Keychain.shared.delete(query)
+}
+
+public func SecCopyErrorMessageString(_ status: OSStatus, _ reserved: UnsafeMutableRawPointer?) -> CFString? {
+    switch status {
+    case errSecSuccess: "No error."
+    case errSecParam: "One or more parameters passed to a function were not valid."
+    case errSecDuplicateItem: "The specified item already exists in the keychain."
+    case errSecItemNotFound: "The specified item could not be found in the keychain."
+    case errSecUnimplemented: "Function or operation not implemented."
+    case errSecDecode: "Unable to decode the provided data."
+    default: "OSStatus \(status)"
+    }
+}
+
+/// The keychain's items, kept in a file in the app's home.
+final class _Keychain: @unchecked Sendable {
+    nonisolated(unsafe) static var shared = _Keychain(file: _Keychain.defaultFile)
+
+    static var defaultFile: URL {
+        let home = ProcessInfo.processInfo.environment["HOME"].flatMap { $0.hasPrefix("/") ? $0 : nil } ?? "/data"
+        return URL(fileURLWithPath: home).appendingPathComponent("Library/Keychains/keychain.json")
+    }
+
+    /// The attributes an item is matched on and returns, besides its data.
+    static let attributeKeys: Set<String> = [
+        kSecClass, kSecAttrAccount, kSecAttrService, kSecAttrServer, kSecAttrProtocol, kSecAttrPort, kSecAttrPath,
+        kSecAttrLabel, kSecAttrDescription, kSecAttrComment, kSecAttrGeneric, kSecAttrAccessGroup,
+        kSecAttrSynchronizable, kSecAttrAccessible,
+    ]
+    static let classes: Set<String> = [kSecClassGenericPassword, kSecClassInternetPassword]
+    /// The access group of items added without one.
+    static let defaultGroup = "app"
+
+    struct Item: Codable {
+        var id: Int
+        var attributes: [String: _Value]
+        var data: Data?
+        var created: Double
+        var modified: Double
+    }
+
+    /// An attribute value the store keeps: what the attributes Apple defines can hold.
+    enum _Value: Codable, Equatable {
+        case string(String), number(Double), bool(Bool), data(Data)
+
+        init?(_ value: Any) {
+            switch value {
+            case let v as String: self = .string(v)
+            case let v as Bool: self = .bool(v)
+            case let v as Int: self = .number(Double(v))
+            case let v as Double: self = .number(v)
+            case let v as Data: self = .data(v)
+            default: return nil
+            }
+        }
+
+        var any: Any {
+            switch self {
+            case .string(let v): v
+            case .number(let v): v == v.rounded() ? Int(v) as Any : v as Any
+            case .bool(let v): v
+            case .data(let v): v
+            }
+        }
+    }
+
+    struct Store: Codable {
+        var nextID = 1
+        var items: [Item] = []
+    }
+
+    let file: URL
+    private var loaded: Store?
+
+    init(file: URL) { self.file = file }
+
+    private var store: Store {
+        get {
+            if let loaded { return loaded }
+            let read = (try? Data(contentsOf: file)).flatMap { try? JSONDecoder().decode(Store.self, from: $0) } ?? Store()
+            loaded = read
+            return read
+        }
+        set {
+            loaded = newValue
+            try? FileManager.default.createDirectory(at: file.deletingLastPathComponent(), withIntermediateDirectories: true)
+            if let data = try? JSONEncoder().encode(newValue) { try? data.write(to: file) }
+        }
+    }
+
+    // MARK: Item functions
+
+    func add(_ attributes: [String: Any], _ result: UnsafeMutablePointer<CFTypeRef?>?) -> OSStatus {
+        guard let itemClass = attributes[kSecClass] as? String, Self.classes.contains(itemClass) else { return errSecParam }
+        var values: [String: _Value] = [:]
+        for (key, value) in attributes where Self.attributeKeys.contains(key) {
+            guard let stored = _Value(value) else { return errSecParam }
+            values[key] = stored
+        }
+        values[kSecAttrAccessGroup] = values[kSecAttrAccessGroup] ?? .string(Self.defaultGroup)
+        values[kSecAttrSynchronizable] = .bool(Self.isTrue(attributes[kSecAttrSynchronizable]))
+        values[kSecAttrAccessible] = values[kSecAttrAccessible] ?? .string(kSecAttrAccessibleWhenUnlocked)
+        var store = self.store
+        if store.items.contains(where: { Self.sameIdentity($0.attributes, values) }) { return errSecDuplicateItem }
+        let now = Date().timeIntervalSince1970
+        let item = Item(id: store.nextID, attributes: values, data: attributes[kSecValueData] as? Data, created: now, modified: now)
+        store.nextID += 1
+        store.items.append(item)
+        self.store = store
+        if let result { result.pointee = Self.answer([item], to: attributes, one: true) }
+        return errSecSuccess
+    }
+
+    func copyMatching(_ query: [String: Any], _ result: UnsafeMutablePointer<CFTypeRef?>?) -> OSStatus {
+        guard query[kSecClass] is String else { return errSecParam }
+        let one = (query[kSecMatchLimit] as? String) != kSecMatchLimitAll
+        var found = store.items.filter { Self.matches($0, query) }
+        if found.isEmpty { return errSecItemNotFound }
+        if one { found = [found[0]] }
+        if let result { result.pointee = Self.answer(found, to: query, one: one) }
+        return errSecSuccess
+    }
+
+    func update(_ query: [String: Any], _ changes: [String: Any]) -> OSStatus {
+        guard query[kSecClass] is String else { return errSecParam }
+        var store = self.store
+        let indices = store.items.indices.filter { Self.matches(store.items[$0], query) }
+        if indices.isEmpty { return errSecItemNotFound }
+        let now = Date().timeIntervalSince1970
+        for index in indices {
+            for (key, value) in changes {
+                if key == kSecValueData {
+                    store.items[index].data = value as? Data
+                } else if Self.attributeKeys.contains(key), key != kSecClass {
+                    guard let stored = key == kSecAttrSynchronizable ? .bool(Self.isTrue(value)) : _Value(value) else { return errSecParam }
+                    store.items[index].attributes[key] = stored
+                }
+            }
+            store.items[index].modified = now
+        }
+        // An update must not make two items the same.
+        for index in indices {
+            let item = store.items[index]
+            if store.items.contains(where: { $0.id != item.id && Self.sameIdentity($0.attributes, item.attributes) }) {
+                return errSecDuplicateItem
+            }
+        }
+        self.store = store
+        return errSecSuccess
+    }
+
+    func delete(_ query: [String: Any]) -> OSStatus {
+        guard query[kSecClass] is String else { return errSecParam }
+        var store = self.store
+        let before = store.items.count
+        store.items.removeAll { Self.matches($0, query) }
+        if store.items.count == before { return errSecItemNotFound }
+        self.store = store
+        return errSecSuccess
+    }
+
+    // MARK: Matching
+
+    static func isTrue(_ value: Any?) -> Bool {
+        switch value {
+        case let v as Bool: v
+        case let v as Int: v != 0
+        case let v as String: v == "1" || v == "true"
+        default: false
+        }
+    }
+
+    /// Whether the item has the query's attributes. Without
+    /// `kSecAttrSynchronizable` a query finds the items that do not
+    /// synchronize; `kSecAttrSynchronizableAny` finds both.
+    static func matches(_ item: Item, _ query: [String: Any]) -> Bool {
+        if let ref = query[kSecValuePersistentRef] as? Data, ref != persistentRef(item) { return false }
+        for (key, value) in query where attributeKeys.contains(key) && key != kSecAttrSynchronizable && key != kSecAttrAccessible {
+            guard let wanted = _Value(value), item.attributes[key] == wanted else { return false }
+        }
+        let synchronizes = item.attributes[kSecAttrSynchronizable] == .bool(true)
+        switch query[kSecAttrSynchronizable] {
+        case let any as String where any == kSecAttrSynchronizableAny: return true
+        case let value?: return isTrue(value) == synchronizes
+        case nil: return !synchronizes
+        }
+    }
+
+    /// Two items are the same item when their class and primary key attributes match.
+    static func sameIdentity(_ a: [String: _Value], _ b: [String: _Value]) -> Bool {
+        let keys = [kSecClass, kSecAttrAccount, kSecAttrService, kSecAttrServer, kSecAttrProtocol, kSecAttrPort, kSecAttrPath,
+                    kSecAttrAccessGroup, kSecAttrSynchronizable]
+        return keys.allSatisfy { a[$0] == b[$0] }
+    }
+
+    static func persistentRef(_ item: Item) -> Data { Data("keychain-item-\(item.id)".utf8) }
+
+    /// What the query's `kSecReturn…` keys ask for: the data, a persistent
+    /// reference, or a dictionary of attributes (with those when asked too);
+    /// an array of them when the match limit is all.
+    static func answer(_ items: [Item], to query: [String: Any], one: Bool) -> CFTypeRef? {
+        let wantsData = isTrue(query[kSecReturnData])
+        let wantsAttributes = isTrue(query[kSecReturnAttributes])
+        let wantsRef = isTrue(query[kSecReturnPersistentRef]) || isTrue(query[kSecReturnRef])
+        func value(of item: Item) -> Any? {
+            if wantsAttributes {
+                var dictionary: [String: Any] = item.attributes.mapValues(\.any)
+                dictionary[kSecAttrCreationDate] = Date(timeIntervalSince1970: item.created)
+                dictionary[kSecAttrModificationDate] = Date(timeIntervalSince1970: item.modified)
+                if wantsData { dictionary[kSecValueData] = item.data ?? Data() }
+                if wantsRef { dictionary[kSecValuePersistentRef] = persistentRef(item) }
+                return dictionary
+            }
+            if wantsData { return item.data ?? Data() }
+            if wantsRef { return persistentRef(item) }
+            return nil
+        }
+        if one { return items.first.flatMap(value(of:)).map { $0 as AnyObject } }
+        // Typed arrays, so `result as? [[String: Any]]` (or `[Data]`) reads them back.
+        if wantsAttributes { return items.compactMap { value(of: $0) as? [String: Any] } as AnyObject }
+        if wantsData || wantsRef { return items.compactMap { value(of: $0) as? Data } as AnyObject }
+        return nil
+    }
+}
+
+// MARK: - Randomness
+
+/// A random number generator; the default one is the only one.
+public typealias SecRandomRef = OpaquePointer
+nonisolated(unsafe) public let kSecRandomDefault: SecRandomRef? = nil
+
+/// Fills `bytes` with `count` cryptographically secure random bytes (the
+/// system's generator: `crypto.getRandomValues` in the browser). On Apple
+/// platforms Foundation brings this along, and FoundationBridge re-exports it.
+public func SecRandomCopyBytes(_ rnd: SecRandomRef?, _ count: Int, _ bytes: UnsafeMutableRawPointer) -> Int32 {
+    var generator = SystemRandomNumberGenerator()
+    let buffer = bytes.bindMemory(to: UInt8.self, capacity: count)
+    for index in 0..<count { buffer[index] = generator.next() }
+    return errSecSuccess
+}

package/Sources/StoreKit/AppStore.swift

@@ -0,0 +1,207 @@
+// StoreKit 2's App Store: whether payments can be made, the storefront,
+// StoreKit's errors, purchase intents, App Store messages, external purchase
+// links and the sheets StoreKit presents. A web app has no App Store behind
+// it: payments cannot be made, the storefront is unknown, no intents or
+// messages arrive (their sequences end at once), external purchase links
+// are not eligible, and the sheets (manage subscriptions, redeem an offer
+// code) are not shown: the calls that present them fail with
+// `StoreKitError.unsupported`.
+
+import Foundation
+import SwiftUI
+// As on iOS, StoreKit brings UIKit along: its sheets present in UIKit's scenes.
+@_exported import UIKit
+
+/// The scene StoreKit presents its sheets in.
+public typealias _StoreKitScene = UIWindowScene
+
+/// The App Store, as far as the browser has one.
+public enum AppStore {
+    /// The environment a transaction happened in.
+    public struct Environment: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let production = Environment(rawValue: "Production")
+        public static let sandbox = Environment(rawValue: "Sandbox")
+        public static let xcode = Environment(rawValue: "Xcode")
+    }
+
+    /// The platform an app was first bought on.
+    public struct Platform: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let iOS = Platform(rawValue: "iOS")
+        public static let macOS = Platform(rawValue: "macOS")
+        public static let tvOS = Platform(rawValue: "tvOS")
+        public static let visionOS = Platform(rawValue: "visionOS")
+    }
+
+    /// False: the browser has no App Store to pay through.
+    public static var canMakePayments: Bool { false }
+
+    /// The device's identifier for verifying transactions: none in the browser.
+    public static var deviceVerificationID: UUID? { nil }
+
+    /// Nothing to sync with; returns at once.
+    public static func sync() async throws {}
+
+    /// The manage-subscriptions sheet does not exist in the browser: throws
+    /// `StoreKitError.unsupported`.
+    @MainActor public static func showManageSubscriptions(in scene: UIWindowScene) async throws {
+        throw StoreKitError.unsupported
+    }
+
+    @MainActor public static func showManageSubscriptions(in scene: UIWindowScene, subscriptionGroupID: String) async throws {
+        throw StoreKitError.unsupported
+    }
+
+    /// The offer-code sheet does not exist in the browser: throws
+    /// `StoreKitError.unsupported`.
+    @MainActor public static func presentOfferCodeRedeemSheet(in scene: UIWindowScene) async throws {
+        throw StoreKitError.unsupported
+    }
+
+    /// Asks for a review: a no-op, as `requestReview` is.
+    @MainActor public static func requestReview(in scene: UIWindowScene) {}
+}
+
+/// The App Store region. The browser's is unknown: `current` is nil and
+/// `updates` ends at once.
+public struct Storefront: Identifiable, Hashable, Sendable {
+    public let countryCode: String
+    public let id: String
+    public var currency: Locale.Currency? { nil }
+
+    public static var current: Storefront? { get async { nil } }
+
+    public static var updates: Storefronts { Storefronts() }
+
+    public struct Storefronts: AsyncSequence, Sendable {
+        public typealias Element = Storefront
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            public mutating func next() async -> Storefront? { nil }
+        }
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
+    }
+}
+
+/// StoreKit 2's errors.
+public enum StoreKitError: LocalizedError, Sendable {
+    case unknown
+    case userCancelled
+    case networkError(URLError)
+    case systemError(any Error)
+    case notAvailableInStorefront
+    case notEntitled
+    case unsupported
+    case invalidPresentationContext
+
+    public var errorDescription: String? {
+        switch self {
+        case .unknown: "An unknown error occurred."
+        case .userCancelled: "The user cancelled."
+        case .networkError(let error): error.localizedDescription
+        case .systemError(let error): error.localizedDescription
+        case .notAvailableInStorefront: "The item is not available in this storefront."
+        case .notEntitled: "The app is not entitled to this."
+        case .unsupported: "The App Store is not available in the browser."
+        case .invalidPresentationContext: "There is no context to present the App Store's sheet in."
+        }
+    }
+}
+
+/// A purchase someone started on the App Store, outside the app. None
+/// arrive in the browser: `intents` ends at once.
+public struct PurchaseIntent: Identifiable, Equatable, Sendable {
+    public let product: Product
+    public let offer: Product.SubscriptionOffer?
+    public var id: Product.ID { product.id }
+
+    public static var intents: PurchaseIntents { PurchaseIntents() }
+
+    public struct PurchaseIntents: AsyncSequence, Sendable {
+        public typealias Element = PurchaseIntent
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            public mutating func next() async -> PurchaseIntent? { nil }
+        }
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
+    }
+}
+
+/// A message the App Store wants to show (a price increase, a billing
+/// issue). None arrive in the browser: `messages` ends at once.
+public struct Message: Hashable, Sendable {
+    public struct Reason: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let generic = Reason(rawValue: "generic")
+        public static let priceIncreaseConsent = Reason(rawValue: "priceIncreaseConsent")
+        public static let billingIssue = Reason(rawValue: "billingIssue")
+        public static let winBackOffer = Reason(rawValue: "winBackOffer")
+    }
+
+    public let reason: Reason
+
+    @MainActor public func display(in scene: UIWindowScene) throws {
+        throw StoreKitError.unsupported
+    }
+
+    public static var messages: Messages { Messages() }
+
+    public struct Messages: AsyncSequence, Sendable {
+        public typealias Element = Message
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            public mutating func next() async -> Message? { nil }
+        }
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
+    }
+}
+
+/// Shows an App Store message over the current scene (iOS 16), from the
+/// environment's `displayStoreKitMessage`. No message arrives in the
+/// browser; one passed in is not shown, which is not an error.
+public struct DisplayMessageAction: Sendable {
+    public init() {}
+
+    @MainActor public func callAsFunction(_ message: Message) throws {}
+}
+
+private struct _DisplayStoreKitMessageKey: EnvironmentKey {
+    static let defaultValue = DisplayMessageAction()
+}
+
+extension EnvironmentValues {
+    public var displayStoreKitMessage: DisplayMessageAction {
+        get { self[_DisplayStoreKitMessageKey.self] }
+        set { self[_DisplayStoreKitMessageKey.self] = newValue }
+    }
+}
+
+/// Links to buying outside the App Store (iOS 18.1). A web app is not
+/// eligible: `isEligible` is false and the notice and tokens are unsupported.
+public enum ExternalPurchaseCustomLink {
+    public struct NoticeType: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let browser = NoticeType(rawValue: "browser")
+        public static let withinApp = NoticeType(rawValue: "withinApp")
+    }
+
+    public enum NoticeResult: Hashable, Sendable {
+        case continued, cancelled
+    }
+
+    public struct Token: Hashable, Sendable {
+        public let value: String
+    }
+
+    public static var isEligible: Bool { get async { false } }
+
+    public static func token(for tokenType: String) async throws -> Token? {
+        throw StoreKitError.unsupported
+    }
+
+    @MainActor public static func showNotice(type: NoticeType) async throws -> NoticeResult {
+        throw StoreKitError.unsupported
+    }
+}