@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/StoreKit/StoreViews.swift

@@ -0,0 +1,428 @@
+// StoreKit's SwiftUI views and modifiers (iOS 17): `StoreView`,
+// `SubscriptionStoreView` and `ProductView`, their styles, and the sheets
+// and purchase callbacks. The browser has no App Store to load products
+// from, so each view shows what StoreKit shows when its products cannot be
+// loaded: the subscription store keeps its marketing content and says
+// subscriptions are unavailable, and a product view is in its
+// `.unavailable` state (which a custom `ProductViewStyle` draws). The sheets
+// (manage subscriptions, redeem an offer code, request a refund) cannot be
+// shown: presenting one sets its binding back to false, as dismissing it
+// would, and the purchase callbacks never run.
+
+import SwiftUI
+
+/// The note the store views show in place of products.
+struct _StoreUnavailableNote: View {
+    let text: String
+    var body: some View {
+        Text(text)
+            .font(.footnote)
+            .foregroundStyle(.secondary)
+            .multilineTextAlignment(.center)
+            .padding()
+    }
+}
+
+// MARK: - StoreView
+
+/// A store of in-app products. In the browser there are none to show.
+public struct StoreView<Icon: View, PlaceholderIcon: View>: View {
+    let productIDs: [Product.ID]
+
+    public init(ids: some Collection<Product.ID>, prefersPromotionalIcon: Bool = false, @ViewBuilder icon: @escaping (Product) -> Icon, @ViewBuilder placeholderIcon: () -> PlaceholderIcon) {
+        productIDs = Array(ids)
+    }
+
+    public var body: some View {
+        _StoreUnavailableNote(text: "In-app purchases are not available in the browser.")
+    }
+}
+
+extension StoreView where PlaceholderIcon == EmptyView {
+    public init(products: some Collection<Product>, prefersPromotionalIcon: Bool = false, @ViewBuilder icon: @escaping (Product) -> Icon) {
+        productIDs = products.map(\.id)
+    }
+}
+
+extension StoreView where Icon == EmptyView, PlaceholderIcon == EmptyView {
+    public init(ids: some Collection<Product.ID>, prefersPromotionalIcon: Bool = false) {
+        productIDs = Array(ids)
+    }
+
+    public init(products: some Collection<Product>, prefersPromotionalIcon: Bool = false) {
+        productIDs = products.map(\.id)
+    }
+}
+
+// MARK: - SubscriptionStoreView
+
+/// A store of auto-renewable subscriptions: its marketing content, and a
+/// note that subscriptions are not available in the browser.
+public struct SubscriptionStoreView<Content: View>: View {
+    let content: Content
+
+    public init(productIDs: some Collection<Product.ID>, @ViewBuilder marketingContent: () -> Content) {
+        content = marketingContent()
+    }
+
+    public init(groupID: String, @ViewBuilder marketingContent: () -> Content) {
+        content = marketingContent()
+    }
+
+    /// The group's subscriptions that relate to the current one as
+    /// `visibleRelationships` says; there is no current one in the browser.
+    public init(groupID: String, visibleRelationships: Product.SubscriptionRelationship, @ViewBuilder marketingContent: () -> Content) {
+        content = marketingContent()
+    }
+
+    public init(subscriptions: some Collection<Product>, @ViewBuilder marketingContent: () -> Content) {
+        content = marketingContent()
+    }
+
+    public var body: some View {
+        VStack(spacing: 16) {
+            content
+            _StoreUnavailableNote(text: "Subscriptions are not available in the browser.")
+        }
+    }
+}
+
+/// The marketing content StoreKit makes from the App Store's metadata: none
+/// in the browser.
+public struct AutomaticSubscriptionStoreMarketingContent: View {
+    public var body: some View { EmptyView() }
+}
+
+extension SubscriptionStoreView where Content == AutomaticSubscriptionStoreMarketingContent {
+    public init(productIDs: some Collection<Product.ID>) {
+        content = AutomaticSubscriptionStoreMarketingContent()
+    }
+
+    public init(groupID: String) {
+        content = AutomaticSubscriptionStoreMarketingContent()
+    }
+
+    public init(groupID: String, visibleRelationships: Product.SubscriptionRelationship) {
+        content = AutomaticSubscriptionStoreMarketingContent()
+    }
+
+    public init(subscriptions: some Collection<Product>) {
+        content = AutomaticSubscriptionStoreMarketingContent()
+    }
+}
+
+/// Content of a subscription store (iOS 18): the groups of subscription
+/// options StoreKit would list. There are none to list in the browser.
+public protocol StoreContent {}
+
+@resultBuilder
+public enum StoreContentBuilder {
+    public static func buildBlock() -> _EmptyStoreContent { _EmptyStoreContent() }
+    public static func buildBlock<C: StoreContent>(_ content: C) -> C { content }
+    public static func buildBlock<each C: StoreContent>(_ content: repeat each C) -> _TupleStoreContent<repeat each C> { _TupleStoreContent(repeat each content) }
+    public static func buildExpression<C: StoreContent>(_ content: C) -> C { content }
+}
+
+public struct _EmptyStoreContent: StoreContent {}
+
+public struct _TupleStoreContent<each C: StoreContent>: StoreContent {
+    let content: (repeat each C)
+    init(_ content: repeat each C) { self.content = (repeat each content) }
+}
+
+/// A subscription store's content, as a view.
+public struct SubscriptionStoreContentView<C: StoreContent>: View {
+    let content: C
+    public var body: some View { EmptyView() }
+}
+
+extension SubscriptionStoreView {
+    public init<C: StoreContent>(productIDs: some Collection<Product.ID>, @StoreContentBuilder content: () -> C) where Content == SubscriptionStoreContentView<C> {
+        self.content = SubscriptionStoreContentView(content: content())
+    }
+
+    public init<C: StoreContent>(groupID: String, @StoreContentBuilder content: () -> C) where Content == SubscriptionStoreContentView<C> {
+        self.content = SubscriptionStoreContentView(content: content())
+    }
+}
+
+/// Where a background goes in a subscription store.
+extension ContainerBackgroundPlacement {
+    public static let subscriptionStore = ContainerBackgroundPlacement(_name: "subscriptionStore")
+    public static let subscriptionStoreFullHeight = ContainerBackgroundPlacement(_name: "subscriptionStoreFullHeight")
+    public static let subscriptionStoreHeader = ContainerBackgroundPlacement(_name: "subscriptionStoreHeader")
+}
+
+/// How a subscription store labels its subscribe button.
+public struct SubscriptionStoreButtonLabel: Hashable, Sendable {
+    let name: String
+    public static let automatic = SubscriptionStoreButtonLabel(name: "automatic")
+    public static let multiline = SubscriptionStoreButtonLabel(name: "multiline")
+    public static let singleLine = SubscriptionStoreButtonLabel(name: "singleLine")
+    public static let action = SubscriptionStoreButtonLabel(name: "action")
+    public static let displayName = SubscriptionStoreButtonLabel(name: "displayName")
+    public static let price = SubscriptionStoreButtonLabel(name: "price")
+}
+
+// MARK: - ProductView
+
+/// What a product view style draws: in the browser, always a product that
+/// could not be loaded.
+public struct ProductViewStyleConfiguration {
+    public enum State {
+        case loading
+        case unavailable
+        case success(Product)
+        case failure(any Error)
+    }
+
+    public struct Icon: View {
+        public var body: some View { EmptyView() }
+    }
+
+    public let productID: Product.ID
+    public let state: State
+    public let icon = Icon()
+    public var product: Product? {
+        if case .success(let product) = state { return product }
+        return nil
+    }
+    public var hasCurrentEntitlement: Bool { false }
+
+    /// Nothing to buy: does nothing.
+    public func purchase() {}
+}
+
+/// How a `ProductView` draws its product.
+public protocol ProductViewStyle {
+    associatedtype Body: View
+    typealias Configuration = ProductViewStyleConfiguration
+    @ViewBuilder @MainActor func makeBody(configuration: Configuration) -> Body
+}
+
+/// The standard look: in the browser, the unavailable note.
+public struct AutomaticProductViewStyle: ProductViewStyle {
+    public init() {}
+    public func makeBody(configuration: Configuration) -> some View {
+        _StoreUnavailableNote(text: "This item is not available in the browser.")
+    }
+}
+
+extension ProductViewStyle where Self == AutomaticProductViewStyle {
+    public static var automatic: AutomaticProductViewStyle { AutomaticProductViewStyle() }
+    public static var compact: AutomaticProductViewStyle { AutomaticProductViewStyle() }
+    public static var regular: AutomaticProductViewStyle { AutomaticProductViewStyle() }
+    public static var large: AutomaticProductViewStyle { AutomaticProductViewStyle() }
+}
+
+struct _AnyProductViewStyle {
+    let make: @MainActor (ProductViewStyleConfiguration) -> any View
+}
+
+private struct _ProductViewStyleKey: EnvironmentKey {
+    static var defaultValue: _AnyProductViewStyle? { nil }
+}
+
+extension EnvironmentValues {
+    var _productViewStyle: _AnyProductViewStyle? {
+        get { self[_ProductViewStyleKey.self] }
+        set { self[_ProductViewStyleKey.self] = newValue }
+    }
+}
+
+/// One in-app product. In the browser it cannot be loaded: the view's style
+/// draws the `.unavailable` state.
+public struct ProductView<Icon: View, PlaceholderIcon: View>: View {
+    let productID: Product.ID
+    /// `ProductView(configuration)` inside a style draws the standard look.
+    let standard: Bool
+    @Environment(\._productViewStyle) private var style
+
+    public init(id: Product.ID, prefersPromotionalIcon: Bool = false, @ViewBuilder icon: () -> Icon, @ViewBuilder placeholderIcon: () -> PlaceholderIcon) {
+        productID = id
+        standard = false
+    }
+
+    public var body: some View {
+        let configuration = ProductViewStyleConfiguration(productID: productID, state: .unavailable)
+        if !standard, let style {
+            AnyView(style.make(configuration))
+        } else {
+            AutomaticProductViewStyle().makeBody(configuration: configuration)
+        }
+    }
+}
+
+extension ProductView where PlaceholderIcon == EmptyView {
+    public init(_ product: Product, prefersPromotionalIcon: Bool = false, @ViewBuilder icon: () -> Icon) {
+        productID = product.id
+        standard = false
+    }
+
+    public init(id: Product.ID, prefersPromotionalIcon: Bool = false, @ViewBuilder icon: () -> Icon) {
+        productID = id
+        standard = false
+    }
+}
+
+extension ProductView where Icon == EmptyView, PlaceholderIcon == EmptyView {
+    public init(id: Product.ID, prefersPromotionalIcon: Bool = false) {
+        productID = id
+        standard = false
+    }
+
+    public init(_ product: Product, prefersPromotionalIcon: Bool = false) {
+        productID = product.id
+        standard = false
+    }
+}
+
+extension ProductView where Icon == ProductViewStyleConfiguration.Icon, PlaceholderIcon == EmptyView {
+    /// The standard look of a style's configuration.
+    public init(_ configuration: ProductViewStyleConfiguration) {
+        productID = configuration.productID
+        standard = true
+    }
+}
+
+// MARK: - Modifiers
+
+nonisolated extension View {
+    @MainActor
+    public func productViewStyle<S: ProductViewStyle>(_ style: S) -> some View {
+        environment(\._productViewStyle, _AnyProductViewStyle(make: { style.makeBody(configuration: $0) }))
+    }
+
+    /// Accepted; the browser's subscription store has no button to label.
+    public func subscriptionStoreButtonLabel(_ label: SubscriptionStoreButtonLabel) -> some View { self }
+
+    /// Accepted; the browser's subscription store has no options to put on a background.
+    public func subscriptionStorePickerItemBackground<S: ShapeStyle>(_ style: S) -> some View { self }
+
+    /// Accepted; the browser's subscription store has no options to put on a background.
+    public func subscriptionStorePickerItemBackground<S: ShapeStyle, B: Shape>(_ style: S, in shape: B) -> some View { self }
+
+    /// Never called: nothing can be bought in the browser.
+    public func onInAppPurchaseStart(perform action: ((Product) async -> Void)?) -> some View { self }
+
+    /// Never called: nothing can be bought in the browser.
+    public func onInAppPurchaseCompletion(perform action: ((Product, Result<Product.PurchaseResult, any Error>) async -> Void)?) -> some View { self }
+
+    /// The manage-subscriptions sheet cannot be shown: presenting it sets
+    /// `isPresented` back to false.
+    @MainActor
+    public func manageSubscriptionsSheet(isPresented: Binding<Bool>) -> some View {
+        _dismissingAtOnce(isPresented)
+    }
+
+    @MainActor
+    public func manageSubscriptionsSheet(isPresented: Binding<Bool>, subscriptionGroupID: String) -> some View {
+        _dismissingAtOnce(isPresented)
+    }
+
+    /// The offer-code sheet cannot be shown: presenting it sets `isPresented`
+    /// back to false and reports `StoreKitError.unsupported`.
+    @MainActor
+    public func offerCodeRedemption(isPresented: Binding<Bool>, onCompletion: @escaping (Result<Void, any Error>) -> Void = { _ in }) -> some View {
+        onChange(of: isPresented.wrappedValue) { _, presented in
+            guard presented else { return }
+            isPresented.wrappedValue = false
+            onCompletion(.failure(StoreKitError.unsupported))
+        }
+    }
+
+    /// The refund sheet cannot be shown: presenting it sets `isPresented`
+    /// back to false and reports `RefundRequestError.failed`.
+    @MainActor
+    public func refundRequestSheet(for transactionID: UInt64, isPresented: Binding<Bool>, onDismiss: ((Result<Transaction.RefundRequestStatus, Transaction.RefundRequestError>) -> Void)? = nil) -> some View {
+        onChange(of: isPresented.wrappedValue) { _, presented in
+            guard presented else { return }
+            isPresented.wrappedValue = false
+            onDismiss?(.failure(.failed))
+        }
+    }
+
+    /// Runs `action` once with the (empty) subscription statuses of the group.
+    @MainActor
+    public func subscriptionStatusTask(for groupID: String, priority: TaskPriority = .medium, action: @escaping (EntitlementTaskState<[Product.SubscriptionInfo.Status]>) async -> Void) -> some View {
+        task { await action(.success([])) }
+    }
+
+    /// Runs `action` once with no entitlement.
+    @MainActor
+    public func currentEntitlementTask(for productID: String, priority: TaskPriority = .medium, action: @escaping (EntitlementTaskState<VerificationResult<Transaction>?>) async -> Void) -> some View {
+        task { await action(.success(nil)) }
+    }
+
+    @MainActor
+    func _dismissingAtOnce(_ isPresented: Binding<Bool>) -> some View {
+        onChange(of: isPresented.wrappedValue) { _, presented in
+            if presented { isPresented.wrappedValue = false }
+        }
+    }
+}
+
+/// What an entitlement task found.
+public enum EntitlementTaskState<Value> {
+    case loading
+    case failure(any Error)
+    case success(Value)
+
+    public var transaction: Value? {
+        if case .success(let value) = self { return value }
+        return nil
+    }
+
+    /// The value the task found, if it succeeded.
+    public var value: Value? {
+        if case .success(let value) = self { return value }
+        return nil
+    }
+
+    /// The state with a found value transformed; a transform that throws
+    /// makes it a failure.
+    public func map<T>(_ transform: (Value) async throws -> T) async -> EntitlementTaskState<T> {
+        switch self {
+        case .loading: return .loading
+        case .failure(let error): return .failure(error)
+        case .success(let value):
+            do { return .success(try await transform(value)) } catch { return .failure(error) }
+        }
+    }
+}
+
+// MARK: - Subscription relationships and store buttons
+
+extension Product {
+    /// Which of a group's subscriptions a store shows, relative to the
+    /// customer's current one (iOS 17).
+    public struct SubscriptionRelationship: OptionSet, Hashable, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let upgrade = SubscriptionRelationship(rawValue: 1)
+        public static let downgrade = SubscriptionRelationship(rawValue: 2)
+        public static let crossgrade = SubscriptionRelationship(rawValue: 4)
+        public static let current = SubscriptionRelationship(rawValue: 8)
+        public static let all: SubscriptionRelationship = [.upgrade, .downgrade, .crossgrade, .current]
+    }
+}
+
+/// The buttons a store view can show besides its products.
+public struct StoreButtonKind: Hashable, Sendable {
+    let name: String
+    public static let cancellation = StoreButtonKind(name: "cancellation")
+    public static let restorePurchases = StoreButtonKind(name: "restorePurchases")
+    public static let redeemCode = StoreButtonKind(name: "redeemCode")
+    public static let signIn = StoreButtonKind(name: "signIn")
+    public static let policies = StoreButtonKind(name: "policies")
+}
+
+nonisolated extension View {
+    /// Accepted; the browser's store views show none of these buttons.
+    public func storeButton(_ visibility: Visibility, for buttonKinds: StoreButtonKind...) -> some View { self }
+
+    /// Accepted; the browser's subscription store lists no subscriptions to give an icon.
+    public func subscriptionStoreControlIcon<V: View>(
+        @ViewBuilder icon: @escaping (Product, Product.SubscriptionInfo) -> V
+    ) -> some View { self }
+}

package/Sources/StoreKit/Transactions.swift

@@ -0,0 +1,197 @@
+// StoreKit 2's transactions, as code that reads them is written: the types,
+// their properties and the sequences of them. A web app sells nothing through
+// the App Store, so there are never any: `Transaction.updates`,
+// `currentEntitlements`, `all` and `unfinished` end at once, and
+// `latest(for:)` answers nil. Analytics and paywall packages (TelemetryDeck,
+// RevenueCat) compile, and see no purchases.
+
+@_exported import Foundation
+
+/// A StoreKit result whose signature has been checked.
+public enum VerificationResult<SignedType: Sendable>: Sendable {
+    case unverified(SignedType, VerificationError)
+    case verified(SignedType)
+
+    public enum VerificationError: Error, Hashable, Sendable {
+        case revokedCertificate, invalidCertificateChain, invalidDeviceVerification, invalidEncoding, invalidSignature, missingRequiredProperties
+    }
+
+    public var unsafePayloadValue: SignedType {
+        switch self {
+        case .unverified(let value, _), .verified(let value): value
+        }
+    }
+
+    public var payloadValue: SignedType {
+        get throws {
+            switch self {
+            case .verified(let value): value
+            case .unverified(_, let error): throw error
+            }
+        }
+    }
+
+    public var jwsRepresentation: String { "" }
+    public var headerData: Data { Data() }
+    public var payloadData: Data { Data() }
+    public var signatureData: Data { Data() }
+    public var signedData: Data { Data() }
+    public var signedDate: Date { Date(timeIntervalSince1970: 0) }
+    public var deviceVerification: Data { Data() }
+    public var deviceVerificationNonce: UUID { UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) }
+}
+
+/// A purchase. There are none in the browser; the type is here for the code that reads them.
+public struct Transaction: Identifiable, Hashable, Sendable {
+    public struct OwnershipType: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let purchased = OwnershipType(rawValue: "PURCHASED")
+        public static let familyShared = OwnershipType(rawValue: "FAMILY_SHARED")
+    }
+
+    public struct RevocationReason: Hashable, Sendable, RawRepresentable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let developerIssue = RevocationReason(rawValue: 1)
+        public static let other = RevocationReason(rawValue: 0)
+        public var localizedDescription: String { "\(rawValue)" }
+    }
+
+    /// Why the transaction happened (iOS 17): a purchase or a renewal.
+    public struct Reason: Hashable, Sendable, RawRepresentable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let purchase = Reason(rawValue: "PURCHASE")
+        public static let renewal = Reason(rawValue: "RENEWAL")
+    }
+
+    /// The kind of offer a transaction used.
+    public struct OfferType: Hashable, Sendable, RawRepresentable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let introductory = OfferType(rawValue: 1)
+        public static let promotional = OfferType(rawValue: 2)
+        public static let code = OfferType(rawValue: 3)
+        public static let winBack = OfferType(rawValue: 4)
+    }
+
+    public struct Offer: Hashable, Sendable {
+        public struct PaymentMode: Hashable, Sendable, RawRepresentable {
+            public let rawValue: String
+            public init(rawValue: String) { self.rawValue = rawValue }
+            public static let freeTrial = PaymentMode(rawValue: "FREE_TRIAL")
+            public static let payAsYouGo = PaymentMode(rawValue: "PAY_AS_YOU_GO")
+            public static let payUpFront = PaymentMode(rawValue: "PAY_UP_FRONT")
+        }
+
+        public let id: String?
+        public let type: OfferType
+        public let paymentMode: PaymentMode?
+    }
+
+    /// How a refund request ended.
+    public enum RefundRequestStatus: Hashable, Sendable {
+        case success, userCancelled
+    }
+
+    public enum RefundRequestError: Error, Hashable, Sendable {
+        case duplicateRequest, failed, ineligible
+    }
+
+    public let id: UInt64
+    public let originalID: UInt64
+    public let webOrderLineItemID: String?
+    public let productID: String
+    public let productType: Product.ProductType
+    public let appBundleID: String
+    public let purchaseDate: Date
+    public let originalPurchaseDate: Date
+    public let expirationDate: Date?
+    public let revocationDate: Date?
+    public let revocationReason: RevocationReason?
+    public let isUpgraded: Bool
+    public let offer: Offer?
+    public let price: Decimal?
+    public let currency: Locale.Currency?
+    public let storefront: Storefront
+    public let environment: AppStore.Environment
+    public let ownershipType: OwnershipType
+    public let subscriptionGroupID: String?
+    public let purchasedQuantity: Int
+    public let appAccountToken: UUID?
+    public let signedDate: Date
+    public let reason: Reason
+    /// The billing plan the subscription was bought with (iOS 26.4).
+    public let billingPlanType: Product.SubscriptionInfo.BillingPlanType?
+    public let deviceVerification: Data
+    public let deviceVerificationNonce: UUID
+
+    public var offerType: OfferType? { offer?.type }
+    public var offerID: String? { offer?.id }
+    public var offerPaymentModeStringRepresentation: String? { offer?.paymentMode?.rawValue }
+    public var currencyCode: String? { currency?.identifier }
+    public var storefrontCountryCode: String { storefront.countryCode }
+    public var environmentStringRepresentation: String { environment.rawValue }
+    public var jsonRepresentation: Data { Data() }
+
+    public func finish() async {}
+
+    /// Transactions as they happen: none in the browser.
+    public static var updates: Transactions { Transactions() }
+    public static var all: Transactions { Transactions() }
+    public static var currentEntitlements: Transactions { Transactions() }
+    public static var unfinished: Transactions { Transactions() }
+    public static func latest(for productID: String) async -> VerificationResult<Transaction>? { nil }
+    public static func currentEntitlement(for productID: String) async -> VerificationResult<Transaction>? { nil }
+    public static func currentEntitlements(for productID: String) -> Transactions { Transactions() }
+
+    /// Never reached in the browser (there are no transactions to refund);
+    /// it fails with `RefundRequestError.failed`.
+    @MainActor public static func beginRefundRequest(for transactionID: UInt64, in scene: _StoreKitScene) async throws -> RefundRequestStatus {
+        throw RefundRequestError.failed
+    }
+
+    @MainActor public func beginRefundRequest(in scene: _StoreKitScene) async throws -> RefundRequestStatus {
+        throw RefundRequestError.failed
+    }
+
+    /// A sequence of transactions; it ends at once.
+    public struct Transactions: AsyncSequence, Sendable {
+        public typealias Element = VerificationResult<Transaction>
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            public mutating func next() async -> VerificationResult<Transaction>? { nil }
+        }
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
+    }
+
+    public static func == (lhs: Transaction, rhs: Transaction) -> Bool { lhs.id == rhs.id }
+    public func hash(into hasher: inout Hasher) { hasher.combine(id) }
+}
+
+/// The app's own purchase from the App Store. A web app was not bought there:
+/// `AppTransaction.shared` throws `StoreKitError.unsupported`.
+public struct AppTransaction: Hashable, Sendable {
+    public let appID: UInt64?
+    public let appVersionID: UInt64?
+    public let appVersion: String
+    public let bundleID: String
+    public let environment: AppStore.Environment
+    public let originalAppVersion: String
+    public let originalPurchaseDate: Date
+    public let preorderDate: Date?
+    public let deviceVerification: Data
+    public let deviceVerificationNonce: UUID
+    public let signedDate: Date
+    public let appTransactionID: String
+    public let originalPlatform: AppStore.Platform
+    public var jsonRepresentation: Data { Data() }
+
+    public static var shared: VerificationResult<AppTransaction> {
+        get async throws { throw StoreKitError.unsupported }
+    }
+
+    public static func refresh() async throws -> VerificationResult<AppTransaction> {
+        throw StoreKitError.unsupported
+    }
+}

package/Sources/SwiftData/Macros.swift

@@ -0,0 +1,58 @@
+// The macros an app writes, declared as in Apple's SwiftData. Their
+// expansions live in Sources/SwiftDataMacros.
+
+// Re-exported, as Apple's SwiftData does: `@Model` expands to
+// `Observation.ObservationRegistrar`, so a model file that imports only
+// SwiftData (Hacking with SwiftUI's HotProspects) must see the module; and
+// such a file uses `Date` and `UUID` without importing Foundation (Backyard
+// Birds' DataGeneration).
+@_exported import Observation
+@_exported import Foundation
+
+/// Makes a class a persistent model: its stored properties are saved by a
+/// `ModelContext` and observed like an `@Observable` class's.
+@attached(member, names: named(_$backingData), named(persistentBackingData), named(schemaMetadata), named(init), named(_$observationRegistrar))
+@attached(memberAttribute)
+@attached(extension, conformances: PersistentModel)
+public macro Model() = #externalMacro(module: "SwiftDataMacros", type: "ModelMacro")
+
+/// Added by `@Model` to each persisted property.
+@attached(accessor, names: named(init), named(get), named(set))
+@attached(peer, names: prefixed(_))
+public macro _PersistedProperty() = #externalMacro(module: "SwiftDataMacros", type: "PersistedPropertyMacro")
+
+/// Options for a persisted attribute (`.unique`, `originalName:`).
+@attached(peer)
+public macro Attribute(_ options: Schema.Attribute.Option..., originalName: String? = nil, hashModifier: String? = nil) = #externalMacro(module: "SwiftDataMacros", type: "MarkerMacro")
+
+/// Options for a relationship: its delete rule and inverse.
+@attached(peer)
+public macro Relationship(
+    _ options: Schema.Relationship.Option...,
+    deleteRule: Schema.Relationship.DeleteRule = .nullify,
+    minimumModelCount: Int? = 0,
+    maximumModelCount: Int? = 0,
+    originalName: String? = nil,
+    inverse: AnyKeyPath? = nil,
+    hashModifier: String? = nil
+) = #externalMacro(module: "SwiftDataMacros", type: "MarkerMacro")
+
+/// A property of a model that is not saved. It needs an initial value.
+@attached(peer)
+public macro Transient() = #externalMacro(module: "SwiftDataMacros", type: "MarkerMacro")
+
+/// Uniqueness constraints over a model's properties (iOS 18). Accepted; use
+/// `@Attribute(.unique)` for a constraint the store enforces.
+@freestanding(declaration)
+public macro Unique<T>(_ constraints: [PartialKeyPath<T>]...) = #externalMacro(module: "SwiftDataMacros", type: "ConstraintMacro")
+
+/// Indexes over a model's properties (iOS 18). Accepted and unused: the store
+/// keeps its records in memory.
+@freestanding(declaration)
+public macro Index<T>(_ indices: [PartialKeyPath<T>]...) = #externalMacro(module: "SwiftDataMacros", type: "ConstraintMacro")
+
+/// Makes an actor a `ModelActor`: it gains `modelContainer`, an executor
+/// with a context of its own, and `init(modelContainer:)`.
+@attached(member, names: named(modelExecutor), named(modelContainer), named(init))
+@attached(extension, conformances: ModelActor)
+public macro ModelActor() = #externalMacro(module: "SwiftDataMacros", type: "ModelActorMacro")