@tinkerlandai/indiana-react-native 0.9.1 → 0.9.5

package/native-sdk/android/java/ai/tinkerland/indiana/FunnelSession.kt

@@ -0,0 +1,208 @@
+package ai.tinkerland.indiana
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.json.JSONObject
+import java.net.URI
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicReference
+/** A Funnel session owns navigation. Native financial facts and receipt recovery remain independent. */
+class IndianaFunnelSession internal constructor(private val configuration: IndianaConfiguration, private val http: IndianaHTTP, private val runToken: String, commandStorage: IndianaFunnelCommandStorage? = null, private val publicPaywallContent: (suspend (JSONObject) -> JSONObject)? = null) {
+    @JvmOverloads constructor(configuration: IndianaConfiguration, runToken: String, commandStorage: IndianaFunnelCommandStorage? = null): this(configuration, IndianaURLTransport(configuration), runToken, commandStorage)
+    constructor(context: android.content.Context, configuration: IndianaConfiguration, runToken: String): this(configuration, IndianaURLTransport(configuration), runToken, IndianaFunnelCommandKeystore(context.applicationContext,configuration,runToken))
+    private val journal = commandStorage?.let { IndianaFunnelCommandJournal(it,configuration.scope) }
+    private val restorationMutex = Mutex()
+    private var restored = false
+    private val purchaseRecovery = AtomicReference<JSONObject?>(null)
+    val pendingPurchase: JSONObject? get() = purchaseRecovery.get()?.let { JSONObject(it.toString()) }
+    private data class Identity(val token: String?, val epoch: UUID)
+    private val identity = AtomicReference(Identity(null, UUID.randomUUID()))
+    private val view = AtomicReference<JSONObject?>(null)
+    private val response = AtomicReference<JSONObject?>(null)
+    private val publicPresentation = AtomicReference<JSONObject?>(null)
+    private val pending = AtomicReference<String?>(null)
+    private val closingCommand = AtomicReference<String?>(null)
+    private val uncertain = java.util.concurrent.ConcurrentHashMap.newKeySet<String>()
+    private val settlements = java.util.concurrent.ConcurrentHashMap<String,String>()
+    @Volatile private var closeRequested = false
+    private val mutex = Mutex()
+    private val responseMutex = Mutex()
+    private val responseState = Any()
+    @Volatile private var invalidated = false
+    private var onInvalidated: (() -> Unit)? = null
+    init { if (!runToken.matches(Regex("gg_fr_[A-Za-z0-9_-]{43}"))) throw IndianaClientException("invalid_run_token") }
+    val current: JSONObject? get() = view.get()?.let { JSONObject(it.toString()) }
+    internal fun hostConfiguration() = configuration
+    internal fun hostPendingCommand(): JSONObject? = (closingCommand.get() ?: pending.get())?.let { JSONObject(it) }
+    internal fun onInvalidation(callback: () -> Unit) { onInvalidated = callback;if (invalidated) callback() }
+    fun identify(customerToken: String) = synchronized(responseState) {
+        if (invalidated || !customerToken.matches(Regex("gg_ct_[A-Za-z0-9_-]{32,128}"))) throw IndianaClientException("unauthenticated")
+        identity.set(Identity(customerToken, UUID.randomUUID()));response.set(null);publicPresentation.set(null)
+    }
+    fun reset() {
+        val callback = synchronized(responseState) {
+            invalidated = true;identity.set(Identity(null, UUID.randomUUID()));pending.set(null);closingCommand.set(null);purchaseRecovery.set(null);uncertain.clear();settlements.clear();view.set(null);response.set(null);publicPresentation.set(null)
+            val callback = onInvalidated;onInvalidated = null;callback
+        }
+        callback?.invoke()
+    }
+    private suspend fun restoreCommands() {
+        if (journal == null || restored) return
+        restorationMutex.withLock {
+            if (restored) return@withLock
+            val actor = identity.get();val record = journal.load()
+            if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+            pending.set(record?.optJSONObject("command")?.toString());closingCommand.set(record?.optJSONObject("closeCommand")?.toString());purchaseRecovery.set(record?.optJSONObject("purchase"))
+            closeRequested = record?.optBoolean("closed") == true || record?.optJSONObject("command")?.optString("operation") == "close"
+            for (command in listOf(pending.get(),closingCommand.get())) command?.let { uncertain.add(JSONObject(it).getString("requestId")) }
+            restored = true
+        }
+    }
+    private suspend fun call(command: JSONObject): JSONObject {
+        restoreCommands()
+        if (invalidated) throw IndianaClientException("identity_changed")
+        val actor = identity.get();val body = JSONObject(command.toString());actor.token?.let { body.put("customerToken", it) }
+        if (body.toString().toByteArray(Charsets.UTF_8).size > 262144) throw IndianaClientException("invalid_command")
+        IndianaSchema.validate("command", body)
+        val next = http.send("funnels", "POST", runToken, body)
+        return responseMutex.withLock {
+        if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+        IndianaSchema.validate("response", next)
+        val scope = next.getJSONObject("scope")
+        if (scope.getString("projectId") != configuration.scope.projectId.toString() || scope.getString("environment") != configuration.scope.environment.value) throw IndianaClientException("scope_mismatch")
+        val run = next.getJSONObject("run");val previous = view.get();val source = run.getJSONObject("source")
+        if (source.getString("type") != "funnel" || previous != null && (previous.getString("id") != run.getString("id") || !IndianaSchema.equal(previous.getJSONObject("source"), source) || previous.getString("locale") != run.getString("locale") || !IndianaSchema.equal(previous.getJSONObject("parameters"), run.getJSONObject("parameters")))) throw IndianaClientException("invalid_response")
+        journal?.bind(run)
+        run.optJSONObject("instruction")?.takeIf { it.optString("type") == "open_url" }?.let { https(it.getString("url")) }
+        val settlementId = command.optString("settlementRequestId").ifEmpty { command.optString("requestId") }
+        if (settlementId.isNotEmpty() && next.optJSONObject("settlement")?.optString("requestId") != settlementId) throw IndianaClientException("invalid_response")
+        synchronized(responseState) {
+            if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+            next.optJSONObject("settlement")?.let { settlements[it.getString("requestId")] = it.getString("state") }
+        }
+        val oldPaywall = previous?.optJSONObject("paywall"); val newPaywall = run.optJSONObject("paywall")
+        if (oldPaywall != null && newPaywall != null && oldPaywall.optString("receiptId") == newPaywall.optString("receiptId") && oldPaywall.getJSONObject("resolution").getJSONObject("content").getJSONObject("artifact").getString("sha256") != newPaywall.getJSONObject("resolution").getJSONObject("content").getJSONObject("artifact").getString("sha256")) throw IndianaClientException("invalid_response")
+        if (oldPaywall != null && newPaywall != null && oldPaywall.optString("receiptId") == newPaywall.optString("receiptId") && newPaywall.optLong("selectionGeneration") < oldPaywall.optLong("selectionGeneration")) return current!!
+        if (journal != null && command.optString("operation") != "review" && (previous == null || run.getInt("revision") >= previous.getInt("revision"))) {
+            val paywall = run.optJSONObject("paywall"); val purchase = paywall ?: next.optJSONObject("purchase"); val operation = purchase?.optJSONObject("operation")
+            val settlement = next.optJSONObject("settlement")?.takeIf { (paywall == null || paywall.optString("purchaseRequestId") == it.optString("requestId")) && (purchaseRecovery.get() == null || purchaseRecovery.get()?.optString("operationId") == it.optString("operationId")) }
+            val operationId = operation?.optString("operationId") ?: purchase?.optJSONObject("quote")?.optString("operationId") ?: settlement?.optString("operationId")?.takeIf { !settlement.isNull("operationId") }
+            val receiptId = purchase?.optString("receiptId") ?: settlement?.optString("receiptId")?.takeIf { !settlement.isNull("receiptId") }
+            if (!operationId.isNullOrEmpty() && !receiptId.isNullOrEmpty()) {
+                val generation = paywall?.optLong("selectionGeneration") ?: purchaseRecovery.get()?.optLong("generation") ?: 0
+                val reference = JSONObject().put("receiptId",receiptId).put("operationId",operationId).put("generation",generation)
+                val terminal = operation?.optString("status") == "complete" || purchase?.optBoolean("canReselect") == true
+                if (generation >= (purchaseRecovery.get()?.optLong("generation") ?: 0L)) {
+                    journal.purchase(reference,terminal,run)
+                    synchronized(responseState) {
+                        if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+                        if (!terminal) purchaseRecovery.set(reference) else if (purchaseRecovery.get()?.optString("operationId") == operationId) purchaseRecovery.set(null)
+                    }
+                }
+            }
+        }
+        synchronized(responseState) {
+            if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+            if (previous == null || run.getInt("revision") >= previous.getInt("revision")) {
+                response.set(JSONObject(next.toString()));view.set(JSONObject(run.toString()))
+            }
+            current!!
+        }
+        }
+    }
+    suspend fun get(data: JSONObject? = null, purchase: JSONObject? = null): JSONObject { restoreCommands(); val command = JSONObject().put("operation", "get");data?.let { command.put("data", it) };val reference = purchase ?: purchaseRecovery.get()?.let { JSONObject().put("receiptId",it.getString("receiptId")).put("operationId",it.getString("operationId")) };reference?.let { command.put("purchase",it) };return call(command) }
+    private suspend fun mutate(command: JSONObject): JSONObject {
+        restoreCommands()
+        val original = command.toString();val closing = command.optString("operation") == "close";val id = command.optString("requestId")
+        if (!closing && closeRequested) throw IndianaClientException("command_pending")
+        suspend fun dispatch(): JSONObject {
+            val slot = if (closing) closingCommand else pending
+            val prior = slot.get();if (prior != null && !IndianaSchema.equal(JSONObject(prior), command)) throw IndianaClientException("command_pending")
+            slot.set(original);val wasUncertain = !uncertain.add(id)
+            try {
+                journal?.let { it.retain(command,current ?: throw IndianaClientException("invalid_command")) }
+                return call(command).also {
+                    val state = settlements[id]
+                    if (it.optJSONObject("pendingRequest")?.optString("requestId") != id && state == "settled" && (!closeRequested || closing || it.optString("status") !in setOf("running","waiting"))) { journal?.settle(id);slot.compareAndSet(original,null);uncertain.remove(id) }
+                }
+            } catch (error: Exception) {
+                val code = (error as? IndianaClientException)?.code?.removePrefix("request_failed_")?.toIntOrNull()
+                if (!wasUncertain && !closeRequested && code != null && code < 500 && code !in setOf(401,425)) { journal?.settle(id);slot.compareAndSet(original,null);uncertain.remove(id) };throw error
+            }
+        }
+        if (closing) { closeRequested = true;return dispatch() }
+        return mutex.withLock { dispatch() }
+    }
+    suspend fun settle(requestId: UUID): JSONObject {
+        val id = requestId.toString();settlements.remove(id)
+        val result = call(JSONObject().put("operation","get").put("settlementRequestId",id))
+        if (settlements[id] == "settled") {
+            journal?.settle(id)
+            for (slot in listOf(pending,closingCommand)) { val old = slot.get();if (old != null && JSONObject(old).optString("requestId") == id) slot.compareAndSet(old,null) };uncertain.remove(id)
+        }
+        return result
+    }
+    private fun base(operation: String, requestId: UUID): JSONObject { val run = current ?: throw IndianaClientException("invalid_command");return JSONObject().put("operation", operation).put("requestId", requestId.toString()).put("nodeId", run.getString("nodeId")).put("visit", run.getInt("visit")).put("revision", run.getInt("revision")) }
+    suspend fun submit(input: JSONObject, requestId: UUID = UUID.randomUUID()) = mutate(base("submit", requestId).put("input", input))
+    suspend fun submit(output: String, answers: JSONObject, selection: JSONObject = JSONObject(), requestId: UUID = UUID.randomUUID()) = submit(JSONObject().put("type", "screen").put("output", output).put("answers", answers).put("selection", selection), requestId)
+    suspend fun back(requestId: UUID = UUID.randomUUID()) = mutate(base("back", requestId))
+    suspend fun shown(requestId: UUID = UUID.randomUUID()) = mutate(base("shown", requestId))
+    suspend fun close(requestId: UUID = UUID.randomUUID()) = mutate(base("close", requestId))
+    suspend fun retry(): JSONObject {
+        restoreCommands(); if (current == null) get()
+        closingCommand.get()?.let { return mutate(JSONObject(it)) }
+        val original = pending.get()?.let { JSONObject(it) } ?: throw IndianaClientException("invalid_command")
+        return if (closeRequested) settle(UUID.fromString(original.getString("requestId"))) else mutate(original)
+    }
+    suspend fun resume(requestId: UUID): JSONObject { restoreCommands();if (current == null) get();if (closeRequested) return settle(requestId);pending.get()?.let { val command = JSONObject(it);if (command.optString("requestId") != requestId.toString()) throw IndianaClientException("command_pending");return mutate(command) };return mutate(JSONObject().put("operation", "resume").put("requestId", requestId.toString())) }
+    internal suspend fun hostCommand(command: JSONObject): JSONObject {
+        if (command.has("customerToken") || command.optString("operation") == "start") throw IndianaClientException("invalid_command")
+        if (command.optString("operation") == "get") { if (command.has("settlementRequestId")) settle(UUID.fromString(command.getString("settlementRequestId"))) else get(command.optJSONObject("data"), command.optJSONObject("purchase")) } else if (command.optString("operation") == "review") call(command) else mutate(command)
+        return hostResponse()
+    }
+    internal fun hostResponse(): JSONObject = response.get()?.let { JSONObject(it.toString()) } ?: throw IndianaClientException("identity_changed")
+    /** Display-only read; settlement and durable purchase recovery never call this transport. */
+    internal suspend fun hostPaywallContent(payload: JSONObject): JSONObject {
+        if (invalidated || payload.keys().asSequence().toSet() != setOf("id", "sha256")) throw IndianaClientException("invalid_command")
+        val paywall = current?.optJSONObject("paywall") ?: throw IndianaClientException("invalid_command")
+        val delivery = paywall.getJSONObject("resolution")
+        if (payload.optString("id") != delivery.getString("id") || payload.optString("sha256") != delivery.getJSONObject("content").getJSONObject("artifact").getString("sha256")) throw IndianaClientException("invalid_command")
+        val actor = identity.get()
+        val loaded = publicPaywallContent?.invoke(delivery) ?: IndianaPaywallContent(configuration).resolve(delivery)
+        if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+        IndianaSchema.validate("paywallResolution", loaded)
+        val active = current?.optJSONObject("paywall") ?: throw IndianaClientException("invalid_response")
+        val latest = active.getJSONObject("resolution")
+        if (!IndianaPaywallContent.validatesHydration(loaded, delivery) || active.getString("receiptId") != paywall.getString("receiptId") || latest.getString("id") != delivery.getString("id") || !IndianaSchema.equal(latest.getJSONObject("content"), delivery.getJSONObject("content"))) throw IndianaClientException("invalid_response")
+        IndianaPaywallContent.applyPresentation(loaded, latest)
+        return synchronized(responseState) {
+            if (invalidated || identity.get().epoch != actor.epoch) throw IndianaClientException("identity_changed")
+            publicPresentation.set(JSONObject().put("receiptId",active.getString("receiptId")).put("resolution",JSONObject(latest.toString())))
+            latest
+        }
+    }
+    private fun presentationButtons(): JSONObject? {
+        val active = current?.optJSONObject("paywall") ?: return null
+        val cached = publicPresentation.get() ?: return null
+        val value = active.getJSONObject("resolution"); val loaded = cached.getJSONObject("resolution")
+        if (active.getString("receiptId") != cached.getString("receiptId") || value.getString("id") != loaded.getString("id") || !IndianaSchema.equal(value.getJSONObject("content"), loaded.getJSONObject("content"))) return null
+        return loaded.getJSONObject("document").getJSONObject("buttons")
+    }
+    internal fun trustedPurchase(offered: JSONObject): JSONObject { val operation = response.get()?.optJSONObject("purchase")?.optJSONObject("operation") ?: current?.optJSONObject("paywall")?.optJSONObject("operation");if (operation == null || !IndianaSchema.equal(operation, offered)) throw IndianaClientException("invalid_command");return JSONObject(operation.toString()) }
+    private fun https(raw: String): URI { val url = URI(raw);if (url.scheme != "https" || url.host == null || url.userInfo != null) throw IndianaClientException("invalid_command");return url }
+    internal fun trustedCheckoutURL(raw: String): URI { val operation = response.get()?.optJSONObject("purchase")?.optJSONObject("operation") ?: current?.optJSONObject("paywall")?.optJSONObject("operation");if (operation?.optString("checkoutUrl") != raw) throw IndianaClientException("invalid_command");return https(raw) }
+    internal fun trustedOpen(offered: JSONObject): URI {
+        val raw = offered.optString("url");val instruction = current?.optJSONObject("instruction");val buttons = presentationButtons()
+        val authoredAction = buttons?.keys()?.asSequence()?.any { key ->
+            buttons.optJSONObject(key)?.optJSONObject("action")?.let { it.optString("type") == "open_url" && it.optString("url") == raw } == true
+        } ?: false
+        val accepted = (instruction?.optString("type") == "open_url" && instruction.optString("url") == raw && instruction.optString("receiptId") == offered.optString("receiptId") && instruction.optString("openIn") == offered.optString("openIn")) || authoredAction
+        if (!accepted) throw IndianaClientException("invalid_command");return https(raw)
+    }
+    internal fun trustedEvent(name: String): String {
+        val instruction = current?.optJSONObject("instruction")
+        val buttons = presentationButtons()
+        val authored = buttons?.keys()?.asSequence()?.any { key -> buttons.optJSONObject(key)?.let { it.optString("type") == "action" && it.optJSONObject("action")?.let { action -> action.optString("type") == "event" && action.optString("event") == name } == true } == true } ?: false
+        if (!(instruction?.optString("type") == "event" && instruction.optString("event") == name) && !authored) throw IndianaClientException("invalid_command")
+        return name
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/FunnelView.kt

@@ -0,0 +1,71 @@
+package ai.tinkerland.indiana
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Color
+import android.net.Uri
+import android.widget.FrameLayout
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+import java.net.URI
+
+/** Native container for the sole Funnel renderer. No JavaScript interface or credential is exposed. */
+class IndianaFunnelView(private val activity: Activity, val session: IndianaFunnelSession): FrameLayout(activity) {
+    var onPurchase: (suspend (JSONObject) -> Unit)? = null
+    var onEvent: (suspend (String) -> Unit)? = null
+    /** Opens an external page or Paywall link (openIn is same_window or new_window). Return false when it could not be
+     * opened; an external page then takes its failed route. Default: the system browser. */
+    var onOpenUrl: (suspend (URI, String) -> Boolean)? = null
+    var onComplete: ((JSONObject) -> Unit)? = null
+    var onDismiss: (() -> Unit)? = null
+    var onError: ((Exception) -> Unit)? = null
+    private val work = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    private val configurationRelay = IndianaFunnelConfigurationRelay(session.hostConfiguration())
+    private var stopped = false; private var completed = false; private var dismissed = false
+    private val host = IndianaBundledWebView(activity, "Funnel", work, ::dispatch) { onError?.invoke(it) }
+    init {
+        setBackgroundColor(Color.TRANSPARENT)
+        addView(host.view, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        session.onInvalidation { post { destroy() } }
+        host.start()
+    }
+    private suspend fun dispatch(method: String, raw: Any?): Any? = when (method) {
+        "ready" -> { send(JSONObject().put("event", "init").put("scope", JSONObject().put("projectId", session.hostConfiguration().scope.projectId.toString()).put("environment", session.hostConfiguration().scope.environment.value)).put("apiOrigin", session.hostConfiguration().apiOrigin)); null }
+        "pendingCommand" -> session.hostPendingCommand()
+        "configuration" -> configurationRelay.read(raw)
+        "command" -> session.hostCommand(raw as? JSONObject ?: throw IndianaClientException("invalid_command"))
+        "paywallContent" -> session.hostPaywallContent(raw as? JSONObject ?: throw IndianaClientException("invalid_command"))
+        "purchase" -> { val operation = (raw as? JSONObject)?.optJSONObject("operation") ?: throw IndianaClientException("invalid_command");val trusted = session.trustedPurchase(operation);val handler = onPurchase ?: throw IndianaClientException("unsupported_capability");handler(trusted);null }
+        "checkout" -> { val value = (raw as? JSONObject)?.optString("url") ?: throw IndianaClientException("invalid_command");val url = session.trustedCheckoutURL(value);activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url.toString())).addCategory(Intent.CATEGORY_BROWSABLE));null }
+        "open" -> {
+            val offered = raw as? JSONObject ?: throw IndianaClientException("invalid_command")
+            val url = session.trustedOpen(offered);val openIn = offered.optString("openIn", "same_window")
+            onOpenUrl?.invoke(url, openIn) ?: try {
+                activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url.toString())).addCategory(Intent.CATEGORY_BROWSABLE));true
+            } catch (_: android.content.ActivityNotFoundException) { false }
+        }
+        "event" -> { val name = (raw as? JSONObject)?.optString("event") ?: throw IndianaClientException("invalid_command");val trusted = session.trustedEvent(name);val handler = onEvent ?: throw IndianaClientException("unsupported_capability");handler(trusted);null }
+        "complete" -> {
+            val run = session.current ?: throw IndianaClientException("run_required")
+            if (run.getString("status") != "completed" || !run.isNull("instruction")) throw IndianaClientException("invalid_command")
+            if (!completed) { completed = true; onComplete?.invoke(run) }; null
+        }
+        "dismiss" -> { if (!dismissed) { dismissed = true; onDismiss?.invoke() }; null }
+        else -> throw IndianaClientException("invalid_command")
+    }
+    private fun send(value: JSONObject) { if (!stopped) host.send(value) }
+    fun refresh() { send(JSONObject().put("event", "refresh")) }
+    override fun onWindowFocusChanged(hasWindowFocus: Boolean) { super.onWindowFocusChanged(hasWindowFocus); if (hasWindowFocus) refresh() }
+    /** Programmatic destruction removes private UI; it does not report business completion. */
+    fun destroy() {
+        if (stopped) return
+        send(JSONObject().put("event", "invalidated")); stopped = true
+        host.destroy(); work.cancel(); removeView(host.view)
+        if (!dismissed) { dismissed = true; onDismiss?.invoke() }
+    }
+    fun close() { work.launch { try { session.close() } catch (error: Exception) { onError?.invoke(error) } finally { destroy() } } }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/GeneratedProtocol.kt

@@ -0,0 +1,16 @@
+// Generated by scripts/sdk/generate-native-protocol.mjs. Do not edit.
+package ai.tinkerland.indiana
+enum class IndianaEnvironment(val value: String) { SANDBOX("sandbox"), LIVE("live") }
+internal object IndianaProtocol {
+    val wireProtocol = "0.9"
+    val uuidPattern = Regex("^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)\$")
+    val utcPattern = Regex("^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))\$")
+    val scopeKeys = setOf("projectId", "environment")
+    val runKeys = setOf("id", "source", "revision", "visit", "nodeId", "nodeType", "status", "stopped", "canBack", "authenticated", "locale", "answers", "parameters", "variables", "output", "screen", "paywall", "instruction", "pendingRequest", "runExpiresAt", "credentialExpiresAt")
+    val runRequiredKeys = setOf("id", "source", "revision", "visit", "nodeId", "nodeType", "status", "stopped", "canBack", "authenticated", "locale", "answers", "parameters", "variables", "output", "screen", "paywall", "instruction", "pendingRequest", "runExpiresAt", "credentialExpiresAt")
+    val nodeTypes = setOf("entry", "screen", "condition", "split", "feature", "action", "external_page", "wait", "end", "offering", "coupon", "coupons", "output")
+    val runStatuses = setOf("running", "waiting", "completed", "closed", "ineligible", "failed")
+    val nonCanonicalLocaleLanguages = setOf("aam", "aar", "abk", "adp", "afr", "agp", "ais", "ajp", "ajt", "aju", "aka", "alb", "als", "amh", "ara", "arb", "arg", "arm", "asd", "asm", "aue", "ava", "ave", "aym", "ayr", "ayx", "aze", "azj", "bak", "bam", "baq", "baz", "bcc", "bcl", "bel", "ben", "bgm", "bhk", "bic", "bih", "bis", "bjd", "bjq", "bkb", "blg", "bod", "bos", "bre", "btb", "bul", "bur", "bxk", "bxr", "cat", "ccq", "ces", "cha", "che", "chi", "chu", "chv", "cjr", "cka", "cld", "cls", "cmk", "cmn", "cnr", "cor", "cos", "coy", "cqu", "cre", "cwd", "cym", "cze", "daf", "dan", "dap", "deu", "dgo", "dhd", "dik", "diq", "dit", "div", "djl", "dkl", "drh", "drr", "drw", "dud", "duj", "dut", "dwl", "dzo", "ekk", "ell", "elp", "emk", "eng", "epo", "esk", "est", "eus", "ewe", "fao", "fas", "fat", "fij", "fin", "fra", "fre", "fry", "fuc", "ful", "gav", "gaz", "gbc", "gbo", "geo", "ger", "gfx", "ggn", "ggo", "ggr", "gio", "gla", "gle", "glg", "gli", "glv", "gno", "gom", "gre", "grn", "gti", "gug", "guj", "guv", "gya", "hat", "hau", "hbs", "hdn", "hea", "heb", "her", "him", "hin", "hmo", "hrr", "hrv", "hun", "hye", "ibi", "ibo", "ice", "ido", "iii", "ike", "iku", "ile", "ill", "ilw", "in", "ina", "ind", "ipk", "isl", "ita", "iw", "izi", "jar", "jav", "jaw", "jeg", "ji", "jpn", "jw", "kal", "kan", "kas", "kat", "kau", "kaz", "kdv", "kgc", "kgd", "kgh", "kgm", "khk", "khm", "kik", "kin", "kir", "kmr", "knc", "kng", "koj", "kom", "kon", "kor", "kpp", "kpv", "krm", "ktr", "kua", "kur", "kvs", "kwq", "kxe", "kxl", "kzh", "kzj", "kzt", "lak", "lao", "lat", "lav", "lbk", "leg", "lii", "lim", "lin", "lit", "llo", "lmm", "ltz", "lub", "lug", "lvs", "mac", "mah", "mal", "mao", "mar", "may", "meg", "mgx", "mhr", "mkd", "mlg", "mlt", "mnk", "mnt", "mo", "mof", "mol", "mon", "mri", "msa", "mst", "mup", "mwd", "mwj", "mya", "myd", "myt", "nad", "nau", "nav", "nbf", "nbl", "nbx", "ncp", "nde", "ndo", "nep", "nld", "nln", "nlr", "nno", "nns", "nnx", "nob", "nom", "noo", "nor", "npi", "nts", "nxu", "nya", "oci", "ojg", "oji", "ori", "orm", "ory", "oss", "oun", "pan", "pat", "pbu", "pcr", "per", "pes", "pli", "plt", "pmc", "pmk", "pmu", "pnb", "pol", "por", "ppa", "ppr", "prp", "prs", "pry", "pus", "puz", "que", "quz", "rmr", "rmy", "roh", "ron", "rum", "run", "rus", "sag", "san", "sap", "sca", "scc", "scr", "sgl", "sh", "sin", "skk", "slk", "slo", "slv", "smd", "sme", "smo", "sna", "snb", "snd", "som", "sot", "spa", "spy", "sqi", "src", "srd", "srp", "ssw", "sul", "sum", "sun", "swa", "swc", "swe", "swh", "szd", "tah", "tam", "tat", "tdu", "tel", "tgg", "tgk", "tgl", "tha", "thc", "thw", "thx", "tib", "tid", "tie", "tir", "tkk", "tl", "tlw", "tmk", "tmp", "tne", "tnf", "ton", "tpw", "tsf", "tsn", "tso", "ttq", "tuk", "tur", "twi", "uig", "ukr", "umu", "unp", "uok", "urd", "uzb", "uzn", "ven", "vie", "vol", "wel", "wgw", "wit", "wiw", "wln", "wol", "xba", "xho", "xia", "xkh", "xpe", "xrq", "xsj", "xsl", "xss", "ybd", "ydd", "yen", "yid", "yiy", "yma", "ymt", "yor", "yos", "yuu", "zai", "zha", "zho", "zir", "zkb", "zsm", "zul", "zyb")
+    val nonCanonicalLocaleScripts = setOf("Qaai")
+    val nonCanonicalLocaleRegions = setOf("AN", "BU", "CS", "CT", "DD", "DY", "FQ", "FX", "HV", "JT", "MI", "NH", "NQ", "NT", "PC", "PU", "PZ", "QU", "RH", "SU", "TP", "UK", "VD", "WK", "YD", "YU", "ZR", "004", "008", "010", "012", "016", "020", "024", "028", "031", "032", "036", "040", "044", "048", "050", "051", "052", "056", "060", "062", "064", "068", "070", "072", "074", "076", "084", "086", "090", "092", "096", "100", "104", "108", "112", "116", "120", "124", "132", "136", "140", "144", "148", "152", "156", "158", "162", "166", "170", "172", "174", "175", "178", "180", "184", "188", "191", "192", "196", "200", "203", "204", "208", "212", "214", "218", "222", "226", "230", "231", "232", "233", "234", "238", "239", "242", "246", "248", "249", "250", "254", "258", "260", "262", "266", "268", "270", "275", "276", "278", "280", "288", "292", "296", "300", "304", "308", "312", "316", "320", "324", "328", "332", "334", "336", "340", "344", "348", "352", "356", "360", "364", "368", "372", "376", "380", "384", "388", "392", "398", "400", "404", "408", "410", "414", "417", "418", "422", "426", "428", "430", "434", "438", "440", "442", "446", "450", "454", "458", "462", "466", "470", "474", "478", "480", "484", "492", "496", "498", "499", "500", "504", "508", "512", "516", "520", "524", "528", "530", "531", "532", "533", "534", "535", "536", "540", "548", "554", "558", "562", "566", "570", "574", "578", "580", "581", "582", "583", "584", "585", "586", "591", "598", "600", "604", "608", "612", "616", "620", "624", "626", "630", "634", "638", "642", "643", "646", "652", "654", "659", "660", "662", "663", "666", "670", "674", "678", "682", "686", "688", "690", "694", "702", "703", "704", "705", "706", "710", "716", "720", "724", "728", "729", "732", "736", "740", "744", "748", "752", "756", "760", "762", "764", "768", "772", "776", "780", "784", "788", "792", "795", "796", "798", "800", "804", "807", "810", "818", "826", "830", "831", "832", "833", "834", "840", "850", "854", "858", "860", "862", "876", "882", "886", "887", "890", "891", "894", "958", "959", "960", "962", "963", "964", "965", "966", "967", "968", "969", "970", "971", "972", "973", "974", "975", "976", "977", "978", "979", "980", "981", "982", "983", "984", "985", "986", "987", "988", "989", "990", "991", "992", "993", "994", "995", "996", "997", "998", "999")
+}

package/native-sdk/android/java/ai/tinkerland/indiana/GoogleStorefront.kt

@@ -0,0 +1,165 @@
+package ai.tinkerland.indiana
+
+import android.app.Activity
+import android.content.Context
+import org.json.JSONObject
+import java.math.BigInteger
+import com.android.billingclient.api.*
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.Dispatchers
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class IndianaStoreException(val code: String) : Exception(code)
+data class GooglePurchaseEvidence(val productId: String, val purchaseToken: String, val pending: Boolean, val accountBinding: String?, val intentBinding: String?) {
+    override fun toString()="GooglePurchaseEvidence(productId=$productId, pending=$pending, purchaseToken=[redacted])"
+}
+data class GooglePricePhase(val displayPrice: String, val currency: String, val micros: String, val billingPeriod: String, val billingCycleCount: Int, val recurrenceMode: Int)
+data class GoogleQuote(val productId: String, val phases: List<GooglePricePhase>, val offerToken: String?, val replacementPolicy:String? = null)
+class GoogleReplacement(val sourceProductId:String,val oldPurchaseToken:String) {
+    override fun toString() = "GoogleReplacement(sourceProductId=$sourceProductId, oldPurchaseToken=[redacted])"
+}
+internal fun googleReplacement(instruction:JSONObject,purchases:List<GooglePurchaseEvidence>):GoogleReplacement {
+    val replacement=instruction.getJSONObject("replacement")
+    if(replacement.optString("policy") != "google_full_price") throw IndianaClientException("invalid_response")
+    val source=purchases.singleOrNull { it.productId == text(replacement,"sourceProductId") && it.intentBinding == text(replacement,"sourceOrderId") && it.accountBinding == text(instruction,"obfuscatedAccountId") && !it.pending } ?: throw IndianaClientException("source_purchase_unavailable")
+    return GoogleReplacement(source.productId,source.purchaseToken)
+}
+data class GoogleStoreTerms(val productKind: String, val offerKind: String, val currency: String, val catalogMinor: Long, val discountMinor: Long, val trialDays: Int?, val seats: List<Pair<String, Int>>, val replacement:GoogleReplacement? = null) {
+    companion object {
+        fun parse(raw: JSONObject): GoogleStoreTerms = safe {
+            val productKind = text(raw,"productKind");require(productKind in setOf("membership","lifetime","credit_pack"))
+            val kind = text(raw, "offerKind"); require(kind in setOf("none", "introductory", "promotional"))
+            val currency = text(raw, "currency"); require(currency.matches(Regex("[A-Z]{3}")))
+            fun amount(key: String): Long { val number = raw.get(key) as? Number ?: throw IllegalArgumentException(); val integer = number.toLong(); require(integer in 0..100000000 && number.toDouble() == integer.toDouble()); return integer }
+            val catalog = amount("catalogAmountMinor"); val discount = amount("discountMinor"); require(discount <= catalog)
+            require(raw.has("trialDays")); val trial = if (raw.isNull("trialDays")) null else amount("trialDays").toInt().also { require(it in 1..730) }
+            require(raw.has("applePromotionalOffer") && raw.isNull("applePromotionalOffer"))
+            val bundles = raw.getJSONArray("seatBundle"); require(bundles.length() <= 20)
+            val seats = (0 until bundles.length()).map { index ->
+                val seat = bundles.getJSONObject(index); keys(seat, setOf("key", "quantity")); val key = text(seat, "key"); require(key.matches(Regex("[a-z][a-z0-9_]{0,63}")))
+                val quantity = seat.get("quantity") as? Number ?: throw IllegalArgumentException(); require(quantity.toInt() in 1..10000 && quantity.toDouble() == quantity.toInt().toDouble()); key to quantity.toInt()
+            }; require(seats.map { it.first }.distinct().size == seats.size)
+            require(trial == null || discount == 0L); require(kind != "none" || (trial == null && discount == 0L))
+            return@safe GoogleStoreTerms(productKind, kind, currency, catalog, discount, trial, seats)
+        }
+    }
+    fun validate(quote: GoogleQuote): GoogleQuote {
+        val scale = if (currency in setOf("JPY", "KRW", "VND")) BigInteger.valueOf(1000000) else BigInteger.valueOf(10000)
+        fun minor(phase: GooglePricePhase): Long {
+            if (phase.currency != currency) throw IndianaStoreException("commercial_terms_changed")
+            val micros = phase.micros.toBigInteger(); if (micros.signum() < 0 || micros.remainder(scale) != BigInteger.ZERO) throw IndianaStoreException("commercial_terms_changed")
+            return micros.divide(scale).longValueExact()
+        }
+        val phases = quote.phases
+        if (phases.isNotEmpty() && ((productKind == "membership") != phases.last().billingPeriod.isNotEmpty())) throw IndianaStoreException("commercial_terms_changed")
+        if (phases.isEmpty() || minor(phases.last()) != catalogMinor) throw IndianaStoreException("commercial_terms_changed")
+        if (offerKind == "none") { if (phases.size != 1) throw IndianaStoreException("unexpected_store_offer") }
+        else {
+            if (phases.size != 2 || phases.first().billingCycleCount != 1 || phases.first().recurrenceMode != ProductDetails.RecurrenceMode.FINITE_RECURRING) throw IndianaStoreException("unsupported_offer_duration")
+            val first = phases.first()
+            if (trialDays != null) {
+                val period = Regex("P([0-9]+)([DW])").matchEntire(first.billingPeriod) ?: throw IndianaStoreException("unsupported_trial_period")
+                val days = period.groupValues[1].toLong() * if (period.groupValues[2] == "W") 7 else 1
+                if (minor(first) != 0L || days != trialDays.toLong()) throw IndianaStoreException("commercial_terms_changed")
+            } else if (minor(first) != catalogMinor - discountMinor || first.billingPeriod != phases.last().billingPeriod) throw IndianaStoreException("commercial_terms_changed")
+        }
+        return quote
+    }
+    fun description(quote: GoogleQuote): String = quote.phases.joinToString("\nThen ") { phase ->
+        phase.displayPrice + if (phase.billingPeriod.isEmpty()) "" else " / " + phase.billingPeriod + if (phase.billingCycleCount > 0) " × " + phase.billingCycleCount else ""
+    } + (if (quote.phases.last().billingPeriod.isNotEmpty()) "\nAuto-renews until canceled in Google Play." else "") + (if (seats.isNotEmpty()) "\nIncluded seats: " + seats.joinToString(", ") { "${it.first}: ${it.second}" } else "")
+}
+sealed interface GoogleStoreResult {
+    data class Purchased(val evidence: GooglePurchaseEvidence): GoogleStoreResult
+    data object Canceled: GoogleStoreResult
+    data class Failed(val code: String): GoogleStoreResult
+}
+
+/** The backend owns acknowledge/consume. Purchase callbacks never grant customer access. */
+class GoogleStorefront(context: Context, private val onResult: (GoogleStoreResult) -> Unit) : IndianaGoogleStore {
+    private val client = BillingClient.newBuilder(context.applicationContext)
+        .setListener { result, purchases ->
+            when (result.responseCode) {
+                BillingClient.BillingResponseCode.OK -> if (purchases.isNullOrEmpty()) onResult(GoogleStoreResult.Failed("invalid_evidence")) else purchases.forEach { purchase ->
+                    if (purchase.products.size != 1 || purchase.quantity != 1 || purchase.purchaseState !in listOf(Purchase.PurchaseState.PURCHASED, Purchase.PurchaseState.PENDING)) onResult(GoogleStoreResult.Failed("unsupported_purchase"))
+                    else onResult(GoogleStoreResult.Purchased(GooglePurchaseEvidence(purchase.products.single(),purchase.purchaseToken,purchase.purchaseState == Purchase.PurchaseState.PENDING,purchase.accountIdentifiers?.obfuscatedAccountId,purchase.accountIdentifiers?.obfuscatedProfileId)))
+                }
+                BillingClient.BillingResponseCode.USER_CANCELED -> onResult(GoogleStoreResult.Canceled)
+                else -> onResult(GoogleStoreResult.Failed("store_unavailable"))
+            }
+        }
+        .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
+        .enableAutoServiceReconnection().build()
+
+    override suspend fun connect() { if(client.isReady)return; suspendCancellableCoroutine<Unit> { continuation ->
+        client.startConnection(object : BillingClientStateListener {
+            override fun onBillingSetupFinished(result: BillingResult) {
+                if (!continuation.isActive) return
+                if (result.responseCode == BillingClient.BillingResponseCode.OK) continuation.resume(Unit)
+                else continuation.resumeWithException(IndianaStoreException("store_unavailable"))
+            }
+            override fun onBillingServiceDisconnected() {}
+        })
+    } }
+    private suspend fun details(productId: String, membership: Boolean): ProductDetails = suspendCancellableCoroutine { continuation ->
+        val request = QueryProductDetailsParams.newBuilder().setProductList(listOf(
+            QueryProductDetailsParams.Product.newBuilder().setProductId(productId)
+                .setProductType(if (membership) BillingClient.ProductType.SUBS else BillingClient.ProductType.INAPP).build()
+        )).build()
+        client.queryProductDetailsAsync(request) { result, products ->
+            if (!continuation.isActive) return@queryProductDetailsAsync
+            val product = products.productDetailsList.firstOrNull { it.productId == productId }
+            if (result.responseCode == BillingClient.BillingResponseCode.OK && product != null) continuation.resume(product)
+            else continuation.resumeWithException(IndianaStoreException("product_unavailable"))
+        }
+    }
+    override suspend fun quote(productId: String, basePlanId: String?, offerId: String?): GoogleQuote = quote(details(productId,basePlanId != null),basePlanId,offerId)
+    private fun quote(product: ProductDetails, basePlanId: String?, offerId: String?): GoogleQuote {
+        if (basePlanId == null) {
+            val offers = product.oneTimePurchaseOfferDetailsList?.filter { it.offerId == offerId } ?: emptyList()
+            if(offers.size != 1) throw IndianaStoreException("unsupported_offer")
+            val offer = offers.single()
+            if (offer.rentalDetails != null || offer.preorderDetails != null || offer.limitedQuantityInfo != null || offer.offerId != offerId) throw IndianaStoreException("unsupported_offer")
+            return GoogleQuote(product.productId,listOf(GooglePricePhase(offer.formattedPrice,offer.priceCurrencyCode,offer.priceAmountMicros.toString(),"",1,ProductDetails.RecurrenceMode.NON_RECURRING)),offer.offerToken)
+        }
+        val offer = product.subscriptionOfferDetails?.firstOrNull { it.basePlanId == basePlanId && it.offerId == offerId }
+            ?: throw IndianaStoreException("offer_unavailable")
+        if (offer.installmentPlanDetails != null) throw IndianaStoreException("unsupported_offer")
+        val phases = offer.pricingPhases.pricingPhaseList
+        if (phases.isEmpty() || phases.size>20 || phases.last().recurrenceMode != ProductDetails.RecurrenceMode.INFINITE_RECURRING) throw IndianaStoreException("unsupported_offer")
+        return GoogleQuote(product.productId,phases.map { GooglePricePhase(it.formattedPrice,it.priceCurrencyCode,it.priceAmountMicros.toString(),it.billingPeriod,it.billingCycleCount,it.recurrenceMode) },offer.offerToken)
+    }
+    override suspend fun purchase(activity: Activity, productId: String, basePlanId: String?, offerId: String?, obfuscatedAccountId: String, obfuscatedProfileId: String, terms: GoogleStoreTerms) {
+        if (obfuscatedAccountId.length !in 1..64) throw IndianaStoreException("invalid_account_binding")
+        val product = details(productId, basePlanId != null)
+        val quote = terms.validate(quote(product, basePlanId, offerId))
+        val item = BillingFlowParams.ProductDetailsParams.newBuilder().setProductDetails(product)
+        quote.offerToken?.let { item.setOfferToken(it) }
+        val flowBuilder = BillingFlowParams.newBuilder()
+        terms.replacement?.let { replacement ->
+            if (basePlanId == null || terms.productKind != "membership" || replacement.oldPurchaseToken.isEmpty()) throw IndianaStoreException("invalid_replacement")
+            item.setSubscriptionProductReplacementParams(BillingFlowParams.ProductDetailsParams.SubscriptionProductReplacementParams.newBuilder()
+                .setOldProductId(replacement.sourceProductId)
+                .setReplacementMode(BillingFlowParams.ProductDetailsParams.SubscriptionProductReplacementParams.ReplacementMode.CHARGE_FULL_PRICE).build())
+            flowBuilder.setSubscriptionUpdateParams(BillingFlowParams.SubscriptionUpdateParams.newBuilder().setOldPurchaseToken(replacement.oldPurchaseToken).build())
+        }
+        val flow = flowBuilder.setProductDetailsParamsList(listOf(item.build()))
+            .setObfuscatedAccountId(obfuscatedAccountId).setObfuscatedProfileId(obfuscatedProfileId).build()
+        val result = withContext(Dispatchers.Main.immediate) { client.launchBillingFlow(activity, flow) }
+        if (result.responseCode != BillingClient.BillingResponseCode.OK) throw IndianaStoreException("purchase_not_started")
+    }
+    override suspend fun scanPurchases(membership: Boolean): List<GooglePurchaseEvidence> = suspendCancellableCoroutine { continuation ->
+        val query = QueryPurchasesParams.newBuilder()
+            .setProductType(if (membership) BillingClient.ProductType.SUBS else BillingClient.ProductType.INAPP).build()
+        client.queryPurchasesAsync(query) { result, purchases ->
+            if (!continuation.isActive) return@queryPurchasesAsync
+            if (result.responseCode != BillingClient.BillingResponseCode.OK) continuation.resumeWithException(IndianaStoreException("store_unavailable"))
+            else continuation.resume(purchases.filter { it.products.size == 1 && it.quantity == 1 }.map {
+                GooglePurchaseEvidence(it.products.single(), it.purchaseToken, it.purchaseState == Purchase.PurchaseState.PENDING,it.accountIdentifiers?.obfuscatedAccountId,it.accountIdentifiers?.obfuscatedProfileId)
+            })
+        }
+    }
+    override fun close() { client.endConnection() }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/HTTPTransport.kt

@@ -0,0 +1,43 @@
+package ai.tinkerland.indiana
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.net.URI
+import java.net.HttpURLConnection
+import java.io.ByteArrayOutputStream
+
+/** Override baseUrl for test services; Sandbox selects business scope within that service. */
+data class IndianaConfiguration(val baseUrl: String = "https://api.tinker.cash",val scope: IndianaScope,val timeoutMs: Int=15_000) {
+    internal val apiOrigin: String get() {
+        val url = URI(baseUrl)
+        return URI(url.scheme.lowercase(), null, url.host.lowercase(), if (url.port == 443) -1 else url.port, null, null, null).toString()
+    }
+    init { val url=URI(baseUrl);require(url.scheme=="https"&&url.host!=null&&url.rawUserInfo==null&&url.rawQuery==null&&url.rawFragment==null&&timeoutMs in 1..120_000) }
+}
+internal interface IndianaHTTP { suspend fun send(path: String,method: String,authorization: String,body: JSONObject?): JSONObject }
+internal fun requireCurrentProtocol(value: String?) {
+    if (value != IndianaProtocol.wireProtocol) throw IndianaClientException("invalid_response")
+}
+internal class IndianaURLTransport(private val configuration: IndianaConfiguration): IndianaHTTP {
+    override suspend fun send(path: String,method: String,authorization: String,body: JSONObject?): JSONObject = withContext(Dispatchers.IO) {
+        require(!path.contains("..")&&!path.contains("?")&&!path.contains("#")&&!path.startsWith("/"))
+        val connection=URI(configuration.baseUrl.trimEnd('/')+"/api/v1/"+path).toURL().openConnection() as HttpURLConnection
+        try {
+            connection.requestMethod=method;connection.instanceFollowRedirects=false;connection.connectTimeout=configuration.timeoutMs;connection.readTimeout=configuration.timeoutMs;connection.useCaches=false
+            if(authorization.isNotEmpty()) connection.setRequestProperty("Authorization","Bearer $authorization")
+            connection.setRequestProperty("Content-Type","application/json")
+            connection.setRequestProperty("X-Indiana-Project",configuration.scope.projectId.toString());connection.setRequestProperty("X-Indiana-Environment",configuration.scope.environment.value)
+            connection.setRequestProperty("X-Indiana-Protocol",IndianaProtocol.wireProtocol)
+            connection.setRequestProperty("X-Indiana-SDK-Version",IndianaSDK.version)
+            if(body!=null){connection.doOutput=true;val bytes=body.toString().toByteArray(Charsets.UTF_8);connection.setFixedLengthStreamingMode(bytes.size);connection.outputStream.use {it.write(bytes)}}
+            if(connection.responseCode !in 200..299)throw IndianaClientException("request_failed_${connection.responseCode}")
+            requireCurrentProtocol(connection.getHeaderField("X-Indiana-Protocol"))
+            if((connection.getHeaderField("Content-Length")?.toLongOrNull() ?: 0)>2_097_152)throw IndianaClientException("invalid_response")
+            val output=ByteArrayOutputStream()
+            connection.inputStream.use {input->val buffer=ByteArray(8192);while(true){val size=input.read(buffer);if(size<0)break;if(output.size()+size>2_097_152)throw IndianaClientException("invalid_response");output.write(buffer,0,size)}}
+            safe{JSONObject(output.toString("UTF-8"))}
+        } catch(e:IndianaClientException){throw e}catch(_:Exception){throw IndianaClientException("temporary_unavailable")}
+        finally {connection.disconnect()}
+    }
+}