@tinkerlandai/longplay-react-native 0.0.0-stage → 0.10.4

package/IndianaReactNative.podspec

@@ -0,0 +1,19 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "IndianaReactNative"
+  s.version = package["version"]
+  s.summary = "Indiana Customer SDK native presentation and StoreKit bridge"
+  s.homepage = "https://longplayai.com"
+  s.license = { :type => "Proprietary" }
+  s.author = "Tinkerland"
+  s.source = { :git => "https://github.com/tinkerlandai/Indiana.git", :tag => "sdk-v#{s.version}" }
+  s.platform = :ios, "16.0"
+  s.swift_version = "6.0"
+  s.source_files = "ios/**/*.{swift,h,m}", "native-sdk/ios/**/*.swift"
+  s.resource_bundles = {
+    "IndianaResources" => ["native-sdk/ios/funnel-wire-schemas.json", "native-sdk/ios/WebView"]
+  }
+  s.frameworks = "StoreKit", "WebKit", "UIKit", "JavaScriptCore"
+  s.dependency "React-Core"
+end

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+<p>
+  <a href="https://longplayai.com">
+    <img src="https://longplayai.com/brand/indiana-mark.png" alt="Longplay" width="72" height="72" />
+  </a>
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Longplay React Native SDK
+
+This source checkout is SDK 0.10.4, protocol 0.10. Publication and runtime promotion are separate; check the [release ledger](../../docs/sdk-releases.md) and [environment state](../../docs/development-status.md) before selecting an install or API target. New capabilities below require this source candidate or its verified publication. Set the API origin explicitly: the SDK default is production.
+
+React Native 0.79+ / Metro 0.82+ uses the shared portable Customer facade: identity/session refresh, holdings, entitlement checks, commercial commands, Coupons/Rewards/Referrals, Offering/Paywall/content resolution, experimentation, Analytics, Messaging and Push adapters. Funnel and independent Paywall data sessions share that identity. Trusted usage writes still go through the merchant backend.
+
+The data client needs Fetch and AbortController, with no DOM or native linking. Optional native integration autolinks the included Swift/Kotlin SDK sources and packaged renderer, adding Funnel/Paywall/content presentation and Apple/Google purchase, restore and subscription-management bridges. It never carries a Server Key.
+
+Install the current release:
+
+```sh
+npm install --save-exact @tinkerlandai/longplay-react-native@latest
+```
+
+The first install resolves latest and saves an exact package.json version. Commit the lockfile and use npm ci for later builds. Use the original package identity and exact version from the [release records](../../docs/sdk-releases.md) for historical installations and rollback. New Longplay package names require their own publication; source changes do not publish artifacts.
+
+```ts
+import { createLongplayReactNative } from "@tinkerlandai/longplay-react-native";
+
+const longplay = createLongplayReactNative({
+  scope: { projectId: "YOUR_APP_UUID", environment: "sandbox" },
+  baseUrl: "https://api.longplayai.com",
+  usageReporter: async (command) => {
+    const response = await fetch("https://your-app.example/api/usage", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${yourAppSessionToken}`,
+      },
+      body: JSON.stringify(command),
+    });
+    if (!response.ok) throw new Error("Usage reporting failed");
+    return response.json();
+  },
+});
+
+// Your backend issues a complete Access/Refresh pair for its authenticated user.
+longplay.identify(session);
+const holdings = await longplay.readHoldings();
+const entitlement = await longplay.checkEntitlement({
+  requirement: {
+    internal_feature_id: "YOUR_FEATURE_UUID",
+    quantity: "1",
+    properties: {},
+  },
+});
+await longplay.trackUsage({
+  eventName: "images",
+  quantity: "1",
+  idempotencyKey: "stable-id-for-this-usage-event",
+});
+longplay.reset();
+```
+
+Never ship a Server Key in the app. `usageReporter` receives only a validated usage command. Your backend authenticates its own app session, selects the Customer and invokes the server SDK with its Server Key; return that SDK's complete usage response unchanged. Preserve the event's idempotency key across retries. The SDK validates response schema and App/environment and rejects results if identity changes while reporting. The callback owns its network timeout and retry policy.
+
+Credentials stay in memory. Passing the complete session pair enables automatic refresh shared by concurrent requests; a bare Access Token requires host-managed renewal. Successful rotation preserves identity; a definitive refresh refusal or expired Refresh Token clears it and stops usage reporting until a new verified login. Call `reset()` at logout. Customer creation and token issuance belong on your backend. The existing `@tinkerlandai/longplay-sdk/react-native` subpath uses the same source implementation; install only one entry in an application.
+
+## Growth, marketing and delivery
+
+The portable client uses the same request/response contracts as the browser Customer client. Use `features(...)` for experimentation, `track(...)` and `flush()` for marketing events, and `listOffers()` / `claimCoupon(...)` for independent Coupons. Marketing events remain separate from trusted usage writes.
+
+Standalone data sessions do not open a UI. `funnel().start(...)` starts under the current Customer; `paywall(...)` prepares an independent Paywall session; `resumeFunnel(runToken)` restores its Run controller. Retain the original request ID for unknown results. Non-browser controllers require a protected `funnelCommandStorage` CAS adapter for durable command recovery. Configuration persistence accepts an explicit `ConfigurationStorage` adapter.
+
+## Optional native presentation and purchases
+
+Build/install this source candidate's package, then run your app's normal CocoaPods installation and native build. iOS requires 16+; the Android native adapter requires API 24+ and the normal Play Billing setup. Native sources and renderer resources are included in the npm package.
+
+Enable core-library API desugaring in the Android application's `build.gradle` for Customer session `java.time` support on API 24–25. The adapter enables the same setting in its library module:
+
+```groovy
+android {
+    compileOptions {
+        coreLibraryDesugaringEnabled true
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+dependencies {
+    coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:2.1.5"
+}
+```
+
+```ts
+import { NativeEventEmitter, NativeModules } from "react-native";
+const bridge = NativeModules.LongplayBridge;
+const events = new NativeEventEmitter(bridge);
+const longplay = createLongplayReactNative({
+  scope: { projectId, environment: "sandbox" },
+  baseUrl: "https://api.dev.longplayai.com",
+  nativeModule: bridge,
+  nativeEvents: (listener) => {
+    const subscription = events.addListener("LongplayAction", listener);
+    return () => subscription.remove();
+  },
+  usageReporter: sendToAuthenticatedBackend,
+});
+longplay.identify(customerSession); // JS owns refresh and supplies native Access Tokens.
+await longplay.native.showFunnel(runToken);
+await longplay.native.showPaywall({
+  paywallId,
+  provider: "apple",
+  currency: "USD",
+});
+await longplay.native.restorePurchases();
+await longplay.native.manageSubscriptions(productId); // Product ID is required on Android.
+await longplay.native.destroy();
+```
+
+Each JS client owns an independent native instance. Logout/account changes close its presentation and invalidate pending results. Direct `purchaseSubscription(operationId, true)` and `switchSubscription(operationId, true)` require explicit purchase acceptance and use native provider verification. Keep the original commercial operation ID for recovery; closing a store sheet does not prove purchase completion.
+
+The JS session is the only Refresh Token owner. Keep `nativeEvents` subscribed while using native capabilities; the bridge requests a current Access Token for each authenticated native request and never receives a Refresh Token. Rotation preserves open native surfaces. An externally managed Access Token can be used without `nativeEvents`; a full Customer session requires the event subscription.
+
+Package versions use the shared `sdk-vX.Y.Z` release. The package includes ESM, CommonJS and TypeScript declarations, native source/resources, autolinking configuration and a portable URL parser. It does not replace application globals; the JS entry's only runtime package dependency is Zod. Native presentation adds the platform frameworks and React Native bridge dependencies. See the repository's [mobile integration guide](https://github.com/tinkerlandai/Indiana/blob/main/docs/mobile-sdk.md) and [release commands](https://github.com/tinkerlandai/Indiana/blob/main/docs/automated-releases.md).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,101 @@
+# GrowthBook core
+
+MIT core port from growthbook/growthbook at ed29827a453ae6b9eba181bdf4e9280d4b670817. No enterprise-licensed code is included.
+
+Copyright (c) 2025 GrowthBook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+# @noble/hashes 2.4.0
+
+SHA-256 for hashed saved-group membership is bundled from `@noble/hashes` 2.4.0.
+Source: https://github.com/paulmillr/noble-hashes
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Paul Miller (https://paulmillr.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+# dom-mutator 0.7.0
+
+GrowthBook declarative DOM mutations use the original `dom-mutator` package.
+Source: https://github.com/growthbook/dom-mutator
+
+MIT License
+
+Copyright (c) 2021 Jeremy Dorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+# whatwg-url-minimum 0.2.0
+
+Bundled URL implementation from https://github.com/expo/whatwg-url-minimum.
+
+MIT License
+
+Copyright (c) Phil Pluckthun,
+Copyright (c) 650 Industries, Inc. (aka Expo),
+Copyright (c) Sebastian Mayr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/build.gradle

@@ -0,0 +1,24 @@
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+android {
+    namespace "ai.tinkerland.indiana.reactnative"
+    compileSdkVersion rootProject.ext.has("compileSdkVersion") ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig { minSdkVersion 24 }
+    sourceSets {
+        main.java.srcDirs += ["../native-sdk/android/java"]
+        main.assets.srcDirs += ["../native-sdk/android/assets"]
+        main.resources.srcDirs += ["../native-sdk/android/resources"]
+    }
+    compileOptions {
+        coreLibraryDesugaringEnabled true
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+dependencies {
+    coreLibraryDesugaring "com.android.tools:desugar_jdk_libs:2.1.5"
+    implementation "com.facebook.react:react-android"
+    implementation "com.android.billingclient:billing:9.1.0"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

package/android/src/main/java/ai/tinkerland/indiana/reactnative/IndianaBridgeModule.kt

@@ -0,0 +1,237 @@
+package ai.tinkerland.indiana.reactnative
+
+import ai.tinkerland.indiana.*
+import android.app.Dialog
+import android.view.View
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.*
+import org.json.JSONObject
+import java.util.UUID
+
+/** Scoped Customer instances, using the native SDK's packaged renderer and store verification. */
+class IndianaBridgeModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+    private class Instance(val client: IndianaClient) {
+        var revision = UUID.randomUUID()
+        var identitySequence = -1L
+        val actions = mutableMapOf<String, CompletableDeferred<Unit>>()
+        val credentials = mutableMapOf<String, CompletableDeferred<String>>()
+        var dismiss: (() -> Unit)? = null
+        var presentation: UUID? = null
+    }
+    private val instances = mutableMapOf<String, Instance>()
+    private val jobs = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    override fun getName() = "IndianaBridge"
+    private fun fields(input: String): JSONObject {
+        require(input.toByteArray(Charsets.UTF_8).size <= 2_097_152)
+        return JSONObject(input)
+    }
+    private fun instance(id: String) = instances[id] ?: throw IllegalArgumentException("Unknown Indiana instance")
+    private fun cancelActions(owner: Instance) {
+        owner.actions.values.toList().forEach { it.completeExceptionally(IllegalStateException("Customer identity changed")) }
+        owner.actions.clear()
+        owner.credentials.values.toList().forEach { it.completeExceptionally(IllegalStateException("Customer identity changed")) }
+        owner.credentials.clear()
+    }
+    private suspend fun credential(id: String): String = withContext(Dispatchers.Main.immediate) {
+        val owner = instance(id); val request = UUID.randomUUID().toString()
+        val result = CompletableDeferred<String>(); owner.credentials[request] = result
+        try {
+            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(
+                "IndianaAction", Arguments.makeNativeMap(mapOf("instanceId" to id, "requestId" to request, "revision" to owner.identitySequence.toDouble(), "kind" to "credential"))
+            )
+            withTimeout(45_000) { result.await() }
+        } finally { owner.credentials.remove(request) }
+    }
+    @ReactMethod fun provideCredential(id: String, requestId: String, token: String?, promise: Promise) = run(promise) {
+        instance(id).credentials.remove(requestId)?.let {
+            if (token != null) it.complete(token) else it.completeExceptionally(IllegalStateException("Customer authentication required"))
+        }
+        null
+    }
+    private fun nativeJson(value: Any?): Any? = when (value) {
+        null, JSONObject.NULL -> null
+        is JSONObject -> value.keys().asSequence().associateWith { nativeJson(value.get(it)) }
+        is org.json.JSONArray -> (0 until value.length()).map { nativeJson(value.get(it)) }
+        else -> value
+    }
+    private suspend fun action(owner: Instance, revision: UUID, payload: JSONObject) {
+        check(owner.revision == revision) { "Customer identity changed" }
+        val id = instances.entries.single { it.value === owner }.key
+        val request = UUID.randomUUID().toString()
+        val result = CompletableDeferred<Unit>()
+        owner.actions[request] = result
+        try {
+            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(
+                "IndianaAction", Arguments.makeNativeMap(mapOf("instanceId" to id, "requestId" to request, "revision" to owner.identitySequence.toDouble(), "action" to nativeJson(payload)))
+            )
+            withTimeout(45_000) { result.await() }
+            check(owner.revision == revision) { "Customer identity changed" }
+        } finally { owner.actions.remove(request) }
+    }
+    @ReactMethod fun addListener(name: String) { }
+    @ReactMethod fun removeListeners(count: Double) { }
+    @ReactMethod fun acknowledge(id: String, requestId: String, accepted: Boolean, promise: Promise) = run(promise) {
+        instance(id).actions.remove(requestId)?.let {
+            if (accepted) it.complete(Unit)
+            else it.completeExceptionally(IllegalStateException("Host action refused"))
+        }
+        null
+    }
+    private fun run(promise: Promise, action: suspend () -> Any?) {
+        jobs.launch {
+            try { promise.resolve(action()) }
+            catch (error: CancellationException) { promise.reject("INDIANA_NATIVE_CANCELLED", "Native operation cancelled") }
+            catch (error: Exception) { promise.reject("INDIANA_NATIVE_ERROR", error.javaClass.simpleName) }
+        }
+    }
+
+    @ReactMethod fun create(configuration: String, promise: Promise) = run(promise) {
+        val input = fields(configuration)
+        val scope = input.getJSONObject("scope")
+        val environment = IndianaEnvironment.entries.single { it.value == scope.getString("environment") }
+        val config = IndianaConfiguration(input.getString("baseUrl"), IndianaScope(UUID.fromString(scope.getString("projectId")), environment), (input.getDouble("timeout") * 1000).toInt())
+        val id = UUID.randomUUID().toString()
+        instances[id] = Instance(IndianaClient(context, config))
+        if (input.optBoolean("credentialEvents")) instances[id]!!.client.setAccessTokenProvider { credential(id) }
+        id
+    }
+
+    @ReactMethod fun identify(id: String, session: String, promise: Promise) = run(promise) {
+        require(session.toByteArray(Charsets.UTF_8).size <= 32768)
+        val owner = instance(id)
+        val frame = fields(session)
+        val rawSequence = frame.getDouble("revision")
+        require(rawSequence.isFinite() && rawSequence >= 0 && rawSequence <= 9007199254740991.0 && rawSequence % 1.0 == 0.0)
+        val sequence = rawSequence.toLong()
+        require(sequence >= 0 && sequence >= owner.identitySequence)
+        owner.identitySequence = sequence
+        owner.revision = UUID.randomUUID(); owner.dismiss?.invoke(); owner.dismiss = null; owner.presentation = null; cancelActions(owner)
+        owner.client.identify(frame.getString("credentials"))
+        null
+    }
+    @ReactMethod fun reset(id: String, revision: Double, promise: Promise) = run(promise) {
+        val owner = instance(id)
+        require(revision.isFinite() && revision >= 0 && revision % 1.0 == 0.0)
+        if (revision.toLong() >= owner.identitySequence) {
+            owner.identitySequence = revision.toLong()
+            owner.revision = UUID.randomUUID(); owner.dismiss?.invoke(); owner.dismiss = null; owner.presentation = null; cancelActions(owner)
+            owner.client.reset()
+        }
+        null
+    }
+    @ReactMethod fun destroy(id: String, promise: Promise) = run(promise) {
+        instances.remove(id)?.let { owner ->
+            owner.revision = UUID.randomUUID(); owner.dismiss?.invoke(); cancelActions(owner); owner.client.close()
+        }
+        null
+    }
+    @ReactMethod fun invoke(id: String, method: String, input: String, promise: Promise) = run(promise) {
+        val owner = instance(id)
+        val original = owner.revision
+        val value = fields(input)
+        val activity = context.currentActivity
+        val result = when (method) {
+            "restorePurchases" -> org.json.JSONArray(owner.client.restorePurchases(context)).toString()
+            "purchaseSubscription", "switchSubscription" -> {
+                require(value.getBoolean("accepted"))
+                val host = activity ?: throw IllegalStateException("Foreground Activity required")
+                val operation = UUID.fromString(value.getString("operationId"))
+                (if (method == "purchaseSubscription") owner.client.purchaseSubscription(host, operation) { true }
+                else owner.client.switchSubscription(host, operation) { true }).toString()
+            }
+            "manageSubscriptions" -> {
+                IndianaStoreSubscriptions.manage(activity ?: throw IllegalStateException("Foreground Activity required"), value.getString("productId"))
+                "null"
+            }
+            "showFunnel", "showPaywall", "showContent" -> present(owner, original, method, value)
+            else -> throw IllegalArgumentException("Unsupported native operation")
+        }
+        check(original == owner.revision) { "Customer identity changed" }
+        result
+    }
+
+    private suspend fun present(owner: Instance, revision: UUID, method: String, input: JSONObject): String {
+        check(owner.presentation == null) { "A native surface is already open" }
+        val activity = context.currentActivity ?: throw IllegalStateException("Foreground Activity required")
+        val reservation = UUID.randomUUID()
+        owner.presentation = reservation
+        val dialog = Dialog(activity)
+        val result = CompletableDeferred<String>()
+        var cleanup: (() -> Unit)? = null
+        fun finish(value: JSONObject) {
+            if (result.complete(value.toString())) {
+                if (owner.presentation == reservation) { owner.dismiss = null; owner.presentation = null }
+                dialog.dismiss()
+                cleanup?.invoke()
+            }
+        }
+        fun failed(error: Throwable) {
+            if (result.completeExceptionally(error)) {
+                if (owner.presentation == reservation) { owner.dismiss = null; owner.presentation = null }
+                dialog.dismiss()
+                cleanup?.invoke()
+            }
+        }
+        val dismissed = { finish(JSONObject().put("status", "dismissed")) }
+        val purchase: suspend (JSONObject) -> Unit = { operation ->
+            check(owner.revision == revision) { "Customer identity changed" }
+            owner.client.purchaseSubscription(activity, UUID.fromString(operation.getString("operationId"))) { true }
+            Unit
+        }
+        return try {
+        val view: View = when (method) {
+            "showFunnel" -> {
+                val session = owner.client.funnel(input.getString("runToken"))
+                IndianaFunnelView(activity, session).also {
+                    cleanup = it::destroy
+                    it.onPurchase = purchase; it.onDismiss = dismissed; it.onError = ::failed
+                    it.onEvent = { name -> action(owner, revision, JSONObject().put("type", "event").put("name", name)) }
+                    it.onComplete = { run -> finish(JSONObject().put("status", "complete").put("result", run)) }
+                }
+            }
+            "showPaywall" -> {
+                val provider = IndianaSubscriptionProvider.entries.single { it.value == input.getString("provider") }
+                val session = owner.client.paywall(
+                    paywallId = input.optString("paywallId").takeIf(String::isNotEmpty)?.let(UUID::fromString),
+                    paywallVersionId = input.optString("paywallVersionId").takeIf(String::isNotEmpty)?.let(UUID::fromString),
+                    provider = provider, currency = input.getString("currency"), locale = input.optString("locale", "en")
+                )
+                IndianaPaywallView(activity, session).also {
+                    cleanup = it::destroy
+                    it.onPurchase = purchase; it.onDismiss = dismissed; it.onError = ::failed
+                    it.onEvent = { name -> action(owner, revision, JSONObject().put("type", "event").put("name", name)) }
+                    it.onComplete = { operation -> finish(JSONObject().put("status", "complete").put("result", operation)) }
+                }
+            }
+            else -> {
+                val session = owner.client.content(JSONObject().put("kind", input.get("kind")).put("selector", input.get("selector")), input.optString("locale", "en"), input.optJSONObject("inputs") ?: JSONObject())
+                IndianaContentView(activity, session).also {
+                    cleanup = it::destroy
+                    it.onDismiss = dismissed; it.onError = ::failed
+                    it.onAction = { payload -> action(owner, revision, payload) }
+                }
+            }
+        }
+        check(owner.revision == revision && owner.presentation == reservation) { "Customer identity changed" }
+        owner.dismiss = dismissed
+        dialog.setContentView(view)
+        dialog.setOnCancelListener { dismissed() }
+        dialog.show()
+        result.await()
+        }
+        finally {
+            if (owner.presentation == reservation) { owner.dismiss = null; owner.presentation = null }
+            dialog.dismiss()
+            cleanup?.invoke()
+        }
+    }
+    override fun invalidate() {
+        jobs.launch {
+            instances.values.forEach { it.dismiss?.invoke(); cancelActions(it); it.client.close() }
+            instances.clear()
+            jobs.cancel()
+        }
+        super.invalidate()
+    }
+}

package/android/src/main/java/ai/tinkerland/indiana/reactnative/IndianaBridgePackage.kt

@@ -0,0 +1,11 @@
+package ai.tinkerland.indiana.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class IndianaBridgePackage : ReactPackage {
+    override fun createNativeModules(context: ReactApplicationContext): List<NativeModule> = listOf(IndianaBridgeModule(context))
+    override fun createViewManagers(context: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}