@tinkerlandai/longplay-react-native 0.10.11 → 0.10.13

package/native-sdk/ios/FeatureClient.swift

@@ -9,6 +9,68 @@ public struct IndianaFeatureResult: Codable, Sendable {
     public let experimentResult: IndianaJSON?
 }
 
+/// Readiness and pending calls of one evaluator host, confined to the main actor. Stopping fails every waiter with its
+/// cause: `identityChanged` only for an identity change or close, otherwise the host's actual failure.
+@MainActor final class IndianaFeatureCalls {
+    private let timeout: UInt64
+    private var readinessSignalled = false
+    private var waiting: [UUID: CheckedContinuation<Void, any Error>] = [:]
+    private var pending: [UUID: CheckedContinuation<IndianaJSON, any Error>] = [:]
+    private(set) var failure: (any Error)?
+    init(timeout nanoseconds: UInt64 = 45_000_000_000) { timeout = nanoseconds }
+    var ready: Bool { readinessSignalled && failure == nil }
+    /// Calls currently waiting for readiness or a result.
+    var waiters: Int { waiting.count + pending.count }
+    /// SDK errors keep their identity; a platform failure of the packaged renderer host reports `invalidResponse`, the
+    /// renderer-failure error of the other Swift hosts.
+    static func hostFailure(_ error: any Error) -> any Error {
+        error is IndianaClientError || error is IndianaFunnelError || error is IndianaStoreError ? error : IndianaClientError.invalidResponse
+    }
+    func markReady() throws {
+        if let failure { throw failure }
+        readinessSignalled = true
+        let current = waiting; waiting = [:]; for continuation in current.values { continuation.resume() }
+    }
+    /// Returns false when already stopped; the first cause wins.
+    @discardableResult func stop(_ cause: any Error) -> Bool {
+        guard failure == nil else { return false }
+        failure = cause
+        let readiness = waiting, calls = pending; waiting = [:]; pending = [:]
+        for continuation in readiness.values { continuation.resume(throwing: cause) }
+        for continuation in calls.values { continuation.resume(throwing: cause) }
+        return true
+    }
+    /// Each wait for readiness and for the result is bounded separately; a timeout fails only this call.
+    func call(_ send: (UUID) -> Void) async throws -> IndianaJSON {
+        if let failure { throw failure }
+        let delay = timeout
+        if !readinessSignalled {
+            let waiter = UUID()
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, any Error>) in
+                waiting[waiter] = continuation
+                Task { [weak self] in
+                    try? await Task.sleep(nanoseconds: delay)
+                    self?.waiting.removeValue(forKey: waiter)?.resume(throwing: IndianaClientError.temporaryUnavailable)
+                }
+            }
+        }
+        if let failure { throw failure }
+        let id = UUID()
+        return try await withCheckedThrowingContinuation { continuation in
+            pending[id] = continuation
+            send(id)
+            Task { [weak self] in
+                try? await Task.sleep(nanoseconds: delay)
+                self?.pending.removeValue(forKey: id)?.resume(throwing: IndianaClientError.temporaryUnavailable)
+            }
+        }
+    }
+    func settle(_ id: UUID, result: IndianaJSON, failed: Bool) {
+        guard let continuation = pending.removeValue(forKey: id) else { return }
+        if failed { continuation.resume(throwing: IndianaClientError.invalidResponse) } else { continuation.resume(returning: result) }
+    }
+}
+
 #if canImport(UIKit)
 import UIKit
 
@@ -19,18 +81,18 @@ import UIKit
     private let attributes: [String: IndianaJSON]
     private let operation: @Sendable (IndianaCustomerOperation, [String: IndianaJSON]) async throws -> IndianaJSON
     private var host: IndianaBundledWebView!
+    private let calls = IndianaFeatureCalls()
     public var onError: (@MainActor (Error) -> Void)?
-    private var ready = false
-    private var stopped = false
-    private var readiness: [CheckedContinuation<Void, Error>] = []
-    private var pending: [UUID: CheckedContinuation<IndianaJSON, Error>] = [:]
     init(configuration: IndianaConfiguration, attributes: [String: IndianaJSON], operation: @escaping @Sendable (IndianaCustomerOperation, [String: IndianaJSON]) async throws -> IndianaJSON) {
         self.configuration = configuration; self.attributes = attributes; self.operation = operation
         host = IndianaBundledWebView(label: "Longplay Feature evaluator", dispatch: { [weak self] method, payload in
             guard let self else { throw IndianaClientError.identityChanged }; return try await self.dispatch(method, payload)
-        }, onError: { [weak self] error in guard let self else { return }; if !self.ready { self.close() } else { self.onError?(error) } })
+        }, onError: { [weak self] error in
+            guard let self else { return }
+            // Before readiness a host failure ends this client with its actual cause rather than an identity change.
+            if !self.calls.ready { self.stop(IndianaFeatureCalls.hostFailure(error)) } else { self.onError?(error) }
+        })
         host.start()
-        Task { [weak self] in try? await Task.sleep(nanoseconds: 45_000_000_000); if let self, !self.ready { self.close() } }
     }
     public func evalFeature(_ key: String) async throws -> IndianaFeatureResult {
         let value = try await call(["method": .string("evalFeature"), "key": .string(key)])
@@ -44,41 +106,25 @@ import UIKit
     public func setAttributes(_ value: [String: IndianaJSON]) async throws { _ = try await call(["method": .string("setAttributes"), "attributes": .object(value)]) }
     public func refresh() async throws { _ = try await call(["method": .string("refresh")]) }
     public func flush() async throws { _ = try await call(["method": .string("flush")]) }
-    public func close() {
-        guard !stopped else { return }; stopped = true; host?.destroy()
-        let waiting = readiness; readiness = []; for continuation in waiting { continuation.resume(throwing: IndianaClientError.identityChanged) }
-        let calls = pending; pending = [:]; for continuation in calls.values { continuation.resume(throwing: IndianaClientError.identityChanged) }
-    }
+    public func close() { stop(IndianaClientError.identityChanged) }
+    private func stop(_ cause: any Error) { if calls.stop(cause) { host?.destroy() } }
     private func call(_ command: [String: IndianaJSON]) async throws -> IndianaJSON {
-        guard !stopped else { throw IndianaClientError.identityChanged }
-        if !ready { try await withCheckedThrowingContinuation { readiness.append($0) } }
-        guard !stopped else { throw IndianaClientError.identityChanged }
-        let id = UUID()
-        return try await withCheckedThrowingContinuation { continuation in
-            pending[id] = continuation
-            host.send(.object(["event": .string("feature_call"), "id": .string(id.uuidString.lowercased()), "input": .object(command)]))
-            Task { [weak self] in
-                try? await Task.sleep(nanoseconds: 45_000_000_000)
-                self?.pending.removeValue(forKey: id)?.resume(throwing: IndianaClientError.temporaryUnavailable)
-            }
-        }
+        try await calls.call { id in host.send(.object(["event": .string("feature_call"), "id": .string(id.uuidString.lowercased()), "input": .object(command)])) }
     }
     private func dispatch(_ method: String, _ value: IndianaJSON) async throws -> IndianaJSON {
         switch method {
         case "ready":
             host.send(.object(["event": .string("init"), "surface": .string("features"), "scope": .object(["projectId": .string(configuration.scope.projectId.uuidString.lowercased()), "environment": .string(configuration.scope.environment.rawValue)]), "apiOrigin": .string(configuration.apiOrigin), "attributes": .object(attributes)])); return .null
         case "featureOperation":
-            guard !stopped, let name = value.object?["operation"]?.string,
+            guard calls.failure == nil, let name = value.object?["operation"]?.string,
                   ["getFeatures", "evaluateFeatures", "trackEvents"].contains(name), let selected = IndianaCustomerOperation(rawValue: name),
                   let input = value.object?["input"]?.object else { throw IndianaFunnelError.invalidCommand }
             return try await operation(selected, input)
         case "featuresReady":
-            guard !stopped else { throw IndianaClientError.identityChanged }; ready = true
-            let waiting = readiness; readiness = []; for continuation in waiting { continuation.resume() }; return .null
+            try calls.markReady(); return .null
         case "featureResult":
-            guard !stopped, let id = value.object?["id"]?.string.flatMap(UUID.init(uuidString:)), let continuation = pending.removeValue(forKey: id) else { return .null }
-            if value.object?["error"] != nil { continuation.resume(throwing: IndianaClientError.invalidResponse) }
-            else { continuation.resume(returning: value.object?["result"] ?? .null) }; return .null
+            guard let id = value.object?["id"]?.string.flatMap(UUID.init(uuidString:)) else { return .null }
+            calls.settle(id, result: value.object?["result"] ?? .null, failed: value.object?["error"] != nil); return .null
         default: throw IndianaFunnelError.invalidCommand
         }
     }

package/native-sdk/ios/IndianaClient.swift

@@ -162,11 +162,9 @@ public actor IndianaClient {
     private var pushObservationID = UUID()
     public private(set) var pushSynchronizationError: IndianaClientError?
     private let nativeStore: any IndianaAppleStore
-    private let nativeStorage: any IndianaNativePendingStorage
     private let durableFunnels: Bool
     private var storeRestorePending: [String: (UUID, Data)] = [:]
     private var recoveringNative = false
-    private var nativeReceiptPending: [UUID: (UUID, Data)] = [:]
     private struct WeakFunnel { weak var value: IndianaFunnelSession? }
     private var funnels: [WeakFunnel] = []
     private struct WeakPaywall { weak var value: IndianaPaywallSession? }
@@ -177,8 +175,8 @@ public actor IndianaClient {
     private struct WeakFeature { weak var value: IndianaFeatureClient? }
     private var featuresClients: [WeakFeature] = []
     #endif
-    public init(configuration: IndianaConfiguration, sessionConfiguration: URLSessionConfiguration = .ephemeral) { self.configuration = configuration; self.http = IndianaSessionTransport(IndianaURLTransport(configuration: configuration, sessionConfiguration: sessionConfiguration), scope: configuration.scope); self.nativeStore = AppleStorefront(); self.nativeStorage = IndianaNativePendingKeychain(scope: configuration.scope); self.durableFunnels = true }
-    init(configuration: IndianaConfiguration, http: any IndianaHTTP, store: (any IndianaAppleStore)? = nil, nativeStorage: (any IndianaNativePendingStorage)? = nil, publicPaywallContent: (@Sendable (IndianaJSON) async throws -> IndianaJSON)? = nil, sessionNow: @escaping @Sendable () -> Date = { Date() }) { self.publicPaywallContent = publicPaywallContent; self.configuration = configuration; self.http = IndianaSessionTransport(http, scope: configuration.scope, now: sessionNow); self.nativeStore = store ?? AppleStorefront(); self.nativeStorage = nativeStorage ?? IndianaNativePendingKeychain(scope: configuration.scope); self.durableFunnels = false }
+    public init(configuration: IndianaConfiguration, sessionConfiguration: URLSessionConfiguration = .ephemeral) { self.configuration = configuration; self.http = IndianaSessionTransport(IndianaURLTransport(configuration: configuration, sessionConfiguration: sessionConfiguration), scope: configuration.scope); self.nativeStore = AppleStorefront(); self.durableFunnels = true }
+    init(configuration: IndianaConfiguration, http: any IndianaHTTP, store: (any IndianaAppleStore)? = nil, publicPaywallContent: (@Sendable (IndianaJSON) async throws -> IndianaJSON)? = nil, sessionNow: @escaping @Sendable () -> Date = { Date() }) { self.publicPaywallContent = publicPaywallContent; self.configuration = configuration; self.http = IndianaSessionTransport(http, scope: configuration.scope, now: sessionNow); self.nativeStore = store ?? AppleStorefront(); self.durableFunnels = false }
     public func identify(customerToken token: String) async throws {
         guard token.range(of: "^gg_ct_[A-Za-z0-9_-]{32,128}$", options: .regularExpression) != nil else { throw IndianaClientError.unauthenticated }
         try await installIdentity(token)
@@ -186,7 +184,7 @@ public actor IndianaClient {
     private func installIdentity(_ token: String, session: IndianaCustomerSession? = nil) async throws {
         analyticsTimer?.cancel(); analyticsTimer = nil; analyticsEvents = []
         if let pushIdentity { pushBindingSequence = try pushIdentity.reserve(); pushSynchronizationError = nil }
-        epoch = UUID(); pushObservationID = UUID(); customerToken = token; nativeReceiptPending = [:]; storeRestorePending = [:]
+        epoch = UUID(); pushObservationID = UUID(); customerToken = token; storeRestorePending = [:]
         let previous = takeViews()
         credentialRevision += 1; let revision = credentialRevision, original = epoch
         let invalidated: @Sendable () async -> Void = { [weak self] in await self?.invalidateSession(revision: revision) }
@@ -302,7 +300,7 @@ public actor IndianaClient {
         analyticsTimer?.cancel(); analyticsTimer = nil; analyticsEvents = []
         do { if let pushIdentity { _ = try pushIdentity.reserve(detach: true) }; pushSynchronizationError = nil }
         catch { pushSynchronizationError = .protectedStorageUnavailable }
-        epoch = UUID(); pushObservationID = UUID(); customerToken = nil; pushBindingSequence = 0; nativeReceiptPending = [:]; storeRestorePending = [:]
+        epoch = UUID(); pushObservationID = UUID(); customerToken = nil; pushBindingSequence = 0; storeRestorePending = [:]
         return takeViews()
     }
     private func closeViews(_ previous: CustomerViews) async {
@@ -326,60 +324,14 @@ public actor IndianaClient {
         schedulePush()
         await closeViews(previous)
     }
-    /// The relay runs on your backend and adds its API key. A Funnel run token is never used for order recovery.
+    /// StoreKit's current transactions are the recovery source: every SDK purchase carries its order binding as its app
+    /// account token and stays unfinished until the server confirms it, so `restorePurchases` and a retried
+    /// `purchaseSubscription` recover it. No local order journal exists; this compatibility entry relays nothing and
+    /// returns no orders.
+    @available(*, deprecated, message: "StoreKit's current transactions are the recovery source; call restorePurchases(synchronizeStore:).")
     public func recoverNativeOrders(using relay: @Sendable (Data) async throws -> Data, synchronizeStore: Bool = false) async throws -> [Data] {
-        guard let token = customerToken, configuration.scope.environment == .sandbox, !recoveringNative else { throw IndianaClientError.unauthenticated }
-        recoveringNative = true; defer { recoveringNative = false }; let original = epoch
-        let storage = nativeStorage
-        let records = try await storage.orders()
-        let scanned = synchronizeStore ? try await nativeStore.restore() : await nativeStore.scanUnfinished()
-        var responses: [Data] = []
-        for record in records {
-            let matching = scanned.filter { $0.productID == record.productId && $0.accountToken == record.accountToken }
-            let items: [ApplePurchaseEvidence?] = matching.isEmpty ? [nil] : matching.map { Optional($0) }
-            for item in items {
-                guard original == epoch else { throw IndianaClientError.identityChanged }
-                let command: (UUID, Data)
-                if let pending = nativeReceiptPending[record.orderId] { command = pending }
-                else {
-                    let requestId = UUID()
-                    var proof: IndianaJSON = .null
-                    if let item {
-                        guard item.signedTransaction.utf8.count <= 131072 else { throw IndianaClientError.invalidResponse }
-                        proof = .object(["provider":.string("apple"), "orderId":.string(record.orderId.uuidString.lowercased()), "receiptId":.string(record.receiptId.uuidString.lowercased()), "signedTransaction":.string(item.signedTransaction)])
-                    }
-                    let body: IndianaJSON = .object(["operation":.string("native_receipt"), "requestId":.string(requestId.uuidString.lowercased()), "customerToken":.string(token), "orderId":.string(record.orderId.uuidString.lowercased()), "receiptId":.string(record.receiptId.uuidString.lowercased()), "nativeEvidence":proof])
-                    command = (requestId, try JSONEncoder().encode(body)); nativeReceiptPending[record.orderId] = command
-                }
-                let credential = try await preparedCustomerToken()
-                guard original == epoch else { throw IndianaClientError.identityChanged }
-                var outgoing = try JSONSerialization.jsonObject(with: command.1) as! [String: Any]
-                outgoing["customerToken"] = credential
-                let payload = try JSONSerialization.data(withJSONObject: outgoing)
-                let bytes: Data
-                do { bytes = try await relay(payload) }
-                catch let error as IndianaClientError {
-                    guard original == epoch else { throw IndianaClientError.identityChanged }
-                    if case .requestFailed(let status) = error, status < 500, status != 425 {
-                        nativeReceiptPending.removeValue(forKey: record.orderId)
-                        if status == 403 || status == 404 { continue }
-                    }
-                    throw error
-                }
-                guard original == epoch else { throw IndianaClientError.identityChanged }
-                struct Reply: Decodable { let scope: IndianaScope; let requestId: UUID; let orderId: UUID; let receiptId: UUID; let orderStatus: String; let refunded: Bool; let nativeCompletion: IndianaNativeCompletion? }
-                guard bytes.count <= 262144, let reply = try? JSONDecoder().decode(Reply.self, from: bytes), reply.scope == configuration.scope, reply.requestId == command.0, reply.orderId == record.orderId, reply.receiptId == record.receiptId, ["created", "pending", "trialing", "paid", "cancelled", "failed"].contains(reply.orderStatus) else { throw IndianaClientError.invalidResponse }
-                if let completion = reply.nativeCompletion {
-                    guard completion.orderId == record.orderId, completion.receiptId == record.receiptId, (1...50).contains(completion.transactionIds.count), Set(completion.transactionIds).count == completion.transactionIds.count, completion.transactionIds.allSatisfy({ !$0.isEmpty && $0.count <= 255 }) else { throw IndianaClientError.invalidResponse }
-                    for transaction in scanned where transaction.productID == record.productId && transaction.accountToken == record.accountToken && completion.transactionIds.contains(transaction.transactionID) {
-                        try await nativeStore.finish(transactionID: transaction.transactionID, confirmedTransactionIDs: Set(completion.transactionIds))
-                    }
-                    if !completion.membership { try await storage.remove(record.orderId) }
-                }
-                nativeReceiptPending.removeValue(forKey: record.orderId); responses.append(bytes)
-            }
-        }
-        return responses
+        guard customerToken != nil else { throw IndianaClientError.unauthenticated }
+        return []
     }
     /// Restores store transactions after reinstall or a device change. No local order journal is required.
     public func restorePurchases(synchronizeStore: Bool = false) async throws -> [Data] {
@@ -395,10 +347,23 @@ public actor IndianaClient {
             guard original == epoch else { throw IndianaClientError.identityChanged }
             // Unbound historical or family-shared transactions are not automatically transferred to an app account.
             guard let intent = purchase.accountToken else { continue }
-            replies.append(try await submitStorePurchase(purchase, intent: intent, original: original))
+            if let reply = try await restoreOne(purchase, intent: intent, original: original) { replies.append(reply) }
         }
         return replies
     }
+    /// The App Store account can hold transactions bound to another Customer or scope. Their definite refusal (403/404)
+    /// skips that transaction; any other refusal or unknown result ends the restore.
+    private func restoreOne(_ purchase: ApplePurchaseEvidence, intent: UUID, original: UUID) async throws -> Data? {
+        do { return try await submitStorePurchase(purchase, intent: intent, original: original) }
+        catch let error as IndianaClientError {
+            guard original == epoch else { throw IndianaClientError.identityChanged }
+            guard case .requestFailed(let status) = error else { throw error }
+            // A definite refusal settles that request; a later attempt starts a new one.
+            if (400..<500).contains(status), status != 425 { storeRestorePending.removeValue(forKey: purchase.transactionID) }
+            guard status == 403 || status == 404 else { throw error }
+            return nil
+        }
+    }
     private func submitStorePurchase(_ purchase: ApplePurchaseEvidence, intent: UUID, original: UUID) async throws -> Data {
         guard purchase.signedTransaction.utf8.count <= 131072 else { throw IndianaClientError.invalidResponse }
         let command: (UUID, Data)

package/native-sdk/ios/NativeReceiptRelay.swift

@@ -1,7 +1,5 @@
 import Foundation
 
-struct IndianaNativeCompletion: Codable, Sendable { let orderId: UUID; let receiptId: UUID; let membership: Bool; let transactionIds: [String] }
-
 /// HTTPS endpoint on your own backend. It authenticates the customer and attaches the Indiana server key there.
 public final class IndianaNativeReceiptRelay: Sendable {
     private let endpoint: URL; private let session: URLSession

package/native-sdk/ios/SDKVersion.swift

@@ -1,4 +1,4 @@
 // Generated by scripts/sdk/generate-native-protocol.mjs. Do not edit.
 public enum IndianaSDK {
-    public static let version = "0.10.11"
+    public static let version = "0.10.13"
 }