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

package/src/__tests__/campaignResolved.test.ts

@@ -1,7 +1,12 @@
 import * as Amply from '../index';
 import {__setNativeModule} from '../nativeModule';
 
-type CampaignPresentEvent = {url: string; info: Record<string, unknown>; mediationId: string};
+type CampaignPresentEvent = {
+  url: string;
+  params: Record<string, unknown>;
+  info: Record<string, unknown>;
+  mediationId: string;
+};
 
 // Drains the microtask queue a few times so promise-chained presenter resolutions
 // (sync or async) settle before assertions run.
@@ -15,12 +20,12 @@ const mockNativeModule = {
   initialize: jest.fn(),
   isInitialized: jest.fn(() => true),
   track: jest.fn(),
-  trackEventGated: jest.fn(),
+  trackGated: jest.fn(),
   resolveCampaign: jest.fn(),
   getRecentEvents: jest.fn(),
   getDataSetSnapshot: jest.fn(),
   registerDeepLinkListener: jest.fn(),
-  registerCampaignPresenter: jest.fn(),
+  registerGate: jest.fn(),
   addListener: jest.fn(),
   removeListeners: jest.fn(),
   onSystemEvent: jest.fn(),
@@ -32,9 +37,10 @@ const mockNativeModule = {
   clearCustomProperties: jest.fn(),
 };
 
-describe('Amply CampaignResolved present/resolve/result API', () => {
+describe('Amply gate API (trackGated + registerGate)', () => {
   afterEach(() => {
     jest.clearAllMocks();
+    Amply.removeAllListeners();
     __setNativeModule(null);
   });
 
@@ -42,139 +48,229 @@ describe('Amply CampaignResolved present/resolve/result API', () => {
     __setNativeModule(mockNativeModule as never);
   });
 
-  describe('trackEvent continuation overload', () => {
-    it('calls fire-and-forget track when no callbacks are supplied', async () => {
+  describe('trackEvent (fire-and-forget)', () => {
+    it('forwards to native track and never gates', async () => {
       await Amply.trackEvent('SaveTapped', {foo: 'bar'});
 
       expect(mockNativeModule.track).toHaveBeenCalledWith({
         name: 'SaveTapped',
         properties: {foo: 'bar'},
       });
-      expect(mockNativeModule.trackEventGated).not.toHaveBeenCalled();
+      expect(mockNativeModule.trackGated).not.toHaveBeenCalled();
     });
 
-    it('routes a "complete" resolution to onProceed', async () => {
-      mockNativeModule.trackEventGated.mockResolvedValueOnce('complete');
+    it('defaults missing properties to an empty object', async () => {
+      await Amply.trackEvent('Ping');
+
+      expect(mockNativeModule.track).toHaveBeenCalledWith({
+        name: 'Ping',
+        properties: {},
+      });
+    });
+  });
 
-      const onProceed = jest.fn();
-      const onCancel = jest.fn();
+  describe('trackGated', () => {
+    it('resolves proceed/completed when the gate is satisfied', async () => {
+      mockNativeModule.trackGated.mockResolvedValueOnce({
+        outcome: 'proceed',
+        reason: 'completed',
+      });
 
-      await Amply.trackEvent('SaveTapped', {foo: 'bar'}, {onProceed, onCancel});
+      const decision = await Amply.trackGated('SaveTapped', {foo: 'bar'});
 
-      expect(mockNativeModule.trackEventGated).toHaveBeenCalledWith('SaveTapped', {
+      expect(mockNativeModule.trackGated).toHaveBeenCalledWith('SaveTapped', {
         foo: 'bar',
       });
-      expect(onProceed).toHaveBeenCalledTimes(1);
-      expect(onCancel).not.toHaveBeenCalled();
+      expect(decision).toEqual({outcome: 'proceed', reason: 'completed'});
     });
 
-    it('routes a "cancel" resolution to onCancel', async () => {
-      mockNativeModule.trackEventGated.mockResolvedValueOnce('cancel');
-
-      const onProceed = jest.fn();
-      const onCancel = jest.fn();
+    it('resolves proceed/failOpen when the native layer reports fail-open', async () => {
+      mockNativeModule.trackGated.mockResolvedValueOnce({
+        outcome: 'proceed',
+        reason: 'failOpen',
+      });
 
-      await Amply.trackEvent('SaveTapped', undefined, {onProceed, onCancel});
+      const decision = await Amply.trackGated('SaveTapped', {});
 
-      expect(mockNativeModule.trackEventGated).toHaveBeenCalledWith('SaveTapped', {});
-      expect(onCancel).toHaveBeenCalledTimes(1);
-      expect(onProceed).not.toHaveBeenCalled();
+      expect(decision).toEqual({outcome: 'proceed', reason: 'failOpen'});
     });
 
-    it('fails open to onProceed when the native call rejects', async () => {
-      mockNativeModule.trackEventGated.mockRejectedValueOnce(new Error('boom'));
+    it('resolves cancelled on a user dismiss under onAbort=cancel', async () => {
+      mockNativeModule.trackGated.mockResolvedValueOnce({outcome: 'cancelled'});
+
+      const decision = await Amply.trackGated('SaveTapped', undefined);
 
-      const onProceed = jest.fn();
-      const onCancel = jest.fn();
+      expect(mockNativeModule.trackGated).toHaveBeenCalledWith('SaveTapped', {});
+      expect(decision).toEqual({outcome: 'cancelled'});
+    });
+
+    it('never rejects — fails open to proceed/failOpen when native rejects', async () => {
+      mockNativeModule.trackGated.mockRejectedValueOnce(new Error('boom'));
 
-      await Amply.trackEvent('SaveTapped', {}, {onProceed, onCancel});
+      const decision = await Amply.trackGated('SaveTapped', {});
 
-      expect(onProceed).toHaveBeenCalledTimes(1);
-      expect(onCancel).not.toHaveBeenCalled();
+      expect(decision).toEqual({outcome: 'proceed', reason: 'failOpen'});
     });
 
-    it('runs onProceed (not onCancel) for "cancel" when no onCancel is supplied', async () => {
-      mockNativeModule.trackEventGated.mockResolvedValueOnce('cancel');
+    it('fails open on an unexpected/malformed native decision', async () => {
+      mockNativeModule.trackGated.mockResolvedValueOnce({outcome: 'wat'} as never);
+
+      const decision = await Amply.trackGated('SaveTapped', {});
+
+      expect(decision).toEqual({outcome: 'proceed', reason: 'failOpen'});
+    });
 
-      const onProceed = jest.fn();
+    it('normalizes an unknown proceed reason to failOpen', async () => {
+      mockNativeModule.trackGated.mockResolvedValueOnce({
+        outcome: 'proceed',
+        reason: 'something-else',
+      } as never);
 
-      await Amply.trackEvent('SaveTapped', {}, {onProceed});
+      const decision = await Amply.trackGated('SaveTapped', {});
 
-      // 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();
+      expect(decision).toEqual({outcome: 'proceed', reason: 'failOpen'});
     });
   });
 
-  describe('registerCampaignPresenter', () => {
-    it('registers once on the native module and subscribes to onCampaignPresent', async () => {
+  describe('registerGate', () => {
+    it('registers once on the native module per baseUrl and subscribes to onCampaignPresent', async () => {
       const remove = jest.fn();
       mockNativeModule.onCampaignPresent.mockReturnValue({remove});
 
-      const presenter = jest.fn(() => 'Completed' as const);
-      const unsubscribe = await Amply.registerCampaignPresenter(presenter);
+      const presenter = jest.fn();
+      const unsubscribe = await Amply.registerGate('stillframe://ad', presenter);
 
-      expect(mockNativeModule.registerCampaignPresenter).toHaveBeenCalledTimes(1);
+      expect(mockNativeModule.registerGate).toHaveBeenCalledTimes(1);
+      expect(mockNativeModule.registerGate).toHaveBeenCalledWith('stillframe://ad', 'cancel', 0);
       expect(mockNativeModule.onCampaignPresent).toHaveBeenCalledTimes(1);
 
+      // Second registration of the same baseUrl re-subscribes but does NOT re-register.
+      await Amply.registerGate('stillframe://ad', jest.fn());
+      expect(mockNativeModule.registerGate).toHaveBeenCalledTimes(1);
+
       unsubscribe();
       expect(remove).toHaveBeenCalledTimes(1);
     });
 
-    it('forwards a synchronous result to resolveCampaign', async () => {
-      let emit: ((e: CampaignPresentEvent) => void) | undefined;
-      mockNativeModule.onCampaignPresent.mockImplementation((listener: (e: CampaignPresentEvent) => void) => {
-        emit = listener;
-        return {remove: jest.fn()};
+    it('passes through onAbort and timeoutMs options', async () => {
+      mockNativeModule.onCampaignPresent.mockReturnValue({remove: jest.fn()});
+
+      await Amply.registerGate('stillframe://ad', jest.fn(), {
+        onAbort: 'proceed',
+        timeoutMs: 8000,
       });
 
-      const presenter = jest.fn(() => 'Dismissed' as const);
-      await Amply.registerCampaignPresenter(presenter);
+      expect(mockNativeModule.registerGate).toHaveBeenCalledWith('stillframe://ad', 'proceed', 8000);
+    });
+
+    it('delivers params + info to the presenter and forwards completed', async () => {
+      let emit: ((e: CampaignPresentEvent) => void) | undefined;
+      mockNativeModule.onCampaignPresent.mockImplementation(
+        (listener: (e: CampaignPresentEvent) => void) => {
+          emit = listener;
+          return {remove: jest.fn()};
+        },
+      );
+
+      const presenter = jest.fn(
+        (_params, _info, resolution: Amply.GateResolution) => resolution.completed(),
+      );
+      await Amply.registerGate('stillframe://ad', presenter);
 
       expect(emit).toBeDefined();
-      emit!({url: 'stillframe://ad', info: {campaignId: 'c1'}, mediationId: 'm1'});
+      emit!({
+        url: 'stillframe://ad?adUnit=rewarded_main',
+        params: {adUnit: 'rewarded_main'},
+        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');
+      expect(presenter).toHaveBeenCalledWith(
+        {adUnit: 'rewarded_main'},
+        {campaignId: 'c1'},
+        expect.any(Object),
+      );
+      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m1', 'Completed');
     });
 
-    it('forwards a promise-resolved result to resolveCampaign', async () => {
+    it('forwards a dismissed resolution', async () => {
       let emit: ((e: CampaignPresentEvent) => void) | undefined;
-      mockNativeModule.onCampaignPresent.mockImplementation((listener: (e: CampaignPresentEvent) => void) => {
-        emit = listener;
-        return {remove: jest.fn()};
-      });
+      mockNativeModule.onCampaignPresent.mockImplementation(
+        (listener: (e: CampaignPresentEvent) => void) => {
+          emit = listener;
+          return {remove: jest.fn()};
+        },
+      );
+
+      await Amply.registerGate('stillframe://ad', (_p, _i, resolution) =>
+        resolution.dismissed(),
+      );
+
+      emit!({url: 'stillframe://ad', params: {}, info: {}, mediationId: 'm2'});
+      await flushMicrotasks();
 
-      const presenter = jest.fn(async () => 'Unavailable' as const);
-      await Amply.registerCampaignPresenter(presenter);
+      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m2', 'Dismissed');
+    });
 
-      emit!({url: 'stillframe://ad', info: {}, mediationId: 'm2'});
+    it('reports Unavailable (fail-open) when the presenter throws', async () => {
+      let emit: ((e: CampaignPresentEvent) => void) | undefined;
+      mockNativeModule.onCampaignPresent.mockImplementation(
+        (listener: (e: CampaignPresentEvent) => void) => {
+          emit = listener;
+          return {remove: jest.fn()};
+        },
+      );
+
+      await Amply.registerGate('stillframe://ad', () => {
+        throw new Error('presenter blew up');
+      });
 
+      emit!({url: 'stillframe://ad', params: {}, info: {}, mediationId: 'm3'});
       await flushMicrotasks();
 
-      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m2', 'Unavailable');
+      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m3', 'Unavailable');
     });
 
-    it('reports Unavailable (fail-open) when the presenter throws', async () => {
+    it('resolves at most once even if the presenter reports twice', async () => {
       let emit: ((e: CampaignPresentEvent) => void) | undefined;
-      mockNativeModule.onCampaignPresent.mockImplementation((listener: (e: CampaignPresentEvent) => void) => {
-        emit = listener;
-        return {remove: jest.fn()};
+      mockNativeModule.onCampaignPresent.mockImplementation(
+        (listener: (e: CampaignPresentEvent) => void) => {
+          emit = listener;
+          return {remove: jest.fn()};
+        },
+      );
+
+      await Amply.registerGate('stillframe://ad', (_p, _i, resolution) => {
+        resolution.completed();
+        resolution.dismissed();
       });
 
-      const presenter = jest.fn(() => {
-        throw new Error('presenter blew up');
-      });
-      await Amply.registerCampaignPresenter(presenter);
+      emit!({url: 'stillframe://ad', params: {}, info: {}, mediationId: 'm4'});
+      await flushMicrotasks();
 
-      emit!({url: 'stillframe://ad', info: {}, mediationId: 'm3'});
+      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledTimes(1);
+      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m4', 'Completed');
+    });
 
+    it('ignores dispatches whose url does not match the registered baseUrl', async () => {
+      let emit: ((e: CampaignPresentEvent) => void) | undefined;
+      mockNativeModule.onCampaignPresent.mockImplementation(
+        (listener: (e: CampaignPresentEvent) => void) => {
+          emit = listener;
+          return {remove: jest.fn()};
+        },
+      );
+
+      const presenter = jest.fn();
+      await Amply.registerGate('stillframe://ad', presenter);
+
+      emit!({url: 'other://thing', params: {}, info: {}, mediationId: 'm5'});
       await flushMicrotasks();
 
-      expect(mockNativeModule.resolveCampaign).toHaveBeenCalledWith('m3', 'Unavailable');
+      expect(presenter).not.toHaveBeenCalled();
+      expect(mockNativeModule.resolveCampaign).not.toHaveBeenCalled();
     });
   });
 });

package/src/index.ts

@@ -5,6 +5,7 @@ export {formatSystemEventLabel} from './systemEventUtils';
 export type {FormatOptions} from './systemEventUtils';
 import type {
   CampaignResult,
+  GateDecision,
   AmplyInitializationConfig,
   DataSetSnapshot,
   DataSetType,
@@ -17,7 +18,7 @@ import type {
 
 let deepLinkRegistered = false;
 let debugLogListenerRegistered = false;
-let campaignPresenterRegistered = false;
+const registeredGates = new Set<string>();
 const deepLinkSubscriptions = new Set<() => void>();
 const campaignPresenterSubscriptions = new Set<() => void>();
 
@@ -137,96 +138,105 @@ export async function track(payload: TrackEventPayload): Promise<void> {
 }
 
 /**
- * Continuation hooks for the gating form of {@link trackEvent}.
- *
- * `onProceed` is "what to do next" (run exactly once when the gate resolves in
- * favor of proceeding). `onCancel` is an OPTIONAL local-UI cleanup hook, invoked
- * only when a campaign's blocking action is user-dismissed under an `onAbort=cancel`
- * policy. Never put business logic in `onCancel`.
- *
- * The raw campaign result is deliberately not exposed — app code must never branch
- * on which action ran or how it resolved.
+ * Possible results a gate presenter can report. Re-exported from the
+ * native spec for app presenters.
  */
-export type TrackEventContinuation = {
-  onProceed: () => void;
-  onCancel?: () => void;
-};
+export type {CampaignResult, GateDecision};
 
 /**
- * Possible results a campaign presenter can report. Re-exported from the
- * native spec for app presenters.
+ * Outcome of a gate presenter's presentation, reported back via {@link GateResolution}.
+ */
+export type GatePresenterResult = CampaignResult;
+
+/**
+ * Resolution token handed to a {@link GatePresenter}. The presenter MUST report
+ * exactly one terminal result. Convenience helpers map to the underlying
+ * {@link CampaignResult}.
  */
-export type {CampaignResult};
+export type GateResolution = {
+  /** The gate condition was satisfied (e.g. rewarded ad watched to completion). */
+  completed: () => void;
+  /** The user deliberately dismissed without satisfying the condition. */
+  dismissed: () => void;
+  /** Any non-user failure (no-fill, not-ready, failed-to-show). Fails open. */
+  unavailable: () => void;
+};
 
 /**
- * A capability presenter for a campaign present (blocking) action. Keyed by deeplink
- * URL semantics, NOT by event — the app is a registry of capabilities. Returns (or
- * resolves) the terminal {@link CampaignResult}. Throwing / rejecting is treated as
- * `'Unavailable'` (fail-open).
+ * A capability presenter for a gate (blocking) action, registered via
+ * {@link registerGate} and keyed by the gate's `baseUrl`. Receives the parsed query
+ * `params`, the enriched `info`, and a {@link GateResolution} token it must resolve
+ * exactly once. Throwing synchronously is treated as `unavailable` (fail-open).
  */
-export type CampaignPresenter = (
-  url: string,
+export type GatePresenter = (
+  params: Record<string, unknown>,
   info: Record<string, unknown>,
-) => CampaignResult | Promise<CampaignResult>;
+  resolution: GateResolution,
+) => void;
 
 /**
- * Fire-and-forget analytics track. Records the event and lets any matching NORMAL
- * campaign action dispatch as usual. A blocking action matched here will NOT fire —
- * there is no continuation to gate.
+ * Options for {@link registerGate}.
  */
-export function trackEvent(event: string, properties?: Record<string, unknown> | null): Promise<void>;
+export type RegisterGateOptions = {
+  /**
+   * Abort policy when the user dismisses the gate without satisfying it.
+   * - `'cancel'` → {@link trackGated} resolves `{ outcome: 'cancelled' }`.
+   * - `'proceed'` → {@link trackGated} resolves `{ outcome: 'proceed', reason: 'failOpen' }`.
+   * Defaults to `'cancel'`.
+   */
+  onAbort?: 'cancel' | 'proceed';
+  /**
+   * Max time (ms) the gate waits for a presenter result before failing open.
+   * Defaults to the SDK's gate default.
+   */
+  timeoutMs?: number;
+};
+
 /**
- * Continuation (gating) form. Records the event; if a blocking campaign action
- * matches AND a presenter is registered, the SDK dispatches it and awaits its result
- * before resolving the continuation:
- * - proceed (completed / unavailable / timeout / dismissed+proceed) → `onProceed`
- * - user dismiss against an `onAbort=cancel` action → `onCancel`
- *
- * Fails open: any error path runs `onProceed`. Passing a continuation is the gating
- * switch — the same event tracked elsewhere without one is a valid, non-gating call.
+ * Fire-and-forget analytics track. Records the event and lets any matching NORMAL
+ * campaign action dispatch as usual. A gate action matched here will NOT block —
+ * there is no caller to gate. Use {@link trackGated} to await a gate.
  */
-export function trackEvent(
-  event: string,
-  properties: Record<string, unknown> | null | undefined,
-  continuation: TrackEventContinuation,
-): Promise<void>;
 export async function trackEvent(
   event: string,
   properties?: Record<string, unknown> | null,
-  continuation?: TrackEventContinuation,
 ): Promise<void> {
-  const props = properties ?? {};
-
-  if (!continuation) {
-    await getNativeModule().track({name: event, properties: props});
-    return;
-  }
+  await getNativeModule().track({name: event, properties: properties ?? {}});
+}
 
-  let decision: string;
+/**
+ * Gated track. Records the event; if a gate action matches AND a presenter is
+ * registered for its `baseUrl`, the SDK dispatches the presentation and awaits its
+ * outcome before resolving:
+ * - `{ outcome: 'proceed', reason: 'completed' }` — the presenter satisfied the gate.
+ * - `{ outcome: 'proceed', reason: 'failOpen' }` — no gate matched, not initialized,
+ *   timeout, unavailable, infra failure, or dismiss under `onAbort=proceed`.
+ * - `{ outcome: 'cancelled' }` — user dismiss under an `onAbort=cancel` gate.
+ *
+ * This NEVER rejects: any infra failure resolves to `{ outcome: 'proceed', reason:
+ * 'failOpen' }` so the caller is never stranded.
+ */
+export async function trackGated(
+  event: string,
+  properties?: Record<string, unknown> | null,
+): Promise<GateDecision> {
+  const props = properties ?? {};
   try {
-    decision = await getNativeModule().trackEventGated(event, props);
+    const decision = (await getNativeModule().trackGated(event, props)) as Partial<GateDecision>;
+    if (decision && decision.outcome === 'cancelled') {
+      return {outcome: 'cancelled'};
+    }
+    if (decision && decision.outcome === 'proceed') {
+      const reason = decision.reason === 'completed' ? 'completed' : 'failOpen';
+      return {outcome: 'proceed', reason};
+    }
+    // Unexpected/malformed payload: fail open.
+    console.warn('[Amply] trackGated returned an unexpected decision; failing open', decision);
+    return {outcome: 'proceed', reason: 'failOpen'};
   } catch (error) {
-    // Fail open: any bridge/SDK failure must proceed, never strand the app.
-    console.warn('[Amply] trackEvent continuation failed; proceeding (fail-open)', error);
-    continuation.onProceed();
-    return;
-  }
-
-  if (decision === 'cancel') {
-    // A deliberate user-dismiss under an onAbort=cancel action. Only the local-UI
-    // cleanup hook runs; the continuation is suppressed.
-    continuation.onCancel?.();
-    return;
-  }
-
-  // 'complete' and any unexpected value fail open to onProceed.
-  continuation.onProceed();
-}
-
-async function ensureCampaignPresenterRegistration(): Promise<void> {
-  if (!campaignPresenterRegistered) {
-    getNativeModule().registerCampaignPresenter();
-    campaignPresenterRegistered = true;
+    // Fail open: any bridge/SDK failure must proceed, never strand the caller.
+    console.warn('[Amply] trackGated failed; proceeding (fail-open)', error);
+    return {outcome: 'proceed', reason: 'failOpen'};
   }
 }
 
@@ -245,33 +255,62 @@ function trackCampaignPresenterSubscription(subscription?: {remove?: () => void}
 }
 
 /**
- * Register a capability presenter for campaign present (blocking) actions. The presenter
- * is invoked when a blocking action is dispatched; it must report a terminal
- * {@link CampaignResult} (returned or resolved). The SDK collapses multi-step ad
- * lifecycles into the single result you report. Throwing/rejecting → `'Unavailable'`.
+ * Register a gate presenter for a gate (blocking) action, keyed by its `baseUrl`.
+ * The presenter is invoked when a matching gate is dispatched; it receives the parsed
+ * query `params`, the enriched `info`, and a {@link GateResolution} it must resolve
+ * exactly once (`completed`/`dismissed`/`unavailable`). The SDK collapses multi-step
+ * ad lifecycles into the single result you report. A synchronous throw → `unavailable`
+ * (fail-open).
  *
  * @returns an unsubscribe function.
  */
-export async function registerCampaignPresenter(
-  presenter: CampaignPresenter,
+export async function registerGate(
+  baseUrl: string,
+  presenter: GatePresenter,
+  opts?: RegisterGateOptions,
 ): Promise<() => void> {
-  await ensureCampaignPresenterRegistration();
+  const onAbort = opts?.onAbort ?? 'cancel';
+  const timeoutMs = opts?.timeoutMs ?? 0;
+
+  if (!registeredGates.has(baseUrl)) {
+    getNativeModule().registerGate(baseUrl, onAbort, timeoutMs);
+    registeredGates.add(baseUrl);
+  }
 
   const nativeModule = getNativeModule();
   const subscription = nativeModule.onCampaignPresent((event: CampaignPresentEvent) => {
-    const {url, info, mediationId} = event;
-    void Promise.resolve()
-      .then(() => presenter(url, info as Record<string, unknown>))
-      .then(
-        result => {
-          nativeModule.resolveCampaign(mediationId, result);
-        },
-        error => {
-          // Presenter failure is an infra failure, never a user dismiss → Unavailable.
-          console.warn('[Amply] campaign presenter failed; reporting Unavailable', error);
-          nativeModule.resolveCampaign(mediationId, 'Unavailable');
-        },
+    const {url, params, info, mediationId} = event;
+    // The native side routes by baseUrl, but guard here too in case multiple gates
+    // share the single onCampaignPresent channel.
+    if (baseUrl && url && !url.startsWith(baseUrl)) {
+      return;
+    }
+
+    let settled = false;
+    const report = (result: CampaignResult) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      nativeModule.resolveCampaign(mediationId, result);
+    };
+    const resolution: GateResolution = {
+      completed: () => report('Completed'),
+      dismissed: () => report('Dismissed'),
+      unavailable: () => report('Unavailable'),
+    };
+
+    try {
+      presenter(
+        (params ?? {}) as Record<string, unknown>,
+        info as Record<string, unknown>,
+        resolution,
       );
+    } catch (error) {
+      // Presenter failure is an infra failure, never a user dismiss → Unavailable.
+      console.warn('[Amply] gate presenter threw; reporting Unavailable (fail-open)', error);
+      report('Unavailable');
+    }
   });
 
   return trackCampaignPresenterSubscription(subscription);
@@ -361,10 +400,11 @@ export function removeAllListeners(): void {
     try {
       unsubscribe();
     } catch (error) {
-      console.warn('[Amply] Failed to remove campaign presenter', error);
+      console.warn('[Amply] Failed to remove gate presenter', error);
     }
   });
   campaignPresenterSubscriptions.clear();
+  registeredGates.clear();
 }
 
 export type {
@@ -393,7 +433,8 @@ export default {
   isInitialized,
   track,
   trackEvent,
-  registerCampaignPresenter,
+  trackGated,
+  registerGate,
   getRecentEvents,
   getDataSetSnapshot,
   addDeepLinkListener,