@amplytools/react-native-amply-sdk 0.4.0 → 0.4.1

package/AmplyReactNative.podspec

@@ -22,7 +22,7 @@ Pod::Spec.new do |s|
   s.dependency 'React-RCTFabric'
 
   # Amply KMP SDK from CocoaPods
-  s.dependency 'AmplySDK', '~> 0.4.0'
+  s.dependency 'AmplySDK', '~> 0.4.1'
 
   s.libraries = 'c++'
   s.pod_target_xcconfig = {

package/android/build.gradle

@@ -15,7 +15,7 @@ buildscript {
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
 
-def amplySdkVersion = project.findProperty('amplySdkVersion') ?: System.getenv('AMPLY_SDK_VERSION') ?: '0.4.0'
+def amplySdkVersion = project.findProperty('amplySdkVersion') ?: System.getenv('AMPLY_SDK_VERSION') ?: '0.4.1'
 group = 'tools.amply'
 version = amplySdkVersion
 

package/android/src/main/java/tools/amply/sdk/reactnative/AmplyModule.kt

@@ -42,6 +42,7 @@ class AmplyModule(reactContext: ReactApplicationContext) :
   private var lifecycleRegistered = false
   private var systemEventsJob: Job? = null
   private var logEventsJob: Job? = null
+  private var campaignPresenterJob: Job? = null
 
   override fun getName(): String = NAME
 
@@ -93,6 +94,55 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun trackEventGated(event: String, properties: ReadableMap, promise: Promise) {
+    if (event.isBlank()) {
+      promise.reject(ARGUMENT_ERROR, "Event 'event' is required")
+      return
+    }
+    val props = properties.toHashMap()
+    // The Promise IS the continuation. We resolve "complete"/"cancel" exactly once;
+    // the KMP overload guarantees exactly-once main-thread delivery, and resolveOnce
+    // guards against the (impossible-but-defensive) double settle.
+    val resolved = java.util.concurrent.atomic.AtomicBoolean(false)
+    fun resolveOnce(decision: String) {
+      if (resolved.compareAndSet(false, true)) {
+        promise.resolve(decision)
+      }
+    }
+    try {
+      client.trackEventGated(
+        event,
+        props,
+        onProceed = { resolveOnce("complete") },
+        onCancel = { resolveOnce("cancel") },
+      )
+    } catch (throwable: Throwable) {
+      // Fail open: a synchronous failure proceeds rather than stranding the app.
+      android.util.Log.w(TAG, "trackEventGated failed; proceeding (fail-open)", throwable)
+      resolveOnce("complete")
+    }
+  }
+
+  override fun resolveCampaign(mediationId: String, result: String) {
+    client.resolveCampaign(mediationId, result)
+  }
+
+  override fun registerCampaignPresenter() {
+    if (campaignPresenterJob == null) {
+      campaignPresenterJob = scope.launch {
+        client.campaignPresents.collect { payload ->
+          android.util.Log.i(
+            TAG,
+            "Emitting campaign present to JS mediationId=${payload.mediationId} url=${payload.url}"
+          )
+          emitCampaignPresent(payload.mediationId, payload.url, payload.info)
+        }
+      }
+      android.util.Log.i(TAG, "Started campaign present collection job")
+    }
+    client.registerCampaignPresenter()
+  }
+
   override fun getRecentEvents(limit: Double, promise: Promise) {
     scope.launch {
       try {
@@ -212,6 +262,8 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     systemEventsJob = null
     logEventsJob?.cancel()
     logEventsJob = null
+    campaignPresenterJob?.cancel()
+    campaignPresenterJob = null
     lastEmittedDeepLinkId = null
     client.shutdown()
   }
@@ -228,6 +280,16 @@ class AmplyModule(reactContext: ReactApplicationContext) :
     android.util.Log.d(TAG, "emitOnDeepLink completed")
   }
 
+  private fun emitCampaignPresent(mediationId: String, url: String, info: Map<String, Any?>) {
+    val map = Arguments.createMap().apply {
+      putString("url", url)
+      putMap("info", info.toWritableMap())
+      putString("mediationId", mediationId)
+    }
+    // emitOnCampaignPresent comes from NativeAmplyModuleSpec (codegen).
+    emitOnCampaignPresent(map)
+  }
+
   private fun emitSystemEvent(event: EventEnvelope) {
     emitOnSystemEvent(event.toWritableMap())
   }

package/android/src/main/java/tools/amply/sdk/reactnative/core/AmplyClient.kt

@@ -6,6 +6,7 @@ import tools.amply.sdk.reactnative.model.DataSetType
 import tools.amply.sdk.reactnative.model.DeepLinkPayload
 import tools.amply.sdk.reactnative.model.EventEnvelope
 import tools.amply.sdk.reactnative.model.LogLevel
+import tools.amply.sdk.reactnative.model.CampaignPresentPayload
 import kotlinx.coroutines.flow.SharedFlow
 
 interface AmplyClient {
@@ -13,12 +14,46 @@ interface AmplyClient {
   val systemEvents: SharedFlow<EventEnvelope>
   val logEvents: SharedFlow<EventEnvelope>
 
+  /**
+   * Stream of campaign present (blocking) action dispatches awaiting a JS-reported result.
+   * Each emission carries a unique `mediationId` to be echoed back via
+   * [resolveCampaign].
+   */
+  val campaignPresents: SharedFlow<CampaignPresentPayload>
+
   suspend fun initialize(options: AmplyInitializationOptions)
 
   fun isInitialized(): Boolean
 
   suspend fun track(name: String, properties: Map<String, Any?>?)
 
+  /**
+   * Gated form of track. Wraps the KMP `trackEvent` continuation overload:
+   * records the event, evaluates campaigns, and (if a blocking action matched and a
+   * presenter is registered) dispatches the campaign present and awaits its result
+   * before invoking exactly one of [onProceed] / [onCancel]. Fails open to
+   * [onProceed] on every error path.
+   */
+  fun trackEventGated(
+    name: String,
+    properties: Map<String, Any?>?,
+    onProceed: () -> Unit,
+    onCancel: () -> Unit,
+  )
+
+  /**
+   * Register the bridge's JS-backed campaign presenter with the KMP SDK so a
+   * dispatched blocking action is surfaced to JS via [campaignPresents].
+   */
+  fun registerCampaignPresenter()
+
+  /**
+   * Report the terminal result (one of `Completed` / `Dismissed` / `Unavailable`) for
+   * a previously dispatched campaign present. Idempotent — late/duplicate or unknown
+   * `mediationId`s are ignored.
+   */
+  fun resolveCampaign(mediationId: String, result: String)
+
   suspend fun getRecentEvents(limit: Int): List<EventEnvelope>
 
   suspend fun getDataSetSnapshot(type: DataSetType): Map<String, Any?>

package/android/src/main/java/tools/amply/sdk/reactnative/core/DefaultAmplyClient.kt

@@ -8,10 +8,13 @@ import tools.amply.sdk.reactnative.model.AmplyInitializationOptions
 import tools.amply.sdk.reactnative.model.DataSetType
 import tools.amply.sdk.reactnative.model.DeepLinkPayload
 import tools.amply.sdk.reactnative.model.EventEnvelope
+import tools.amply.sdk.reactnative.model.CampaignPresentPayload
 import tools.amply.sdk.reactnative.model.toNativeDataSetType
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
+import java.util.UUID
 import java.lang.ref.WeakReference
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -22,7 +25,10 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import tools.amply.sdk.Amply
+import tools.amply.sdk.actions.CampaignResolution
+import tools.amply.sdk.actions.CampaignResult
 import tools.amply.sdk.actions.DeepLinkListener
+import tools.amply.sdk.actions.CampaignPresenter
 import tools.amply.sdk.config.AmplyConfig
 import tools.amply.sdk.config.amplyConfig
 import tools.amply.sdk.core.AmplySDKInterface
@@ -41,7 +47,10 @@ class DefaultAmplyClient(
   private val pendingPropertyOps = mutableListOf<(Amply) -> Unit>()
   private val deepLinkRegistered = AtomicBoolean(false)
   private val systemEventsRegistered = AtomicBoolean(false)
+  private val campaignPresenterRegistered = AtomicBoolean(false)
   private val deepLinkSequence = AtomicLong(0L)
+  private val campaignPresentSequence = AtomicLong(0L)
+  private val pendingCompletions = ConcurrentHashMap<String, CampaignResolution>()
   private val lastResumedActivity = AtomicReference<WeakReference<Activity>?>(null)
   private val sessionPrimed = AtomicBoolean(false)
   private val mainHandler = Handler(Looper.getMainLooper())
@@ -63,6 +72,12 @@ class DefaultAmplyClient(
   )
   override val logEvents: SharedFlow<EventEnvelope> = _logEvents.asSharedFlow()
 
+  private val _campaignPresents = MutableSharedFlow<CampaignPresentPayload>(
+    replay = 0,
+    extraBufferCapacity = 16,
+  )
+  override val campaignPresents: SharedFlow<CampaignPresentPayload> = _campaignPresents.asSharedFlow()
+
   override suspend fun initialize(options: AmplyInitializationOptions) {
     var createdInstance = false
     mutex.withLock {
@@ -134,6 +149,96 @@ class DefaultAmplyClient(
     }
   }
 
+  override fun trackEventGated(
+    name: String,
+    properties: Map<String, Any?>?,
+    onProceed: () -> Unit,
+    onCancel: () -> Unit,
+  ) {
+    val instance = amplyInstance
+    if (instance == null) {
+      // Fail open: not initialized yet -> proceed immediately (mirrors KMP row 1).
+      android.util.Log.w(
+        "AmplyReactNative",
+        "trackEventGated('$name') before init; proceeding (fail-open)"
+      )
+      onProceed()
+      return
+    }
+    android.util.Log.i(
+      "AmplyReactNative",
+      "trackEventGated('$name') with properties=${properties?.filterValues { it != null }}"
+    )
+    // KMP continuation overload guarantees exactly-once, main-thread delivery of the
+    // callbacks. The bridge simply forwards them; the raw result never surfaces here.
+    instance.trackEvent(
+      name,
+      properties?.toNonNullMap() ?: emptyMap(),
+      onProceed,
+      onCancel,
+    )
+  }
+
+  override fun registerCampaignPresenter() {
+    val instance = requireInstance()
+    if (!campaignPresenterRegistered.compareAndSet(false, true)) {
+      return
+    }
+    android.util.Log.i("AmplyReactNative", "Registering campaign presenter")
+    // Catch-all registration: the JS layer is the single capability registry and
+    // routes by URL on its side. Per-URL-pattern KMP registration is reserved for
+    // native integrators.
+    instance.registerCampaignPresenter(object : CampaignPresenter {
+      override fun present(
+        url: String,
+        info: Map<String, Any>,
+        completion: CampaignResolution,
+      ) {
+        val mediationId = UUID.randomUUID().toString()
+        pendingCompletions[mediationId] = completion
+        android.util.Log.i(
+          "AmplyReactNative",
+          "Dispatching campaign present mediationId=$mediationId url=$url infoKeys=${info.keys}"
+        )
+        val payload = CampaignPresentPayload(
+          sequenceId = campaignPresentSequence.incrementAndGet(),
+          mediationId = mediationId,
+          url = url,
+          info = info.mapValues { it.value },
+        )
+        if (!_campaignPresents.tryEmit(payload)) {
+          // Backpressure / no collector: fail open by reporting Unavailable so the
+          // SDK's continuation still proceeds rather than hanging until timeout.
+          android.util.Log.w(
+            "AmplyReactNative",
+            "Dropping campaign present mediationId=$mediationId; reporting Unavailable (fail-open)"
+          )
+          pendingCompletions.remove(mediationId)
+          completion.resolve(CampaignResult.Unavailable)
+        }
+      }
+    })
+  }
+
+  override fun resolveCampaign(mediationId: String, result: String) {
+    val completion = pendingCompletions.remove(mediationId)
+    if (completion == null) {
+      // Late/duplicate/unknown reply — the SDK token is the source of truth and is
+      // already settled (or never existed). Ignore.
+      android.util.Log.i(
+        "AmplyReactNative",
+        "resolveCampaign for unknown/settled mediationId=$mediationId result=$result; ignored"
+      )
+      return
+    }
+    val mapped = result.toCampaignResult()
+    android.util.Log.i(
+      "AmplyReactNative",
+      "resolveCampaign mediationId=$mediationId result=$result -> $mapped"
+    )
+    completion.resolve(mapped)
+  }
+
   override suspend fun getRecentEvents(limit: Int): List<EventEnvelope> {
     val instance = requireInstance()
     return withContext(Dispatchers.IO) {
@@ -316,10 +421,22 @@ class DefaultAmplyClient(
     }
     deepLinkRegistered.set(false)
     systemEventsRegistered.set(false)
+    campaignPresenterRegistered.set(false)
     android.util.Log.i("AmplyReactNative", "Amply client shutdown; deep link listener cleared")
     deepLinkSequence.set(0L)
+    campaignPresentSequence.set(0L)
     sessionPrimed.set(false)
     lastResumedActivity.set(null)
+    // Fail open any in-flight mediated actions so no continuation is left hanging.
+    val inFlight = pendingCompletions.values.toList()
+    pendingCompletions.clear()
+    inFlight.forEach { completion ->
+      try {
+        completion.resolve(CampaignResult.Unavailable)
+      } catch (error: Throwable) {
+        android.util.Log.w("AmplyReactNative", "Error settling mediated action on shutdown: ${error.message}")
+      }
+    }
     _deepLinkEvents.resetReplayCache()
     _systemEvents.resetReplayCache()
   }
@@ -342,6 +459,23 @@ class DefaultAmplyClient(
   private fun Map<String, Any?>.toNonNullMap(): Map<String, Any> =
     entries.mapNotNull { (key, value) -> value?.let { key to it } }.toMap()
 
+  // Maps the JS-reported result string to the KMP enum. Strict semantics: anything
+  // that isn't a deliberate user 'Dismissed' or an explicit 'Completed' fails open to
+  // Unavailable (proceed) — never strand the continuation on a malformed value.
+  private fun String.toCampaignResult(): CampaignResult =
+    when (this) {
+      "Completed" -> CampaignResult.Completed
+      "Dismissed" -> CampaignResult.Dismissed
+      "Unavailable" -> CampaignResult.Unavailable
+      else -> {
+        android.util.Log.w(
+          "AmplyReactNative",
+          "Unknown campaign result '$this'; treating as Unavailable (fail-open)"
+        )
+        CampaignResult.Unavailable
+      }
+    }
+
   private fun Map<String, Any>.toNullableValues(): Map<String, Any?> =
     mapValues { it.value }
 

package/android/src/main/java/tools/amply/sdk/reactnative/model/CampaignPresentPayload.kt

@@ -0,0 +1,16 @@
+package tools.amply.sdk.reactnative.model
+
+/**
+ * A campaign present (blocking) action that has been dispatched to the JS layer and
+ * is awaiting a terminal result reported back via `resolveCampaign`.
+ *
+ * `mediationId` is the SDK-minted token correlating the dispatch with the JS reply;
+ * `info` carries the enriched, decoupled action info
+ * (`url`, `campaignId`, `campaignName`, `triggeringEvent`, `triggeringProperties`, `content`).
+ */
+data class CampaignPresentPayload(
+  val sequenceId: Long,
+  val mediationId: String,
+  val url: String,
+  val info: Map<String, Any?>,
+)

package/android/src/main/java/tools/amply/sdk/reactnative/model/DeepLinkPayload.kt

@@ -1,5 +1,20 @@
 package tools.amply.sdk.reactnative.model
 
+/**
+ * A deep link emitted by an Amply campaign.
+ *
+ * As of the campaign->app action contract, the KMP SDK enriches `info` with the
+ * decoupled action keys (in addition to any campaign-authored content):
+ * - `url`                   — routing URL
+ * - `campaignId`            — id of the matched campaign
+ * - `campaignName`          — name of the matched campaign
+ * - `triggeringEvent`       — the event name that triggered the action
+ * - `triggeringProperties`  — the properties of the triggering event (Map)
+ * - `content`               — opaque, campaign-authored content passthrough (Map)
+ *
+ * The keys are carried inside [info]; older campaigns that only supplied a URL still
+ * round-trip unchanged (the extra keys are simply absent).
+ */
 data class DeepLinkPayload(
   val sequenceId: Long,
   val url: String,

package/android/src/newarch/java/tools/amply/sdk/reactnative/NativeAmplyModuleSpec.java

@@ -42,6 +42,10 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
     mEventEmitterCallback.invoke("onDeepLink", value);
   }
 
+  protected final void emitOnCampaignPresent(ReadableMap value) {
+    mEventEmitterCallback.invoke("onCampaignPresent", value);
+  }
+
   @ReactMethod
   @DoNotStrip
   public abstract void initialize(ReadableMap config, Promise promise);
@@ -54,6 +58,18 @@ public abstract class NativeAmplyModuleSpec extends ReactContextBaseJavaModule i
   @DoNotStrip
   public abstract void track(ReadableMap payload, Promise promise);
 
+  @ReactMethod
+  @DoNotStrip
+  public abstract void trackEventGated(String event, ReadableMap properties, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void resolveCampaign(String mediationId, String result);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void registerCampaignPresenter();
+
   @ReactMethod
   @DoNotStrip
   public abstract void getRecentEvents(double limit, Promise promise);

package/android/src/newarch/jni/AmplyReactNative-generated.cpp

@@ -27,6 +27,21 @@ static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_track(facebo
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "track", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_trackEventGated(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "trackEventGated", "(Ljava/lang/String;Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "resolveCampaign", "(Ljava/lang/String;Ljava/lang/String;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerCampaignPresenter(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "registerCampaignPresenter", "()V", args, count, cachedMethodId);
+}
+
 static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
   static jmethodID cachedMethodId = nullptr;
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "getRecentEvents", "(DLcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
@@ -92,6 +107,9 @@ NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const JavaTurboModule::InitPa
   methodMap_["initialize"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_initialize};
   methodMap_["isInitialized"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_isInitialized};
   methodMap_["track"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_track};
+  methodMap_["trackEventGated"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_trackEventGated};
+  methodMap_["resolveCampaign"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign};
+  methodMap_["registerCampaignPresenter"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerCampaignPresenter};
   methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
   methodMap_["getDataSetSnapshot"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot};
   methodMap_["registerDeepLinkListener"] = MethodMetadata {0, __hostFunction_NativeAmplyModuleSpecJSI_registerDeepLinkListener};
@@ -106,6 +124,7 @@ NativeAmplyModuleSpecJSI::NativeAmplyModuleSpecJSI(const JavaTurboModule::InitPa
   methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_removeListeners};
   eventEmitterMap_["onSystemEvent"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   eventEmitterMap_["onDeepLink"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onCampaignPresent"] = std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   configureEventEmitterCallback();
 }
 

package/dist/src/__tests__/campaignResolved.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=campaignResolved.test.d.ts.map

package/dist/src/__tests__/campaignResolved.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"campaignResolved.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/campaignResolved.test.ts"],"names":[],"mappings":""}

package/dist/src/__tests__/campaignResolved.test.js

@@ -0,0 +1,137 @@
+import * as Amply from '../index';
+import { __setNativeModule } from '../nativeModule';
+// Drains the microtask queue a few times so promise-chained presenter resolutions
+// (sync or async) settle before assertions run.
+async function flushMicrotasks() {
+    for (let i = 0; i < 5; i++) {
+        await Promise.resolve();
+    }
+}
+const mockNativeModule = {
+    initialize: jest.fn(),
+    isInitialized: jest.fn(() => true),
+    track: jest.fn(),
+    trackEventGated: jest.fn(),
+    resolveCampaign: jest.fn(),
+    getRecentEvents: jest.fn(),
+    getDataSetSnapshot: jest.fn(),
+    registerDeepLinkListener: jest.fn(),
+    registerCampaignPresenter: jest.fn(),
+    addListener: jest.fn(),
+    removeListeners: jest.fn(),
+    onSystemEvent: jest.fn(),
+    onDeepLink: jest.fn(),
+    onCampaignPresent: jest.fn(),
+    setCustomProperties: jest.fn(),
+    getCustomProperty: jest.fn(),
+    removeCustomProperty: jest.fn(),
+    clearCustomProperties: jest.fn(),
+};
+describe('Amply CampaignResolved present/resolve/result API', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+        __setNativeModule(null);
+    });
+    beforeEach(() => {
+        __setNativeModule(mockNativeModule);
+    });
+    describe('trackEvent continuation overload', () => {
+        it('calls fire-and-forget track when no callbacks are supplied', async () => {
+            await Amply.trackEvent('SaveTapped', { foo: 'bar' });
+            expect(mockNativeModule.track).toHaveBeenCalledWith({
+                name: 'SaveTapped',
+                properties: { foo: 'bar' },
+            });
+            expect(mockNativeModule.trackEventGated).not.toHaveBeenCalled();
+        });
+        it('routes a "complete" resolution to onProceed', async () => {
+            mockNativeModule.trackEventGated.mockResolvedValueOnce('complete');
+            const onProceed = jest.fn();
+            const onCancel = jest.fn();
+            await Amply.trackEvent('SaveTapped', { foo: 'bar' }, { onProceed, onCancel });
+            expect(mockNativeModule.trackEventGated).toHaveBeenCalledWith('SaveTapped', {
+                foo: 'bar',
+            });
+            expect(onProceed).toHaveBeenCalledTimes(1);
+            expect(onCancel).not.toHaveBeenCalled();
+        });
+        it('routes a "cancel" resolution to onCancel', async () => {
+            mockNativeModule.trackEventGated.mockResolvedValueOnce('cancel');
+            const onProceed = jest.fn();
+            const onCancel = jest.fn();
+            await Amply.trackEvent('SaveTapped', undefined, { onProceed, onCancel });
+            expect(mockNativeModule.trackEventGated).toHaveBeenCalledWith('SaveTapped', {});
+            expect(onCancel).toHaveBeenCalledTimes(1);
+            expect(onProceed).not.toHaveBeenCalled();
+        });
+        it('fails open to onProceed when the native call rejects', async () => {
+            mockNativeModule.trackEventGated.mockRejectedValueOnce(new Error('boom'));
+            const onProceed = jest.fn();
+            const onCancel = jest.fn();
+            await Amply.trackEvent('SaveTapped', {}, { onProceed, onCancel });
+            expect(onProceed).toHaveBeenCalledTimes(1);
+            expect(onCancel).not.toHaveBeenCalled();
+        });
+        it('runs onProceed (not onCancel) for "cancel" when no onCancel is supplied', async () => {
+            mockNativeModule.trackEventGated.mockResolvedValueOnce('cancel');
+            const onProceed = jest.fn();
+            await Amply.trackEvent('SaveTapped', {}, { onProceed });
+            // The raw result is never exposed; a "cancel" with no onCancel hook is a no-op
+            // for the continuation. onProceed must not fire on a cancel.
+            expect(onProceed).not.toHaveBeenCalled();
+        });
+    });
+    describe('registerCampaignPresenter', () => {
+        it('registers once on the native module and subscribes to onCampaignPresent', async () => {
+            const remove = jest.fn();
+            mockNativeModule.onCampaignPresent.mockReturnValue({ remove });
+            const presenter = jest.fn(() => 'Completed');
+            const unsubscribe = await Amply.registerCampaignPresenter(presenter);
+            expect(mockNativeModule.registerCampaignPresenter).toHaveBeenCalledTimes(1);
+            expect(mockNativeModule.onCampaignPresent).toHaveBeenCalledTimes(1);
+            unsubscribe();
+            expect(remove).toHaveBeenCalledTimes(1);
+        });
+        it('forwards a synchronous result to resolveCampaign', async () => {
+            let emit;
+            mockNativeModule.onCampaignPresent.mockImplementation((listener) => {
+                emit = listener;
+                return { remove: jest.fn() };
+            });
+            const presenter = jest.fn(() => 'Dismissed');
+            await Amply.registerCampaignPresenter(presenter);
+            expect(emit).toBeDefined();
+            emit({ url: 'stillframe://ad', info: { campaignId: 'c1' }, mediationId: 'm1' });
+            // allow the (possibly async) presenter resolution to flush
+            await flushMicrotasks();
+            expect(presenter).toHaveBeenCalledWith('stillframe://ad', { campaignId: 'c1' });
+            expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m1', 'Dismissed');
+        });
+        it('forwards a promise-resolved result to resolveCampaign', async () => {
+            let emit;
+            mockNativeModule.onCampaignPresent.mockImplementation((listener) => {
+                emit = listener;
+                return { remove: jest.fn() };
+            });
+            const presenter = jest.fn(async () => 'Unavailable');
+            await Amply.registerCampaignPresenter(presenter);
+            emit({ url: 'stillframe://ad', info: {}, mediationId: 'm2' });
+            await flushMicrotasks();
+            expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m2', 'Unavailable');
+        });
+        it('reports Unavailable (fail-open) when the presenter throws', async () => {
+            let emit;
+            mockNativeModule.onCampaignPresent.mockImplementation((listener) => {
+                emit = listener;
+                return { remove: jest.fn() };
+            });
+            const presenter = jest.fn(() => {
+                throw new Error('presenter blew up');
+            });
+            await Amply.registerCampaignPresenter(presenter);
+            emit({ url: 'stillframe://ad', info: {}, mediationId: 'm3' });
+            await flushMicrotasks();
+            expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m3', 'Unavailable');
+        });
+    });
+});