@tinkerlandai/longplay-react-native 0.10.7 → 0.10.11

package/native-sdk/ios/BundledWebView.swift

@@ -56,7 +56,11 @@ import UIKit
               let data=try? JSONSerialization.data(withJSONObject:message.body), data.count <= 262144,
               let value=try? JSONDecoder().decode(IndianaJSON.self,from:data).object,
               Set(value.keys) == Set(["id","method","payload"]), let id=value["id"]?.string.flatMap(UUID.init(uuidString:)),
-              let method=value["method"]?.string, requests.count < 8, requests.insert(id).inserted else { return }
+              let method=value["method"]?.string, !requests.contains(id) else { return }
+        guard requests.count < 8 else {
+            send(.object(["id":.string(id.uuidString.lowercased()),"error":.object(["code":.string("NATIVE_BUSY"),"status":.number(429)])])); return
+        }
+        requests.insert(id)
         Task {
             defer { requests.remove(id) }
             do {

package/native-sdk/ios/CustomerSession.swift

@@ -2,6 +2,8 @@ import Foundation
 
 /// Opaque credentials issued by the merchant backend; keep them in memory.
 public struct IndianaCustomerSession: Codable, Sendable {
+    private static let fractionalDate = Date.ISO8601FormatStyle(includingFractionalSeconds: true)
+    private static let wholeDate = Date.ISO8601FormatStyle()
     public let customerId: UUID
     public let sessionId: UUID
     public let accessToken: String
@@ -12,8 +14,7 @@ public struct IndianaCustomerSession: Codable, Sendable {
         self.customerId = customerId; self.sessionId = sessionId; self.accessToken = accessToken; self.refreshToken = refreshToken; self.expiresAt = expiresAt; self.refreshExpiresAt = refreshExpiresAt
     }
     internal func deadline(_ value: String) -> Date? {
-        let parser = ISO8601DateFormatter(); parser.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-        return parser.date(from: value) ?? ISO8601DateFormatter().date(from: value)
+        (try? Self.fractionalDate.parse(value)) ?? (try? Self.wholeDate.parse(value))
     }
     internal func validate(fresh: Bool = false) throws {
         guard accessToken.range(of: "^gg_ct_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil,
@@ -39,6 +40,7 @@ internal actor IndianaSessionTransport: IndianaHTTP {
     init(_ upstream: any IndianaHTTP, scope: IndianaScope, now: @escaping @Sendable () -> Date = { Date() }) { self.upstream = upstream; self.scope = scope; self.now = now }
     func identify(_ access: String?, revision: UInt64? = nil, onInvalidated: (@Sendable () async -> Void)? = nil) {
         if let revision { guard revision >= identityRevision else { return }; identityRevision = revision } else { identityRevision += 1 }
+        pending?.1.cancel()
         epoch = UUID(); credentials = nil; originalAccess = access; pending = nil; self.onInvalidated = onInvalidated
     }
     func identify(_ value: IndianaCustomerSession, revision: UInt64? = nil, onInvalidated: (@Sendable () async -> Void)? = nil) throws {
@@ -54,6 +56,7 @@ internal actor IndianaSessionTransport: IndianaHTTP {
         do {
             let next = try await task.value
             guard version == epoch else { throw IndianaClientError.identityChanged }
+            try Task.checkCancellation()
             return next
         } catch {
             guard revision == identityRevision else { throw IndianaClientError.identityChanged }
@@ -62,6 +65,7 @@ internal actor IndianaSessionTransport: IndianaHTTP {
     }
     func refresh() async throws -> IndianaCustomerSession {
         guard accessProvider == nil else { throw IndianaClientError.unsupportedCapability }
+        try Task.checkCancellation()
         if let pending {
             return try await awaitRefresh(pending.1, epoch: epoch, revision: identityRevision)
         }
@@ -97,7 +101,7 @@ internal actor IndianaSessionTransport: IndianaHTTP {
             guard originalAccess != nil else { throw IndianaClientError.unauthenticated }
             let token = try await accessProvider()
             guard version == epoch else { throw IndianaClientError.identityChanged }
-            guard token.range(of: "^gg_ct_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil else { throw IndianaClientError.invalidResponse }
+            guard token.range(of: "^gg_ct_[A-Za-z0-9_-]{32,128}$", options: .regularExpression) != nil else { throw IndianaClientError.invalidResponse }
             return token
         }
         if let current = credentials, (current.deadline(current.expiresAt) ?? .distantPast) <= now().addingTimeInterval(30) { _ = try await refresh() }

package/native-sdk/ios/FunnelConfigurationRelay.swift

@@ -23,6 +23,7 @@ final class IndianaFunnelConfigurationRelay: Sendable {
         request.cachePolicy = path.contains("/artifacts/") ? .useProtocolCachePolicy : .reloadIgnoringLocalCacheData
         do {
             let (bytes, response) = try await session.bytes(for: request)
+            defer { bytes.task.cancel() }
             guard let http = response as? HTTPURLResponse else { throw IndianaClientError.temporaryUnavailable }
             var headers: [String: IndianaJSON] = [:]
             for (key, value) in http.allHeaderFields {

package/native-sdk/ios/FunnelProcess.swift

@@ -0,0 +1,148 @@
+import Foundation
+
+/// Calls the merchant backend's process adapter with its acknowledged durable handle and authenticated merchant session.
+/// The backend resolves the subject; no Server Key, Guest proof or Customer token enters this interface.
+public protocol IndianaFunnelProcessBridge: Sendable {
+    func invoke(_ operation: String, input: [String: IndianaJSON]) async throws -> Data
+    func detach() async throws
+}
+
+/// Process identity and its credential-free command journal survive Customer-session replacement.
+public actor IndianaFunnelProcess {
+    private let configuration: IndianaConfiguration
+    private let bridge: any IndianaFunnelProcessBridge
+    private let storage: any IndianaFunnelCommandStorage
+    private var epoch = UUID()
+    private var presentation: IndianaFunnelSession?
+    private var runToken: String?
+    public private(set) var current: [String: IndianaJSON]?
+    private let onAuthenticationRequired: (@Sendable ([String: IndianaJSON]) -> Void)?
+    public init(configuration: IndianaConfiguration, bridge: any IndianaFunnelProcessBridge, commandStorage: any IndianaFunnelCommandStorage,
+                onAuthenticationRequired: (@Sendable ([String: IndianaJSON]) -> Void)? = nil) {
+        self.configuration=configuration; self.bridge=bridge; storage=commandStorage; self.onAuthenticationRequired=onAuthenticationRequired
+    }
+    private func bytes(_ value: [String: IndianaJSON]) throws -> Data { try JSONEncoder().encode(value) }
+    private func update(_ change: ([String: IndianaJSON]) throws -> [String: IndianaJSON]) async throws {
+        for _ in 0..<8 {
+            let saved=try await storage.read()
+            let record=try saved.entry.map { try JSONDecoder().decode([String: IndianaJSON].self,from:$0) } ?? [:]
+            let next=try change(record)
+            if next==record { return }
+            if try await storage.write(expectedRevision:saved.revision,entry:bytes(next)) != nil { return }
+        }
+        throw IndianaFunnelError.commandPending
+    }
+    private func record() async throws -> [String: IndianaJSON] {
+        let saved=try await storage.read()
+        return try saved.entry.map { try JSONDecoder().decode([String: IndianaJSON].self,from:$0) } ?? [:]
+    }
+    private func accept(_ data: Data, epoch original: UUID) async throws -> [String: IndianaJSON] {
+        guard original==epoch else { throw IndianaFunnelError.identityChanged }
+        try IndianaSchema.validate("processResponse",data:data)
+        let reply=try JSONDecoder().decode([String: IndianaJSON].self,from:data)
+        guard let run=reply["run"]?.object, let identity=run["identity"]?.object,
+              let scope=reply["scope"], try JSONDecoder().decode(IndianaScope.self,from:JSONEncoder().encode(scope))==configuration.scope else { throw IndianaFunnelError.invalidResponse }
+        let tuple: [String: IndianaJSON] = ["scope":scope,"runId":run["id"]!,"source":run["source"]!,"participantId":identity["participantId"]!,"startedAs":identity["startedAs"]!,"runExpiresAt":run["runExpiresAt"]!]
+        let binding=identity["binding"]?.object?["id"] ?? .null
+        try await update { record in
+            var next=record
+            if let previous=record["origin"], previous != .object(tuple) { throw IndianaFunnelError.invalidResponse }
+            if let old=record["bindingId"], old != .null, binding != old { throw IndianaFunnelError.identityChanged }
+            next["origin"] = .object(tuple); next["bindingId"] = binding
+            if let settlement=reply["settlement"]?.object, settlement["state"] == .string("settled"),
+               let id=settlement["requestId"] {
+                for lane in ["pending","close"] where record[lane]?.object?["command"]?.object?["requestId"]==id { next.removeValue(forKey:lane) }
+            }
+            return next
+        }
+        guard original==epoch else { throw IndianaFunnelError.identityChanged }
+        let revision: (IndianaJSON?) -> Double = { if case .number(let n)=$0 { return n }; return -1 }
+        if current==nil || revision(run["revision"])>=revision(current?["revision"]) { current=run }
+        if let value=reply["runToken"]?.string { if let old=runToken,old != value { throw IndianaFunnelError.invalidResponse };runToken=value }
+        if run["instruction"]?.object?["type"] == .string("authentication_required") { onAuthenticationRequired?(run) }
+        return reply
+    }
+    private func invoke(_ operation: String, _ input: [String: IndianaJSON]) async throws -> [String: IndianaJSON] {
+        let original=epoch
+        do { return try await accept(bridge.invoke(operation,input:input),epoch:original) }
+        catch {
+            if let failure=error as? IndianaClientError {
+                switch failure { case .identityChanged,.unauthenticated: current=nil;await presentation?.reset();presentation=nil;default:break }
+            }
+            throw error
+        }
+    }
+    public func open(_ input: [String: IndianaJSON]) async throws -> [String: IndianaJSON] {
+        try IndianaSchema.validate("processOpen",data:bytes(input));_ = try await invoke("open",input)
+        try await settlePending(); return try await invoke("get",[:])
+    }
+    public func syncIdentity() async throws -> [String: IndianaJSON] {
+        _ = try await invoke("syncIdentity",[:]);try await settlePending()
+        let result=try await invoke("get",[:]);_ = try await presentation?.get();return result
+    }
+    public func get(_ input: [String: IndianaJSON] = [:]) async throws -> [String: IndianaJSON] {
+        var input=input
+        if let id=input["settlementRequestId"] {
+            let saved=try await record()
+            for lane in ["pending","close"] where saved[lane]?.object?["command"]?.object?["requestId"]==id { input["settlementBindingId"]=saved[lane]?.object?["bindingId"] ?? .null }
+        }
+        return try await invoke("get",input)
+    }
+    public func command(_ command: [String: IndianaJSON]) async throws -> [String: IndianaJSON] {
+        try IndianaSchema.validate("processMutation",data:bytes(command))
+        guard let current else { throw IndianaFunnelError.invalidCommand }
+        let original=epoch
+        let envelope: [String: IndianaJSON] = ["command":.object(command),"bindingId":current["identity"]?.object?["binding"]?.object?["id"] ?? .null]
+        let lane=command["operation"] == .string("close") ? "close" : "pending"
+        var accepted=envelope
+        try await update { record in
+            var next=record
+            if let pending=record[lane]?.object {
+                guard pending["command"]==envelope["command"] else { throw IndianaFunnelError.commandPending };accepted=pending
+            } else { next[lane] = .object(envelope) }
+            return next
+        }
+        guard original==epoch else { throw IndianaFunnelError.identityChanged }
+        return try await invoke("command",accepted)
+    }
+    private func settlePending() async throws {
+        let saved=try await record()
+        for lane in ["pending","close"] {
+            guard let pending=saved[lane]?.object, let id=pending["command"]?.object?["requestId"] else { continue }
+            _ = try await get(["settlementRequestId":id,"settlementBindingId":pending["bindingId"] ?? .null])
+        }
+    }
+    /// Reuses the native renderer without a second command journal or a Customer-token installation.
+    public func presentationSession() throws -> IndianaFunnelSession {
+        if let presentation { return presentation }
+        guard let runToken else { throw IndianaFunnelError.invalidCommand }
+        let value=try IndianaFunnelSession(configuration:configuration,http:ProcessHTTP(process:self),runToken:runToken)
+        presentation=value;return value
+    }
+    public func detach() async throws {
+        epoch=UUID();current=nil;await presentation?.reset();presentation=nil;runToken=nil
+        try await bridge.detach()
+    }
+    fileprivate func rendered(_ command: [String: IndianaJSON]) async throws -> Data {
+        let operation=command["operation"]?.string ?? ""
+        var input=command;input.removeValue(forKey:"operation");input.removeValue(forKey:"customerToken")
+        var reply: [String: IndianaJSON]
+        if operation=="get" { reply=try await get(input) }
+        else if operation=="review" { reply=try await invoke("review",input) }
+        else { var mutation=command;mutation.removeValue(forKey:"customerToken");reply=try await self.command(mutation) }
+        reply.removeValue(forKey:"contract")
+        var run=reply["run"]!.object!;let identity=run.removeValue(forKey:"identity")!.object!
+        run["authenticated"] = .bool(identity["binding"] != .null)
+        if run["instruction"]?.object?["type"] == .string("authentication_required") { run["instruction"] = .null }
+        reply["run"] = .object(run)
+        if var settlement=reply["settlement"]?.object { settlement.removeValue(forKey:"accepted");reply["settlement"] = .object(settlement) }
+        return try bytes(reply)
+    }
+}
+private struct ProcessHTTP: IndianaHTTP {
+    let process: IndianaFunnelProcess
+    func send(path: String,method: String,authorization: String,body: Data?) async throws -> Data {
+        guard path=="funnels",method=="POST",let body else { throw IndianaFunnelError.invalidCommand }
+        return try await process.rendered(JSONDecoder().decode([String: IndianaJSON].self,from:body))
+    }
+}

package/native-sdk/ios/FunnelSession.swift

@@ -40,6 +40,7 @@ public actor IndianaFunnelSession {
     public private(set) var pendingPurchase: [String: IndianaJSON]?
     private var customerToken: String?; private var epoch = UUID(); private var pending: [String: IndianaJSON]?; private var sending = false; private var closingCommand: [String: IndianaJSON]?; private var closeRequested = false; private var uncertain = Set<String>(); private var settlements: [String: String] = [:]
     private var invalidated = false; private var invalidation: (@Sendable () -> Void)?; private var response: Data?
+    private var closingSending = false
     public private(set) var current: IndianaFunnelRun?
     public init(configuration: IndianaConfiguration, runToken: String, commandStorage: (any IndianaFunnelCommandStorage)? = nil) throws {
         guard runToken.range(of: "^gg_fr_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil else { throw IndianaFunnelError.invalidCommand }
@@ -59,7 +60,10 @@ public actor IndianaFunnelSession {
         let record = try await restoration!.value
         guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
         if restored { return }; restored = true
-        pending = record?.command; closingCommand = record?.closeCommand; pendingPurchase = record?.purchase; closeRequested = record?.closed == true || pending?["operation"] == .string("close")
+        let command = record?.command
+        pending = command?["operation"] == .string("close") ? nil : command
+        closingCommand = command?["operation"] == .string("close") ? command : record?.closeCommand
+        pendingPurchase = record?.purchase; closeRequested = record?.closed == true || closingCommand != nil
         for command in [pending, closingCommand].compactMap({ $0 }) { if let id = command["requestId"]?.string { uncertain.insert(id) } }
     }
     public func identify(customerToken: String) throws {
@@ -70,10 +74,11 @@ public actor IndianaFunnelSession {
     func hostConfiguration() -> IndianaConfiguration { configuration }
     func onInvalidation(_ callback: @escaping @Sendable () -> Void) { invalidation = callback;if invalidated { callback() } }
     func hostPendingCommand() -> IndianaJSON { (closingCommand ?? pending).map(IndianaJSON.object) ?? .null }
-    private func request(_ command: [String: IndianaJSON]) async throws -> IndianaFunnelRun {
+    private func request(_ command: [String: IndianaJSON], expectedEpoch: UUID? = nil) async throws -> IndianaFunnelRun {
         try await restoreCommands()
         guard !invalidated else { throw IndianaFunnelError.identityChanged }
         let original = epoch;var body = command;if let customerToken { body["customerToken"] = .string(customerToken) }
+        guard expectedEpoch == nil || expectedEpoch == original else { throw IndianaFunnelError.identityChanged }
         let encoder = JSONEncoder();encoder.outputFormatting = [.sortedKeys];let input = try encoder.encode(body)
         guard input.count <= 262144 else { throw IndianaFunnelError.invalidCommand };try IndianaSchema.validate("command", data: input)
         let bytes = try await http.send(path: "funnels", method: "POST", authorization: runToken, body: input)
@@ -133,38 +138,61 @@ public actor IndianaFunnelSession {
     }
     private func mutate(_ command: [String: IndianaJSON]) async throws -> IndianaFunnelRun {
         try await restoreCommands()
+        guard !invalidated else { throw IndianaFunnelError.identityChanged }
         let closing = command["operation"] == .string("close"), id = command["requestId"]?.string ?? ""
         if closeRequested && !closing { throw IndianaFunnelError.commandPending }
-        if sending && !closing { throw IndianaFunnelError.commandPending }
+        if closing ? closingSending : sending { throw IndianaFunnelError.commandPending }
         if closing {
+            if pending?["requestId"] == .string(id) { throw IndianaFunnelError.invalidCommand }
             closeRequested = true
             if let closingCommand, closingCommand != command { throw IndianaFunnelError.commandPending }
             closingCommand = command
+            closingSending = true
         } else {
             if let pending, pending != command { throw IndianaFunnelError.commandPending };pending = command
+            sending = true
         }
-        let wasUncertain = uncertain.contains(id);uncertain.insert(id);sending = true;let original = epoch
-        defer { sending = false }
+        let wasUncertain = uncertain.contains(id), original = epoch
+        defer { if closing { closingSending = false } else { sending = false } }
         do {
             if let journal { guard let current else { throw IndianaFunnelError.invalidCommand }; try await journal.retain(command, run: current) }
-            let run = try await request(command)
+            guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
+            uncertain.insert(id)
+            let run = try await request(command, expectedEpoch: original)
             let settled = settlements[id] == "settled"
             if original == epoch, run.pendingRequest?.requestId.uuidString.lowercased() != id,
                settled,
                (!closeRequested || closing || settled && !["running", "waiting"].contains(run.status)) {
                 try await journal?.settle(id)
+                guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
                 if pending == command { pending = nil };if closingCommand == command { closingCommand = nil };uncertain.remove(id)
             }
+            guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
             return run
         } catch {
-            if original == epoch, !wasUncertain, !closeRequested, let failure = error as? IndianaClientError, case .requestFailed(let status) = failure, status < 500, status != 401, status != 425 { try await journal?.settle(id); if pending == command { pending = nil };uncertain.remove(id) }
+            if original == epoch, !invalidated, !wasUncertain,
+               pending == command || closingCommand == command,
+               let failure = error as? IndianaClientError, case .requestFailed(let status) = failure,
+               status < 500, status != 401, status != 425 {
+                try await journal?.settle(id)
+                guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
+                if pending == command { pending = nil };if closingCommand == command { closingCommand = nil };uncertain.remove(id)
+            }
             throw error
         }
     }
     public func settle(requestId: UUID) async throws -> IndianaFunnelRun {
-        let id = requestId.uuidString.lowercased();settlements.removeValue(forKey: id);let run = try await request(["operation": .string("get"), "settlementRequestId": .string(id)])
+        try await restoreCommands()
+        let original = epoch, id = requestId.uuidString.lowercased();settlements.removeValue(forKey: id)
+        let run = try await request(["operation": .string("get"), "settlementRequestId": .string(id)], expectedEpoch: original)
         guard let state = settlements[id] else { throw IndianaFunnelError.invalidResponse }
-        if state == "settled" { try await journal?.settle(id); if pending?["requestId"] == .string(id) { pending = nil };if closingCommand?["requestId"] == .string(id) { closingCommand = nil };uncertain.remove(id) };return run
+        if state == "settled", run.pendingRequest?.requestId != requestId {
+            try await journal?.settle(id)
+            guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
+            if pending?["requestId"] == .string(id) { pending = nil };if closingCommand?["requestId"] == .string(id) { closingCommand = nil };uncertain.remove(id)
+        }
+        guard original == epoch, !invalidated else { throw IndianaFunnelError.identityChanged }
+        return run
     }
     private func base(_ operation: String, requestId: UUID) throws -> [String: IndianaJSON] {
         guard let current, !invalidated else { throw IndianaFunnelError.invalidCommand }

package/native-sdk/ios/HTTPTransport.swift

@@ -42,6 +42,7 @@ final class IndianaURLTransport: IndianaHTTP, Sendable {
         config.timeoutIntervalForRequest = configuration.timeout; config.timeoutIntervalForResource = configuration.timeout
         self.session = URLSession(configuration: config, delegate: NoRedirect(), delegateQueue: nil)
     }
+    deinit { session.invalidateAndCancel() }
     func send(path: String, method: String, authorization: String, body: Data?) async throws -> Data {
         guard !path.contains(".."), !path.contains("?"), !path.contains("#"), !path.hasPrefix("/") else { throw IndianaClientError.invalidConfiguration }
         var request = URLRequest(url: requestOrigin.appendingPathComponent("api/v1").appendingPathComponent(path))
@@ -54,6 +55,7 @@ final class IndianaURLTransport: IndianaHTTP, Sendable {
         request.setValue(IndianaSDK.version, forHTTPHeaderField: "X-Indiana-SDK-Version")
         do {
             let (bytes, response) = try await session.bytes(for: request)
+            defer { bytes.task.cancel() }
             guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
                 throw IndianaClientError.requestFailed((response as? HTTPURLResponse)?.statusCode ?? 0)
             }

package/native-sdk/ios/IndianaClient.swift

@@ -498,7 +498,13 @@ public actor IndianaClient {
         guard (1...20).contains(plans.count), Set(plans.map(\.productVersionId)).count == plans.count,
               currency.range(of: "^[A-Z]{3}$", options: .regularExpression) != nil,
               plans.allSatisfy({ $0.featureQuantities.count <= 100 && $0.featureQuantities.values.allSatisfy { (0...10000).contains($0) } && $0.seatQuantities.count <= 20 && $0.seatQuantities.allSatisfy { $0.key.range(of: "^[a-z][a-z0-9_]{0,63}$", options: .regularExpression) != nil && (0...10000).contains($0.value) } }) else { throw IndianaClientError.invalidResponse }
-        let entries = plans.map { plan in IndianaJSON.object(["productVersionId":.string(plan.productVersionId.uuidString.lowercased()), "seatQuantities":.object(plan.seatQuantities.mapValues { .number(Double($0)) }), "featureQuantities":.object(Dictionary(uniqueKeysWithValues: plan.featureQuantities.map { ($0.key.uuidString.lowercased(), IndianaJSON.number(Double($0.value))) }))]) }
+        // Empty quantity maps are omitted: the contract treats them as absent and the deployed runtime refuses an empty object.
+        let entries = plans.map { plan -> IndianaJSON in
+            var entry: [String: IndianaJSON] = ["productVersionId": .string(plan.productVersionId.uuidString.lowercased())]
+            if !plan.seatQuantities.isEmpty { entry["seatQuantities"] = .object(plan.seatQuantities.mapValues { .number(Double($0)) }) }
+            if !plan.featureQuantities.isEmpty { entry["featureQuantities"] = .object(Dictionary(uniqueKeysWithValues: plan.featureQuantities.map { ($0.key.uuidString.lowercased(), IndianaJSON.number(Double($0.value))) })) }
+            return .object(entry)
+        }
         var fields: [String: IndianaJSON] = ["requestId":.string(requestId.uuidString.lowercased()), "plans":.array(entries), "provider":.string(provider.rawValue), "currency":.string(currency)]
         if let billingSubscriptionId { fields["billingSubscriptionId"] = .string(billingSubscriptionId.uuidString.lowercased()) }
         guard nativeOffer == nil || (nativeOffer!.matches(provider) && plans.count == 1),

package/native-sdk/ios/NativeReceiptRelay.swift

@@ -8,15 +8,17 @@ public final class IndianaNativeReceiptRelay: Sendable {
     public init(endpoint: URL) throws {
         guard endpoint.scheme == "https", endpoint.host != nil, endpoint.user == nil, endpoint.password == nil, endpoint.query == nil, endpoint.fragment == nil else { throw IndianaClientError.invalidConfiguration }
         self.endpoint = endpoint
-        let config = URLSessionConfiguration.ephemeral; config.urlCache = nil; config.httpCookieStorage = nil; config.requestCachePolicy = .reloadIgnoringLocalCacheData; config.timeoutIntervalForRequest = 35
+        let config = URLSessionConfiguration.ephemeral; config.urlCache = nil; config.httpCookieStorage = nil; config.requestCachePolicy = .reloadIgnoringLocalCacheData; config.timeoutIntervalForRequest = 35; config.timeoutIntervalForResource = 35
         session = URLSession(configuration: config, delegate: NoRedirect(), delegateQueue: nil)
     }
+    deinit { session.invalidateAndCancel() }
     public func send(_ body: Data) async throws -> Data {
         guard body.count <= 262144, let input = try? JSONDecoder().decode(IndianaJSON.self, from: body).object, input["operation"] == .string("native_receipt"), let token = input["customerToken"]?.string, token.range(of: "^gg_ct_[A-Za-z0-9_-]{32,128}$", options: .regularExpression) != nil else { throw IndianaClientError.invalidConfiguration }
         var request = URLRequest(url: endpoint); request.httpMethod = "POST"; request.httpBody = body
         request.setValue("application/json", forHTTPHeaderField: "Content-Type"); request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
         do {
             let (stream, response) = try await session.bytes(for: request)
+            defer { stream.task.cancel() }
             guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else { throw IndianaClientError.requestFailed((response as? HTTPURLResponse)?.statusCode ?? 0) }
             guard response.expectedContentLength <= 262144 else { throw IndianaClientError.invalidResponse }
             var result = Data(); for try await byte in stream { guard result.count < 262144 else { throw IndianaClientError.invalidResponse }; result.append(byte) }; return result

package/native-sdk/ios/PaywallSession.swift

@@ -52,7 +52,8 @@ public actor IndianaPaywallSession {
     private func canonical(_ value: IndianaJSON) throws -> Data { let encoder = JSONEncoder(); encoder.outputFormatting = .sortedKeys; return try encoder.encode(value) }
     public func refresh() async throws -> IndianaJSON { try await hostCommand(.object(["operation":.string("resolve"),"input":.object([:])])) }
     internal func hostCommand(_ payload: IndianaJSON) async throws -> IndianaJSON {
-        guard !closed, !busy, let envelope = payload.object, Set(envelope.keys) == Set(["operation","input"]), let action = envelope["operation"]?.string, let input = envelope["input"]?.object else { throw IndianaFunnelError.invalidCommand }
+        guard !closed, let envelope = payload.object, Set(envelope.keys) == Set(["operation","input"]), let action = envelope["operation"]?.string, let input = envelope["input"]?.object else { throw IndianaFunnelError.invalidCommand }
+        guard !busy else { throw IndianaFunnelError.commandPending }
         busy = true; defer { busy = false }
         switch action {
         case "resolve":
@@ -78,7 +79,6 @@ public actor IndianaPaywallSession {
             let fingerprint = try canonical(payload)
             if let pendingPreview, pendingPreview != fingerprint {
                 guard let status = operation?.object?["status"]?.string, status != "pending" else { throw IndianaFunnelError.commandPending }
-                quote = nil; operation = nil
             }
             if pendingPreview == fingerprint, let quote { return quote }
             var selectedPlan: [String:IndianaJSON] = ["productVersionId":.string(product)]
@@ -87,6 +87,7 @@ public actor IndianaPaywallSession {
             fields["offerId"] = input["offerId"]; fields["nativeOffer"] = input["nativeOffer"]
             let body = IndianaJSON.object(fields)
             try IndianaSchema.validate("previewAttachRequest", data: JSONEncoder().encode(body))
+            if pendingPreview != fingerprint { quote = nil; operation = nil }
             pendingPreview = fingerprint
             let reply = try await send("previewAttach", path:"subscriptions/preview-attach",body:body)
             guard let value = reply.object?["quote"], let q = value.object, q["currency"]?.string == currency, q["provider"]?.string == provider.rawValue,
@@ -97,9 +98,9 @@ public actor IndianaPaywallSession {
             let body = action == "read" ? IndianaJSON.object(["operationId":id]) : .object(["operationId":id,"intent":.string(action)])
             let reply = try await send(action == "read" ? "readSubscriptionOperation" : "attach", path: action == "read" ? "subscriptions/operations/read" : "subscriptions/attach", body:body)
             guard let value = reply.object?["operation"], value.object?["operationId"] == id, value.object?["currency"]?.string == currency else { throw IndianaClientError.invalidResponse }
-            if operation?.object?["status"]?.string == "complete" { return operation! }
+            if let previous = operation, let status = previous.object?["status"]?.string,
+               status == "complete" || status != "pending" && value.object?["status"]?.string == "pending" { return previous }
             operation = value
-            if value.object?["status"]?.string != "pending" && value.object?["status"]?.string != "complete" { pendingPreview = nil; quote = nil }
             return value
         default: throw IndianaFunnelError.invalidCommand
         }

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.7"
+    public static let version = "0.10.11"
 }