@tinkerlandai/indiana-react-native 0.9.1 → 0.9.5

package/native-sdk/ios/CustomerResponseSemantics.swift

@@ -0,0 +1,232 @@
+import Foundation
+
+// Dispatch uses generated schema fields, so merchant JSON cannot impersonate a DTO.
+enum IndianaCustomerResponseSemantics {
+    typealias O = [String: Any]
+    static func require(_ value: Bool) throws { if !value { throw IndianaClientError.invalidResponse } }
+    static func o(_ value: Any?) -> O { value as? O ?? [:] }
+    static func a(_ value: Any?) -> [O] { value as? [O] ?? [] }
+    static func s(_ value: Any?) -> String { value as? String ?? "" }
+    static func n(_ value: Any?) -> Decimal { if let text = value as? String { return Decimal(string: text, locale: Locale(identifier: "en_US_POSIX")) ?? 0 }; return (value as? NSNumber)?.decimalValue ?? 0 }
+    static func nilValue(_ value: Any?) -> Bool { value == nil || value is NSNull }
+    static func unique(_ values: [String]) -> Bool { Set(values).count == values.count }
+    static func time(_ value: Any?) -> TimeInterval { IndianaDates.parse(s(value))?.timeIntervalSince1970 ?? 0 }
+    static func rules(_ original: Any, schema: O) throws -> Any {
+        var value = original
+        let rules = Set(schema["x-indiana-rules"] as? [String] ?? [])
+        if rules.contains("trim"), let text = value as? String { value = text.trimmingCharacters(in: CharacterSet(charactersIn: "\u{9}\u{a}\u{b}\u{c}\u{d}\u{20}\u{a0}\u{1680}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}")) }
+        if rules.contains("positive") { try require(n(value) > 0) }; if rules.contains("atLeastOne") { try require(n(value) >= 1) }
+        if rules.contains("lowercase") { try require(s(value) == s(value).lowercased()) }
+        if rules.contains("https") { let url = URL(string: s(value)); try require(url?.scheme == "https" && url?.host?.isEmpty == false) }
+        if rules.contains("locale") { let parts = s(value).split(separator: "-").map(String.init); try require(!IndianaProtocol.nonCanonicalLocaleLanguages.contains(parts.first ?? "") && !parts.dropFirst().contains(where: { $0.count == 4 ? IndianaProtocol.nonCanonicalLocaleScripts.contains($0) : IndianaProtocol.nonCanonicalLocaleRegions.contains($0) })) }
+        if rules.contains("notNegativeZero") { try require(!s(value).hasPrefix("-") || n(value) != 0) }
+        if rules.contains("boundedAdjustment") { try require(s(value) != "-0" && n(value) >= -200000000 && n(value) <= 200000000) }
+        if rules.contains("orderedPair"), let pair = value as? [NSNumber], pair.count == 2 { try require(pair[0].doubleValue <= pair[1].doubleValue) }
+        if !rules.isDisjoint(with: ["jsonBudget", "attributes", "condition"]) { try jsonBudget(value); if !rules.isDisjoint(with: ["attributes", "condition"]) { try require(o(value).count <= 128) } }
+        if rules.contains("condition") { try condition(o(value)) }
+        return value
+    }
+    static func jsonBudget(_ value: Any) throws {
+        var count = 0
+        func visit(_ value: Any, _ depth: Int) throws {
+            count += 1; try require(count <= 10000 && depth <= 20)
+            if let text = value as? String { try require(!text.contains("\0")) }
+            if let list = value as? [Any] { for child in list { try visit(child, depth + 1) } }
+            if let object = value as? O { for (key, child) in object { try require(!["__proto__", "constructor", "prototype"].contains(key) && !key.contains("\0")); try visit(child, depth + 1) } }
+        }
+        try visit(value, 0); try require(try JSONSerialization.data(withJSONObject: value, options: [.fragmentsAllowed, .withoutEscapingSlashes]).count <= 65536)
+    }
+    static func condition(_ value: O) throws {
+        let operators: Set<String> = ["$in", "$ini", "$inGroup", "$nin", "$nini", "$notInGroup", "$gt", "$gte", "$lt", "$lte", "$regex", "$regexi", "$ne", "$eq", "$size", "$elemMatch", "$all", "$alli", "$not", "$type", "$exists", "$vgt", "$vgte", "$vlt", "$vlte", "$vne", "$veq", "$and", "$or", "$nor", "$savedGroup"]
+        try require(!["all", "any", "group", "parameter", "answer", "attribute", "result"].contains(s(value["source"])) || value["operator"] == nil && value["predicates"] == nil && value["groupId"] == nil)
+        func visit(_ current: Any) throws {
+            if let list = current as? [Any] { for child in list { try visit(child) } }
+            if let object = current as? O { for (key, child) in object {
+                if key == "$savedGroup" { let group = o(child); try require(Set(group.keys).isSubset(of: ["id", "attributeKey"]) && UUID(uuidString: s(group["id"])) != nil && (group["attributeKey"] == nil || !s(group["attributeKey"]).isEmpty && s(group["attributeKey"]).utf16.count <= 128)) }
+                if key.hasPrefix("$") { try require(operators.contains(key)) } else { try require(key.split(separator: ".").allSatisfy { !["__proto__", "constructor", "prototype"].contains(String($0)) }) }
+                if ["$regex", "$regexi"].contains(key), let pattern = child as? String {
+                    try require(pattern.range(of: "\\(\\?[<!=]|\\\\[0-9]|\\\\k<", options: .regularExpression) == nil)
+                    let matches = try NSRegularExpression(pattern: "\\{([0-9]+)(?:,([0-9]*))?\\}").matches(in: pattern, range: NSRange(pattern.startIndex..., in: pattern))
+                    for match in matches { for index in [1, 2] { if let range = Range(match.range(at: index), in: pattern), let bound = Int(pattern[range]) { try require(bound <= 255) } } }
+                    if key == "$regexi" { try require(pattern.unicodeScalars.allSatisfy { $0.value <= 127 }) }
+                    // With no Unicode flag, JavaScript treats unknown ASCII letter
+                    // escapes as identity escapes; ICU/JVM would reject e.g. \q.
+                    let chars = Array(pattern); var syntax = "", index = 0
+                    while index < chars.count { if chars[index] == "\\", index + 1 < chars.count { let next = chars[index + 1]; if next.isASCII && next.isLetter && !"bBcdDsSwWfnrtvux".contains(next) { syntax.append(next) } else { syntax.append(chars[index]); syntax.append(next) }; index += 2 } else { syntax.append(chars[index]); index += 1 } }
+                    _ = try NSRegularExpression(pattern: syntax)
+                }
+                try visit(child)
+            } }
+        }; try visit(value)
+    }
+    static func object(_ input: O, fields: Set<String>, path: [String]) throws -> O {
+        var v = input
+        func has(_ keys: [String]) -> Bool { Set(keys).isSubset(of: fields) }
+        if has(["productKind", "seatBundle", "applePromotionalOffer", "replacement", "offerKind"]) {
+            let apple = s(v["provider"]) == "apple", member = s(v["productKind"]) == "membership", kind = s(v["offerKind"]), replacement = o(v["replacement"]), proof = o(v["applePromotionalOffer"])
+            if !replacement.isEmpty { try require(member && kind == "none" && nilValue(v["trialDays"]) && s(replacement["policy"]) == (apple ? "apple_store" : "google_full_price")) }
+            if !member { try require(nilValue(v["trialDays"]) && kind == "none" && v["basePlanId"] == nil) }
+            else if !apple { try require(v["basePlanId"] != nil) }
+            try require(n(v["discountMinor"]) <= n(v["catalogAmountMinor"]) && unique(a(v["seatBundle"]).map { s($0["key"]) }))
+            try require(nilValue(v["trialDays"]) || n(v["discountMinor"]) == 0 && kind != "none")
+            try require(kind != "none" || n(v["discountMinor"]) == 0)
+            if apple {
+                try require(!nilValue(v["appAccountToken"]) && v["obfuscatedAccountId"] == nil && v["obfuscatedProfileId"] == nil && v["basePlanId"] == nil)
+                try require((kind == "promotional") == !nilValue(v["applePromotionalOffer"]) && (kind == "promotional") == (v["offerId"] != nil))
+                try require(proof.isEmpty || s(proof["offerId"]) == s(v["offerId"]))
+            } else { try require(v["appAccountToken"] == nil && !s(v["obfuscatedAccountId"]).isEmpty && !s(v["obfuscatedProfileId"]).isEmpty && nilValue(v["applePromotionalOffer"]) && (kind == "none") == (v["offerId"] == nil)) }
+        }
+        if has(["kind", "tiers"]), ["graduated", "volume"].contains(s(v["kind"])) {
+            let rows = a(v["tiers"]); try require(!rows.isEmpty && nilValue(rows.last?["upTo"]))
+            for (index, row) in rows.dropLast().enumerated() { try require(!nilValue(row["upTo"]) && (index == 0 || n(row["upTo"]) > n(rows[index - 1]["upTo"]))) }
+            try require(!rows.contains { n($0["flatAmountMinor"]) > 0 } || s(v["kind"]) == "volume" && rows.count > 1)
+        }
+        if has(["units", "prices", "minimumQuantity", "maximumQuantity"]) {
+            try require(n(v["units"]) > 0 && n(v["maximumQuantity"]) >= n(v["minimumQuantity"]))
+            let prices = a(v["prices"]); try require(unique(prices.map { s($0["currency"]) }))
+            for price in prices {
+                try require(price["pricing"] == nil || n(price["amountMinor"]) == 0)
+                let bounds = [n(v["maximumQuantity"])] + a(o(price["pricing"])["tiers"]).filter { !nilValue($0["upTo"]) }.flatMap { [n($0["upTo"]), n($0["upTo"]) + 1] }
+                for quantity in bounds where quantity <= n(v["maximumQuantity"]) { _ = try prepaid(price, quantity) }
+            }
+        }
+        if has(["terms", "includedAmount", "priceId", "productId", "unitAmountMinor"]) {
+            let terms = o(v["terms"]), quantity = n(v["quantity"])
+            try require(quantity >= n(terms["minimumQuantity"]) && quantity <= n(terms["maximumQuantity"]) && nilValue(v["productId"]) == nilValue(v["priceId"]))
+            try require(quantity == 0 || v["pricing"] == nil && n(v["unitAmountMinor"]) == 0 || !nilValue(v["priceId"]))
+            try require(n(v["includedAmount"]) + n(terms["units"]) * quantity <= Decimal(string: "999999999999.999999")!)
+            _ = try prepaid(v, quantity)
+        }
+        if has(["lineId", "baseAmountMinor", "catalogAmountMinor", "seats", "trial"]) {
+            let seats = a(v["seats"]); try require(unique(seats.map { s($0["key"]) }))
+            try require(seats.allSatisfy { n($0["quantity"]) >= n($0["includedQuantity"]) && n($0["quantity"]) <= n($0["maximumQuantity"]) })
+            var total = n(v["baseAmountMinor"]) + seats.reduce(0) { $0 + n($1["unitAmountMinor"]) * (n($1["quantity"]) - n($1["includedQuantity"])) }
+            for row in a(v["prepaid"]) { total += try prepaid(row, n(row["quantity"])) }; try require(total == n(v["catalogAmountMinor"]))
+        }
+        if has(["percent_off", "amount_off", "currency", "duration_in_months", "duration"]) { try require((v["percent_off"] != nil) != (v["amount_off"] != nil) && (v["amount_off"] == nil) == (v["currency"] == nil) && (s(v["duration"]) == "repeating") == (v["duration_in_months"] != nil)) }
+        if has(["operationId", "lines", "discount", "charge", "nativeOffer", "execution"]) { try attachQuote(v) }
+        if has(["executor", "checkoutUrl", "execution"]) {
+            try require(nilValue(v["execution"]) || s(v["executor"]) == "merchant")
+            if has(["quoteFinalized", "orderId"]) { try require(nilValue(v["checkoutUrl"]) || s(v["executor"]) == "indiana") }
+            if !nilValue(v["checkoutUrl"]) { try require(URL(string: s(v["checkoutUrl"]))?.scheme == "https") }
+        }
+        if has(["action", "executor", "update", "cancel", "schedule", "release"]) {
+            for action in ["update", "cancel", "schedule", "release"] { try require(!nilValue(v[action]) == (s(v["action"]) == action)) }
+            try require(s(v["executor"]) == "indiana" || (a(o(v["update"])["items"]) + a(o(v["schedule"])["nextItems"])).allSatisfy { !nilValue($0["price"]) })
+        }
+        if has(["offerKind", "offerId", "discountMinor", "trialDays"]), fields.count == 4 { try require((s(v["offerKind"]) != "none" || nilValue(v["offerId"]) && n(v["discountMinor"]) == 0 && nilValue(v["trialDays"])) && (nilValue(v["trialDays"]) || n(v["discountMinor"]) == 0)) }
+        if has(["lookupKey", "displayName", "items", "metadata"]) { v = try offering(v) }
+        if has(["tiers", "assignments"]) { let tiers = a(v["tiers"]).map { s($0["id"]) }, assignments = a(v["assignments"]); try require(unique(tiers) && unique(assignments.map { s($0["productVersionId"]) }) && unique(assignments.map { s($0["tierId"]) + ":" + s($0["period"]) }) && assignments.allSatisfy { tiers.contains(s($0["tierId"])) }) }
+        if has(["kind", "screen", "contract", "name"]) {
+            let screen = o(v["screen"]), kind = s(v["kind"]), actions = a(screen["actions"]), outputs = o(o(v["contract"])["outputs"])
+            try require(s(screen["surface"]) == kind && s(screen["name"]) == s(v["name"]) && (kind == "banner") == (s(o(screen["presentation"])["type"]) == "inline") && actions.allSatisfy { ["event", "navigate"].contains(s($0["type"])) })
+            try require(Set(actions.filter { s($0["type"]) == "event" }.map { s($0["id"]) }) == Set(outputs.keys))
+            try require(try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes]).count <= 300000)
+        }
+        if has(["pages", "actions", "initialPageId", "strings", "surface"]) { try screen(v) }
+        if has(["type", "planIds", "label", "fallback"]), s(v["type"]) == "plan_picker" {
+            if let ids = v["planIds"] as? [String] { try require(unique(ids)) }
+            if let group = v["grouping"] as? O { try require(productGrouping(group) == Set(v["planIds"] as? [String] ?? [])) }
+        }
+        if has(["type", "source", "expired", "granularity"]), s(v["type"]) == "countdown" { try require(s(v["source"]) != "fixed" || !nilValue(v["at"])) }
+        if has(["minimumQuantity", "maximumQuantity", "defaultQuantity", "step"]) { let q = n(v["defaultQuantity"]), min = n(v["minimumQuantity"]), step = n(v["step"]); let quotient = NSDecimalNumber(decimal: (q - min) / step); try require(q >= min && q <= n(v["maximumQuantity"]) && quotient.doubleValue.rounded() == quotient.doubleValue) }
+        if has(["id", "event", "properties", "type", "close"]) { try require(o(v["properties"]).count <= 20) }
+        if has(["transactionIds", "membership"]) { try require(unique(v["transactionIds"] as? [String] ?? [])) }
+        if has(["defaultLocale", "locales"]), path.last == "displayCopy" { let locales = o(v["locales"]); try require(!locales.isEmpty && locales.count <= 20 && locales[s(v["defaultLocale"])] != nil); try require(try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes]).count <= 50000) }
+        if has(["kind", "threshold", "quantity", "purchaseUnits"]) { try require(n(v["quantity"]) >= 1 && n(v["purchaseUnits"]) > 0) }
+        if has(["kind", "cashPrice", "currency"]) { try require(s(o(v["cashPrice"])["currency"]) == s(v["currency"])) }
+        if has(["currency", "pricing", "billingCycle"]) { let pricing = o(v["pricing"]); try require(s(pricing["kind"]) != "volume" || a(pricing["tiers"]).count == 1) }
+        if has(["status", "terms", "acceptedAt", "effectiveAt", "revokedAt"]) { let status = s(v["status"]); try require((status != "prepared" || nilValue(v["acceptedAt"])) && (status != "active" || !nilValue(v["acceptedAt"]) && !nilValue(v["effectiveAt"])) && (status == "revoked") == !nilValue(v["revokedAt"])) }
+        if has(["basis", "thresholds", "limit"]) { for field in ["thresholds", "includedThresholds", "absoluteThresholds"] { let values = v[field] as? [Any] ?? []; for index in values.indices.dropFirst() { try require(n(values[index]) > n(values[index - 1])) } } }
+        if has(["basis", "used", "reserved"]) && s(v["basis"]) == "usage" { for key in ["used", "reserved"] { try require(s(v[key]).range(of: "^(0|[1-9][0-9]{0,11})(\\.[0-9]{1,6})?$", options: .regularExpression) != nil) } }
+        if has(["amountMinor", "requestId", "reason"]), let amount = v["amountMinor"] as? String { try require(amount != "-0" && n(amount) >= -200000000 && n(amount) <= 200000000) }
+        if has(["inputs", "outputs"]), path.last == "contract" { try require(o(v["inputs"]).count <= 40 && o(v["outputs"]).count <= 40) }
+        if has(["formatVersion", "kind", "sha256", "url"]), path.contains("paywall") { try require(s(v["kind"]) == "paywall" && n(v["formatVersion"]) == 1) }
+        if has(["changeKind", "seat", "feature", "effectiveAt"]) { try require((s(v["changeKind"]) == "seats") == !nilValue(v["seat"]) && (s(v["changeKind"]) == "quantity") == (v["feature"] != nil)) }
+        if has(["usage", "capacity", "remaining", "withinLimit", "operationId"]) {
+            try require(nilValue(v["capacity"]) == nilValue(v["remaining"]))
+            try require(nilValue(v["capacity"]) ? v["withinLimit"] as? Bool == true : n(v["remaining"]) == n(v["capacity"]) - n(v["usage"]) && v["withinLimit"] as? Bool == (n(v["remaining"]) >= 0))
+            try require((n(v["revision"]) == 0) == nilValue(v["operationId"]) && nilValue(v["operationId"]) == nilValue(v["updatedAt"]))
+        }
+        if has(["usageType", "accessible", "available", "held", "debt", "usage"]) {
+            try require((s(v["kind"]) == "metered") == !nilValue(v["usageType"]) && (v["accessible"] as? Bool == true || s(v["available"]) == "0" && s(v["held"]) == "0"))
+            let usage = o(v["usage"])
+            if s(v["usageType"]) == "non_consumable" { let remaining = usage["remaining"]; try require(!usage.isEmpty && s(usage["internal_feature_id"]) == s(v["internal_feature_id"]) && v["unlimited"] as? Bool == nilValue(usage["capacity"]) && s(v["available"]) == (nilValue(remaining) || s(remaining).hasPrefix("-") ? "0" : s(remaining)) && s(v["held"]) == "0" && s(v["debt"]) == "0") }
+            else { try require(nilValue(v["usage"])) }
+        }
+        if has(["customerId", "rows", "nextCursor"]), path.contains("ledger") {
+            let rows = a(v["rows"]); try require(unique(rows.map { s($0["type"]) + s($0["id"]) }))
+            if let cursor = v["nextCursor"] as? O { let last = rows.last ?? [:]; try require(s(last["id"]) == s(cursor["id"]) && s(last["type"]) == s(cursor["type"]) && s(last["occurredAt"]) == s(cursor["at"])) }
+        }
+        if has(["kind", "accepted", "charges", "reservationStatus", "quantity"]), s(v["type"]) == "usage" {
+            let zero = s(v["kind"]) == "set_usage" || s(v["kind"]) == "consume" && s(v["quantity"]) == "0", accepted = v["accepted"] as? Bool == true, charges = a(v["charges"])
+            try require(zero ? accepted && nilValue(v["reason"]) && charges.isEmpty && nilValue(v["reservationStatus"]) : accepted ? nilValue(v["reason"]) && !charges.isEmpty : !nilValue(v["reason"]) && charges.isEmpty)
+            try require(!nilValue(v["originalId"]) == ["confirm", "refund", "release", "expire"].contains(s(v["kind"])) && nilValue(v["expiresAt"]) == nilValue(v["reservationStatus"]))
+        }
+        if has(["purpose", "productVersionId", "productName", "invoiceId", "originalId"]), s(v["type"]) == "transaction" {
+            let product = s(v["purpose"]) == "product"; try require(nilValue(v["currency"]) == nilValue(v["amountMinor"]) && product == !nilValue(v["productVersionId"]) && product == !nilValue(v["productName"]) && product == !nilValue(v["productVersion"]) && product == nilValue(v["invoiceId"]) && (s(v["kind"]) == "refund") == !nilValue(v["originalId"]) && (s(v["kind"]) != "refund" || nilValue(v["amountMinor"]) || n(v["amountMinor"]) > 0))
+        }
+        if has(["net", "internal_feature_id"]), s(v["net"]).hasPrefix("-") { try require(n(v["net"]) != 0) }
+        if has(["funding", "units"]) {
+            try require(n(v["units"]) > 0)
+            if s(v["funding"]) == "prepaid" {
+                let pricing = a(v["pricing"]); try require(pricing.reduce(0) { $0 + n($1["units"]) } == n(v["units"]) && pricing.reduce(0) { $0 + n($1["amount"]) } == n(v["amount"]) && pricing.allSatisfy { n($0["unitCost"]) * n($0["units"]) == n($0["amount"]) })
+            }
+        }
+        if has(["allowed", "allocations", "quantity", "internal_feature_id"]), v["allowed"] as? Bool == true {
+            let rows = a(v["allocations"]), delta = rows.reduce(0) { $0 + n($1["units"]) } - n(v["quantity"]), tolerance: Decimal = rows.contains { s($0["funding"]) == "balance" } ? Decimal(string: "0.0000000001")! : 0
+            try require(delta >= -tolerance && delta <= tolerance)
+        }
+        return v
+    }
+    static func prepaid(_ price: O, _ quantity: Decimal) throws -> Decimal {
+        if quantity == 0 { return 0 }; var total: Decimal = 0; let pricing = o(price["pricing"])
+        if pricing.isEmpty { total = n(price["amountMinor"] ?? price["unitAmountMinor"]) * quantity }
+        else { var lower: Decimal = 0; for row in a(pricing["tiers"]) { let upper = nilValue(row["upTo"]) ? 10000 : n(row["upTo"]); if s(pricing["kind"]) == "volume", quantity <= upper { total = quantity * n(row["unitAmountMinor"]) + n(row["flatAmountMinor"]); break }; if s(pricing["kind"]) != "volume", quantity > lower { total += (min(quantity, upper) - lower) * n(row["unitAmountMinor"]) }; lower = upper } }
+        try require(total <= 200000000); return total
+    }
+    static func attachQuote(_ v: O) throws {
+        let lines = a(v["lines"]), trial = o(lines.first?["trial"]), execution = o(v["execution"]), discount = o(v["discount"]), provider = s(v["provider"])
+        if provider == "stripe" {
+            if trial["cardRequired"] as? Bool == false && o(execution["invoiceMode"])["enabled"] as? Bool != true { try require(execution.isEmpty && discount.isEmpty) }
+            else {
+                try require(!execution.isEmpty && s(o(execution["metadata"])["grooveCheckoutId"]) == s(v["operationId"]) && time(execution["expiresAt"]) <= time(v["expiresAt"]))
+                try require(s(execution["mode"]) == (lines.contains { !["one_time", "free"].contains(s($0["interval"])) } ? "subscription" : "payment"))
+                try require(nilValue(execution["trialPeriodDays"]) == trial.isEmpty && (trial.isEmpty || n(execution["trialPeriodDays"]) == n(trial["days"])))
+                try require(s(execution["executor"]) == "indiana" || a(execution["lineItems"]).allSatisfy { !nilValue($0["price"]) })
+                let discounts = a(execution["discounts"]); try require(discounts.count == (discount.isEmpty ? 0 : 1))
+                for row in discounts { let terms = o(row["terms"]), coupon = s(row["coupon"]); try require(coupon == s(terms["id"]) && !discount.isEmpty); if coupon != s(discount["couponId"]) { try require(s(o(discount["discount"])["type"]) == "amount" && coupon == s(discount["couponId"]) + "_credit_" + s(discount["offerId"]) + "_" + String(describing: terms["amount_off"]!) && n(terms["amount_off"]) == n(o(discount["discount"])["amountOffCents"]) && s(terms["currency"]).uppercased() == s(v["currency"]) && s(terms["duration"]) == "once") } }
+            }
+            try require(v["nativeOffer"] == nil)
+        } else { let selection = o(v["nativeOffer"]); try require(execution.isEmpty && !selection.isEmpty && lines.count == 1 && n(selection["discountMinor"]) <= n(v["catalogAmountMinor"]) && nilValue(selection["trialDays"]) == trial.isEmpty && (trial.isEmpty || n(selection["trialDays"]) == n(trial["days"])) && (discount.isEmpty || n(selection["discountMinor"]) == n(discount["amountMinor"]))) }
+        if !discount.isEmpty {
+            let allocations = a(discount["allocations"]); try require(nilValue(v["billingSubscriptionId"]) && (provider == "stripe" || s(o(discount["duration"])["type"]) == "once") && n(discount["amountMinor"]) <= n(v["catalogAmountMinor"]) && allocations.count == lines.count)
+            for (row, line) in zip(allocations, lines) { try require(s(row["productVersionId"]) == s(line["productVersionId"]) && n(row["amountMinor"]) <= n(line["catalogAmountMinor"])) }; try require(allocations.reduce(0) { $0 + n($1["amountMinor"]) } == n(discount["amountMinor"]))
+        }
+        if let charge = v["charge"] as? O { try require(!nilValue(v["billingSubscriptionId"]) && n(charge["totalMinor"]) == n(charge["debitMinor"]) - n(charge["discountMinor"]) + n(charge["taxMinor"]) && n(charge["discountMinor"]) <= n(charge["debitMinor"]) && time(charge["periodEndsAt"]) > time(charge["effectiveAt"])) }
+        try require(unique(lines.map { s($0["lineId"]) }) && lines.reduce(0) { $0 + n($1["catalogAmountMinor"]) } == n(v["catalogAmountMinor"]))
+    }
+    static func offering(_ input: O) throws -> O {
+        var v = input; var products = Set<String>(), groups = Set<String>(), count = 0
+        func visit(_ items: [O]) throws -> [O] { try items.map { source in var item = source; count += 1; if s(item["type"]) == "product" { let id = s(item["productId"]); try require(id == id.lowercased() && products.insert(id).inserted) } else { try require(groups.insert(s(item["key"])).inserted); item["name"] = s(item["name"]).trimmingCharacters(in: .whitespacesAndNewlines); item["items"] = try visit(a(item["items"])) }; return item } }
+        v["items"] = try visit(a(v["items"])); try require(products.count <= 20 && count <= 60)
+        let bytes = try JSONSerialization.data(withJSONObject: o(v["metadata"]), options: [.withoutEscapingSlashes]); try require(String(data: bytes, encoding: .utf8)!.unicodeScalars.count <= 4000)
+        for field in ["displayName", "lookupKey"] { v[field] = s(v[field]).trimmingCharacters(in: .whitespacesAndNewlines) }; return v
+    }
+    static func productGrouping(_ group: O) -> Set<String> { Set(a(group["assignments"]).map { s($0["productVersionId"]) }) }
+    static func screen(_ v: O) throws {
+        let pages = a(v["pages"]), actions = a(v["actions"]), strings = o(v["strings"]), locales = Set(o(strings["locales"]).keys), pageIds = pages.map { s($0["id"]) }, actionIds = actions.map { s($0["id"]) }
+        try require((s(v["surface"]) == "paywall" || pages.count == 1) && pages.count <= 10 && actions.count <= 40 && locales.count <= 20 && locales.contains(s(strings["defaultLocale"])) && unique(pageIds) && unique(actionIds) && !pageIds.contains("next") && !pageIds.contains("back"))
+        try require(nilValue(v["initialPageId"]) || pageIds.contains(s(v["initialPageId"])))
+        for action in actions where s(action["type"]) == "navigate" { try require(s(v["surface"]) == "paywall" && pageIds.contains(s(action["pageId"]))) }
+        var ids = Set<String>(), count = 0
+        func visit(_ node: O, _ depth: Int) throws {
+            count += 1; try require(depth <= 8 && count <= 150 && ids.insert(s(node["id"])).inserted)
+            if s(node["type"]) == "button" { try require(actionIds.contains(s(node["action"]))) }
+            if s(node["type"]) == "custom_html" { try require(Set(o(node["html"]).keys).isSubset(of: locales)) }
+            if s(node["type"]) == "image" { try require(Set(o(node["localizedSrc"]).keys).isSubset(of: locales)) }
+            for child in a(node["children"]) { try visit(child, depth + 1) }
+        }
+        for page in pages { try visit(o(page["root"]), 1) }
+    }
+}

package/native-sdk/ios/CustomerSemantics.swift

@@ -0,0 +1,145 @@
+import Foundation
+
+// Adapters for current Customer Zod refinements/transforms that JSON Schema cannot encode.
+// Structural validation remains generated from the original Contracts.
+enum IndianaCustomerSemantics {
+    static func preflight(_ operation: String, _ value: [String: IndianaJSON]) throws {
+        if operation == "evaluateFeatures", let attributes = value["attributes"]?.object {
+            guard attributes.count <= 128 else { throw IndianaClientError.invalidConfiguration }; try jsonBudget(.object(attributes))
+        }
+        if operation == "trackEvents" { for event in array(value["events"]) { for child in event.object?["properties"]?.object?.values ?? Dictionary<String, IndianaJSON>().values { try jsonBudget(child) } } }
+    }
+    static func defaults(_ operation: String, _ input: [String: IndianaJSON]) -> [String: IndianaJSON] {
+        var input = input
+        if ["previewAttach", "previewUpdate"].contains(operation), var invoice = input["invoiceMode"]?.object {
+            if invoice["enable_plan_immediately"] == nil { invoice["enable_plan_immediately"] = .bool(false) }
+            if invoice["finalize"] == nil { invoice["finalize"] = .bool(true) }
+            input["invoiceMode"] = .object(invoice)
+        }
+        if operation == "trackEvents", case .array(let events)? = input["events"] {
+            input["events"] = .array(events.map { event in
+                guard var value = event.object else { return event }
+                if value["properties"] == nil { value["properties"] = .object([:]) }; return .object(value)
+            })
+        }
+        return input
+    }
+    static func request(_ operation: String, _ value: [String: IndianaJSON]) throws -> [String: IndianaJSON] {
+        var value = value
+        func require(_ allowed: Bool) throws { if !allowed { throw IndianaClientError.invalidConfiguration } }
+        if operation == "previewAttach" {
+            let plans = array(value["plans"]), provider = value["provider"]?.string
+            try require(Set(plans.compactMap { $0.object?["productVersionId"]?.string }).count == plans.count)
+            try require(plans.allSatisfy { ($0.object?["featureQuantities"]?.object?.count ?? 0) <= 100 })
+            try require(value["offerId"] == nil || value["billingSubscriptionId"] == nil && (provider == "stripe" || value["nativeOffer"] != nil))
+            try require(value["nativeOffer"] == nil || provider != "stripe" && plans.count == 1)
+            try require(value["newBillingSubscription"] == nil || provider == "stripe" && value["billingSubscriptionId"] == nil)
+            try require(value["invoiceMode"]?.object?["enabled"] != .bool(true) || provider == "stripe" && value["entityId"] == nil)
+            if let offer = value["nativeOffer"]?.object {
+                try require(offer["offerKind"] != .string("none") || offer["offerId"] == .null && offer["discountMinor"] == .number(0) && offer["trialDays"] == .null)
+                try require(offer["trialDays"] == .null || offer["discountMinor"] == .number(0))
+            }
+        }
+        if operation == "previewUpdate" {
+            let type = value["change"]?.object?["type"]?.string, timing = value["timing"]?.string
+            try require(timing != "store" || type == "plan")
+            try require(type != "billing_cycle" || timing == (value["change"]?.object?["billingCycleAnchor"] == .string("now") ? "immediate" : "renewal"))
+            if let group = value["membershipIds"] {
+                let members = array(group)
+                try require(["cancel", "uncancel"].contains(type ?? "") && members.contains(value["membershipId"] ?? .null) && Set(members.compactMap(\.string)).count == members.count)
+            }
+            try require(value["carryOverBalances"] == nil && value["carryOverUsages"] == nil || type == "plan" && timing == "immediate")
+            try require(value["prorationBehavior"] == nil || type == "quantity")
+            for field in ["carryOverBalances", "carryOverUsages"] {
+                if let ids = value[field]?.object?["featureIds"] { let list = array(ids); try require(Set(list.compactMap(\.string)).count == list.count) }
+            }
+        }
+        if operation == "setBillingCoupons" { let ids = array(value["grantIds"]); try require(Set(ids.compactMap(\.string)).count == ids.count) }
+        if operation == "prepareBillingAuthorization", value["kind"] == .string("auto_topup") {
+            try require(decimal(value["quantity"]) >= 1)
+            value["quantity"] = .string(quantity(value["quantity"]!.string!))
+            value["threshold"] = .string(quantity(value["threshold"]!.string!))
+        }
+        if ["checkEntitlement", "resolvePaywall", "resolveOffering"].contains(operation), var requirement = value["requirement"]?.object {
+            try require(decimal(requirement["quantity"]) > 0)
+            requirement["quantity"] = .string(quantity(requirement["quantity"]!.string!))
+            requirement["properties"] = .object(try properties(requirement["properties"]!.object!))
+            value["requirement"] = .object(requirement)
+        }
+        if operation == "quoteBalance", var command = value["command"]?.object {
+            try require(decimal(command["quantity"]) > 0)
+            command["quantity"] = .string(quantity(command["quantity"]!.string!))
+            command["properties"] = .object(try properties(command["properties"]!.object!)); value["command"] = .object(command)
+        }
+        if operation == "readLedger", let query = value["query"]?.object, let from = query["from"]?.string, let to = query["to"]?.string { try require(from <= to) }
+        if operation == "readCreditStatement" {
+            guard let from = IndianaDates.parse(value["from"]!.string!), let to = IndianaDates.parse(value["to"]!.string!) else { throw IndianaClientError.invalidConfiguration }
+            try require(to > from && to.timeIntervalSince(from) <= 366 * 86400)
+            try require(value["after"] == .null || value["snapshotAt"] != .null)
+        }
+        return value
+    }
+    static func response(_ operation: String, _ value: IndianaJSON) throws {
+        func require(_ allowed: Bool) throws { if !allowed { throw IndianaClientError.invalidResponse } }
+        let checks = [
+            value.object?["check"]?.object,
+            operation == "resolvePaywall" ? value.object?["paywall"]?.object?["check"]?.object : nil,
+        ].compactMap { $0 }
+        for check in checks {
+            try require(check["allowed"] == .bool(check["reason"] == .null))
+            try require(check["allowed"] != .bool(true) || check["preview"] == .null)
+            let candidates = array(check["preview"]?.object?["candidates"])
+            try require(Set(candidates.compactMap { $0.object?["productVersionId"]?.string }).count == candidates.count)
+            try require(candidates.allSatisfy { ($0.object?["action"] == .string("upgrade")) == ($0.object?["membershipId"] != .null) })
+        }
+        if operation == "quoteBalance", let quote = value.object?["quote"]?.object {
+            let allocations = array(quote["allocations"])
+            try require(quote["allowed"] == .bool(true) ? quote["reason"] == .null : quote["reason"] != .null && allocations.isEmpty)
+            if quote["overageBehavior"] == nil { try require(quote["requestedQuantity"] == nil && decimal(quote["quantity"]) > 0) }
+            else { try require(quote["requestedQuantity"] != nil && decimal(quote["requestedQuantity"]) >= decimal(quote["quantity"]) && (quote["overageBehavior"] == .string("cap") || quote["requestedQuantity"] == quote["quantity"])) }
+        }
+    }
+    private static func array(_ value: IndianaJSON?) -> [IndianaJSON] { if case .array(let values)? = value { return values }; return [] }
+    private static func decimal(_ value: IndianaJSON?) -> Decimal { Decimal(string: value?.string ?? "0", locale: Locale(identifier: "en_US_POSIX")) ?? 0 }
+    private static func quantity(_ value: String) -> String {
+        var value = value
+        if value.contains(".") { while value.hasSuffix("0") { value.removeLast() }; if value.hasSuffix(".") { value.removeLast() } }; return value == "-0" ? "0" : value
+    }
+    private static func properties(_ value: [String: IndianaJSON]) throws -> [String: IndianaJSON] {
+        guard value.count <= 16 else { throw IndianaClientError.invalidConfiguration }
+        return try value.mapValues { item in
+            switch item {
+            case .string: return item
+            case .bool(let flag): return .string(flag ? "true" : "false")
+            case .number(let number):
+                if number == 0 { return .string("0") }
+                let encoded = String(data: try JSONEncoder().encode(item), encoding: .utf8)!.lowercased()
+                let parts = encoded.split(separator: "e").map(String.init)
+                if parts.count == 1 { return .string(encoded) }
+                let exponent = Int(parts[1])!, mantissa = parts[0]
+                if abs(number) >= 1e-6 && abs(number) < 1e21 {
+                    let negative = mantissa.hasPrefix("-"), unsigned = negative ? String(mantissa.dropFirst()) : mantissa
+                    let digits = unsigned.replacingOccurrences(of: ".", with: ""), point = (unsigned.firstIndex(of: ".").map { unsigned.distance(from: unsigned.startIndex, to: $0) } ?? unsigned.count) + exponent
+                    let expanded = point <= 0 ? "0." + String(repeating: "0", count: -point) + digits : point >= digits.count ? digits + String(repeating: "0", count: point - digits.count) : String(digits.prefix(point)) + "." + String(digits.dropFirst(point))
+                    return .string((negative ? "-" : "") + expanded)
+                }
+                return .string(mantissa + "e" + (exponent >= 0 ? "+" : "") + String(exponent))
+            default: throw IndianaClientError.invalidConfiguration
+            }
+        }
+    }
+    private static func jsonBudget(_ value: IndianaJSON) throws {
+        var count = 0
+        func visit(_ value: IndianaJSON, _ depth: Int) throws {
+            count += 1; guard count <= 10000, depth <= 20 else { throw IndianaClientError.invalidConfiguration }
+            switch value {
+            case .string(let text): guard !text.contains("\0") else { throw IndianaClientError.invalidConfiguration }
+            case .array(let values): for child in values { try visit(child, depth + 1) }
+            case .object(let object): for (key, child) in object { guard !key.contains("\0"), !["__proto__", "constructor", "prototype"].contains(key) else { throw IndianaClientError.invalidConfiguration }; try visit(child, depth + 1) }
+            default: break
+            }
+        }
+        try visit(value, 0); let encoder = JSONEncoder(); encoder.outputFormatting = [.withoutEscapingSlashes]
+        guard try encoder.encode(value).count <= 65536 else { throw IndianaClientError.invalidConfiguration }
+    }
+}

package/native-sdk/ios/CustomerSession.swift

@@ -0,0 +1,129 @@
+import Foundation
+
+/// Opaque credentials issued by the merchant backend; keep them in memory.
+public struct IndianaCustomerSession: Codable, Sendable {
+    public let customerId: UUID
+    public let sessionId: UUID
+    public let accessToken: String
+    public let refreshToken: String
+    public let expiresAt: String
+    public let refreshExpiresAt: String
+    public init(customerId: UUID, sessionId: UUID, accessToken: String, refreshToken: String, expiresAt: String, refreshExpiresAt: String) {
+        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)
+    }
+    internal func validate(fresh: Bool = false) throws {
+        guard accessToken.range(of: "^gg_ct_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil,
+              refreshToken.range(of: "^gg_rt_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil,
+              let access = deadline(expiresAt), let refresh = deadline(refreshExpiresAt), refresh >= access, refresh > Date(), !fresh || access > Date()
+        else { throw IndianaClientError.invalidResponse }
+    }
+}
+
+/// All child capabilities share this owner; rotation never changes their identity epoch.
+internal actor IndianaSessionTransport: IndianaHTTP {
+    private let upstream: any IndianaHTTP
+    private let scope: IndianaScope
+    private let now: @Sendable () -> Date
+    private var credentials: IndianaCustomerSession?
+    private var originalAccess: String?
+    private var epoch = UUID()
+    private var identityRevision: UInt64 = 0
+    private var onInvalidated: (@Sendable () async -> Void)?
+    private var pending: (UUID, Task<IndianaCustomerSession, Error>)?
+    private var accessProvider: (@Sendable () async throws -> String)?
+    func setAccessTokenProvider(_ provider: (@Sendable () async throws -> String)?) { accessProvider = provider }
+    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 }
+        epoch = UUID(); credentials = nil; originalAccess = access; pending = nil; self.onInvalidated = onInvalidated
+    }
+    func identify(_ value: IndianaCustomerSession, revision: UInt64? = nil, onInvalidated: (@Sendable () async -> Void)? = nil) throws {
+        try value.validate(); if let revision, revision < identityRevision { return }
+        identify(value.accessToken, revision: revision, onInvalidated: onInvalidated); credentials = value
+    }
+    private func invalidate() async {
+        let notify = onInvalidated
+        epoch = UUID(); credentials = nil; originalAccess = nil; pending = nil; onInvalidated = nil
+        await notify?()
+    }
+    private func awaitRefresh(_ task: Task<IndianaCustomerSession, Error>, epoch version: UUID, revision: UInt64) async throws -> IndianaCustomerSession {
+        do {
+            let next = try await task.value
+            guard version == epoch else { throw IndianaClientError.identityChanged }
+            return next
+        } catch {
+            guard revision == identityRevision else { throw IndianaClientError.identityChanged }
+            throw error
+        }
+    }
+    func refresh() async throws -> IndianaCustomerSession {
+        guard accessProvider == nil else { throw IndianaClientError.unsupportedCapability }
+        if let pending {
+            return try await awaitRefresh(pending.1, epoch: epoch, revision: identityRevision)
+        }
+        guard let current = credentials else { throw IndianaClientError.unauthenticated }
+        guard let end = current.deadline(current.refreshExpiresAt), end > now() else {
+            await invalidate(); throw IndianaClientError.unauthenticated
+        }
+        let version = epoch, revision = identityRevision, job = UUID(), upstream = upstream, scope = scope
+        let task = Task { [self] () async throws -> IndianaCustomerSession in
+            do {
+                let data = try await upstream.send(path: "customer-sessions/refresh", method: "POST", authorization: current.refreshToken, body: Data("{}".utf8))
+                guard version == epoch else { throw IndianaClientError.identityChanged }
+                struct Envelope: Decodable { let scope: IndianaScope }
+                guard let envelope = try? JSONDecoder().decode(Envelope.self, from: data), envelope.scope == scope else { throw IndianaClientError.invalidResponse }
+                let next = try JSONDecoder().decode(IndianaCustomerSession.self, from: data); try next.validate(fresh: true)
+                guard next.customerId == current.customerId, next.sessionId == current.sessionId else { throw IndianaClientError.invalidResponse }
+                credentials = next
+                if pending?.0 == job { pending = nil }
+                return next
+            } catch {
+                guard version == epoch else { throw IndianaClientError.identityChanged }
+                if case IndianaClientError.requestFailed(401) = error { await invalidate() }
+                if pending?.0 == job { pending = nil }
+                throw error
+            }
+        }
+        pending = (job, task)
+        return try await awaitRefresh(task, epoch: version, revision: revision)
+    }
+    func access() async throws -> String {
+        let version = epoch
+        if let accessProvider {
+            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 }
+            return token
+        }
+        if let current = credentials, (current.deadline(current.expiresAt) ?? .distantPast) <= now().addingTimeInterval(30) { _ = try await refresh() }
+        guard version == epoch else { throw IndianaClientError.identityChanged }
+        guard let token = credentials?.accessToken ?? originalAccess else { throw IndianaClientError.unauthenticated }; return token
+    }
+    func send(path: String, method: String, authorization: String, body: Data?) async throws -> Data {
+        let version = epoch
+        var payload = body.flatMap { try? JSONSerialization.jsonObject(with: $0) as? [String: Any] }
+        let proof = payload?["customerToken"] as? String
+        if path.hasPrefix("push/"), payload?["credentialDigest"] != nil {
+            guard originalAccess != nil else { throw IndianaClientError.unauthenticated }
+            let result = try await upstream.send(path: path, method: method, authorization: authorization, body: body)
+            guard version == epoch else { throw IndianaClientError.identityChanged }; return result
+        }
+        if originalAccess == nil && (authorization.hasPrefix("gg_ct_") || (proof?.hasPrefix("gg_ct_") ?? false)) { throw IndianaClientError.unauthenticated }
+        let needsCustomer = originalAccess != nil && (authorization == originalAccess || proof == originalAccess)
+        var token = authorization
+        if needsCustomer {
+            let active = try await access()
+            guard version == epoch else { throw IndianaClientError.identityChanged }
+            if authorization == originalAccess { token = active }
+            if proof == originalAccess { payload?["customerToken"] = active }
+        }
+        let outgoing = proof == originalAccess && needsCustomer ? try payload.map { try JSONSerialization.data(withJSONObject: $0) } : body
+        let result = try await upstream.send(path: path, method: method, authorization: token, body: outgoing)
+        guard !needsCustomer || version == epoch else { throw IndianaClientError.identityChanged }; return result
+    }
+}

package/native-sdk/ios/FeatureClient.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+public struct IndianaFeatureResult: Codable, Sendable {
+    public let value: IndianaJSON
+    public let source: String
+    public let on: Bool
+    public let off: Bool
+    public let ruleId: String
+    public let experimentResult: IndianaJSON?
+}
+
+#if canImport(UIKit)
+import UIKit
+
+/// Local and private/remote Feature evaluation share the SDK's packaged GB engine.
+/// The hidden shell receives no Customer Token; HTTP and identity remain native.
+@MainActor public final class IndianaFeatureClient {
+    private let configuration: IndianaConfiguration
+    private let attributes: [String: IndianaJSON]
+    private let operation: @Sendable (IndianaCustomerOperation, [String: IndianaJSON]) async throws -> IndianaJSON
+    private var host: IndianaBundledWebView!
+    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: "Indiana 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) } })
+        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)])
+        let data = try JSONEncoder().encode(value)
+        try IndianaSchema.validate("nativeFeatureResult", data: data)
+        return try JSONDecoder().decode(IndianaFeatureResult.self, from: data)
+    }
+    public func isOn(_ key: String) async throws -> Bool { try await evalFeature(key).on }
+    public func isOff(_ key: String) async throws -> Bool { try await evalFeature(key).off }
+    public func getFeatureValue(_ key: String, fallback: IndianaJSON = .null) async throws -> IndianaJSON { try await call(["method": .string("getFeatureValue"), "key": .string(key), "fallback": fallback]) }
+    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) }
+    }
+    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)
+            }
+        }
+    }
+    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,
+                  ["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
+        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
+        default: throw IndianaFunnelError.invalidCommand
+        }
+    }
+}
+#endif