@chipmobilesdk/rn-ads 0.5.1 → 0.7.0

package/src/react/AdsBanner.tsx

@@ -16,13 +16,15 @@
  * a banner through the load/show handle model, which does not fit it.
  */
 
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
 import { View, type LayoutChangeEvent, type ViewStyle } from 'react-native';
 
 import type { PlacementState } from '../config/types';
-import { AdsError, normalizeProviderError } from '../diagnostics/errors';
+import { normalizeProviderError } from '../diagnostics/errors';
+import type { AdEvent } from '../diagnostics/events';
+import type { EngineFailureKind } from '../engine/port';
 import { useAds } from './AdsProvider';
-import type { ThrottledResult } from '../core/adsInstance';
+import { getInternals, type ThrottledResult } from '../core/adsInstance';
 import { useAdsStatus } from './hooks';
 
 export interface AdsBannerProps {
@@ -33,21 +35,14 @@ export interface AdsBannerProps {
 	readonly style?: ViewStyle;
 }
 
-interface ProviderBannerModule {
-	BannerAd: React.ComponentType<Record<string, unknown>>;
-	BannerAdSize: Record<string, string>;
-}
-
-function loadBannerModule(): ProviderBannerModule | null {
-	try {
-		return require('react-native-google-mobile-ads') as ProviderBannerModule;
-	} catch {
-		return null;
-	}
-}
-
 export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps) {
 	const ads = useAds();
+	// The instance's banner wiring (ADS-13). An instance the app wrote by hand has
+	// none, and is treated like a missing one.
+	const internals = useMemo(() => (ads ? getInternals(ads) : null), [ads]);
+	// The throttle token for this mount: stable across renders and minted by React
+	// rather than by a counter, so a render that runs twice charges one slot.
+	const mountToken = useId();
 	// The reported state lives in a ref rather than in component state: the host
 	// itself renders the same tree for every state, so storing it would only
 	// force re-renders the PERF-002 budget does not need to spend. The instance
@@ -58,6 +53,9 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 	// produces a genuinely re-adapted banner rather than a stretched old one.
 	const [cycle, setCycle] = useState(0);
 	const correlationRef = useRef<string | null>(null);
+	// Whether the current correlation already reported `loaded`. The provider
+	// auto-refreshes a banner inside one mount; each refresh is a new cycle.
+	const loadedInCycleRef = useRef(false);
 	const startedAtRef = useRef(0);
 	// Whether this mount has already taken a throttle slot, and the refusal if it
 	// was refused. Resets with the mount, which is exactly the granularity FR-140
@@ -66,23 +64,29 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 		decided: boolean;
 		refusal: ThrottledResult | null;
 	}>({ decided: false, refusal: null });
+	// Which attempt this mount is on. A refused mount asks again once the window
+	// passes (ADS-06), and each attempt needs its own token: the throttle replays
+	// the stored verdict for a token it has seen.
+	const throttleAttemptRef = useRef(0);
 
-	const provider = useMemo(loadBannerModule, []);
+	// The engine's banner component (ADS-12): the host never names the provider.
+	const banner = useMemo(() => internals?.banner() ?? null, [internals]);
 	// Initialization is asynchronous and a banner is almost always mounted before
 	// it finishes. Without this the resolution below would be computed once, while
 	// the instance was still `not_started`, be refused, and never be retried — the
 	// banner would sit at `unavailable` forever on a perfectly healthy app.
 	const status = useAdsStatus();
 
-	// Keyed on `cycle` so a genuine width change mints a fresh correlation id and
-	// starts a new, separately traceable load (FR-038, FR-052), and on `status` so
-	// the banner recovers the moment the instance becomes able to request.
+	// Keyed on `cycle` so a genuine width change starts a new, separately traceable
+	// load (FR-038, FR-052), and on `status` so the banner recovers the moment the
+	// instance becomes able to request. Pure: the cycle's correlation id is minted
+	// in the effect that starts it, not here (ADS-20).
 	const resolved = useMemo(
 		() =>
-			ads && status === 'ready'
-				? { cycle, value: ads.internals.resolveBanner(placementKey) }
+			internals && status === 'ready'
+				? { cycle, value: internals.resolveBanner(placementKey) }
 				: null,
-		[ads, placementKey, cycle, status],
+		[internals, placementKey, cycle, status],
 	);
 	const resolution = resolved?.value ?? null;
 
@@ -92,10 +96,10 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 				return;
 			}
 			stateRef.current = next;
-			ads?.internals.setPlacementState(placementKey, next);
+			internals?.setPlacementState(placementKey, next);
 			onStateChange?.(next);
 		},
-		[ads, onStateChange, placementKey],
+		[internals, onStateChange, placementKey],
 	);
 
 	// FR-140. Decided **during render**, not in the effect below, because the
@@ -108,20 +112,23 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 	// out), while a later cycle in the *same* mount is a width re-adaptation —
 	// rotation — which must not be refused or a rotated screen loses its banner
 	// for up to a minute.
-	if (ads && resolution?.ok && containerWidth > 0 && !throttleRef.current.decided) {
+	if (internals && resolution?.ok && containerWidth > 0 && !throttleRef.current.decided) {
 		throttleRef.current = {
 			decided: true,
-			refusal: ads.internals.commitBannerRequest(placementKey, resolution.correlationId),
+			refusal: internals.commitBannerRequest(
+				placementKey,
+				`${mountToken}:${throttleAttemptRef.current}`,
+			),
 		};
 	}
 	const throttleRefusal = throttleRef.current.refusal;
 
 	const usable = Boolean(
-		ads && provider && resolution?.ok && containerWidth > 0 && !throttleRefusal,
+		internals && banner && resolution?.ok && containerWidth > 0 && !throttleRefusal,
 	);
 
 	useEffect(() => {
-		if (!ads || !provider) {
+		if (!internals || !banner) {
 			move('unavailable');
 			return;
 		}
@@ -165,30 +172,39 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 		// collapse the space for both, but only one is worth investigating.
 		if (throttleRefusal) {
 			move('throttled');
-			ads.internals.emit({
+			internals.emit({
 				type: 'request_throttled',
-				timestamp: Date.now(),
+				timestamp: internals.now(),
 				placementKey,
 				format: 'banner',
 				retryAfterMs: throttleRefusal.retryAfterMs,
-				minRequestIntervalMs: ads.internals.throttleFloorFor(placementKey),
+				minRequestIntervalMs: internals.throttleFloorFor(placementKey),
+			});
+			// ADS-06: ask again in this same mount once the window has passed. Until
+			// 0.7.0 a refused banner stayed empty until it was remounted, so a banner
+			// pinned to a screen the user returned to within a minute never filled.
+			return internals.schedule(throttleRefusal.retryAfterMs, () => {
+				throttleRef.current = { decided: false, refusal: null };
+				throttleAttemptRef.current += 1;
+				setCycle(value => value + 1);
 			});
-			return;
 		}
-		correlationRef.current = resolution.correlationId;
-		startedAtRef.current = Date.now();
+		const correlationId = internals.nextCorrelationId();
+		correlationRef.current = correlationId;
+		loadedInCycleRef.current = false;
+		startedAtRef.current = internals.now();
 		move('loading');
-		ads.internals.emit({
+		internals.emit({
 			type: 'load_started',
-			timestamp: Date.now(),
+			timestamp: startedAtRef.current,
 			placementKey,
 			format: 'banner',
-			correlationId: resolution.correlationId,
+			correlationId,
 		});
 		// Deliberately keyed on `cycle`, not on every render: FR-041 forbids a
 		// re-render from producing a second uncontrolled request.
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [ads, provider, status, resolution, containerWidth, cycle]);
+	}, [internals, banner, status, resolution, containerWidth, cycle]);
 
 	const onLayout = useCallback((event: LayoutChangeEvent) => {
 		const width = Math.round(event.nativeEvent.layout.width);
@@ -206,48 +222,59 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 	}, []);
 
 	const emit = useCallback(
-		(event: Parameters<NonNullable<typeof ads>['internals']['emit']>[0]) => {
-			ads?.internals.emit(event);
+		(event: AdEvent) => {
+			internals?.emit(event);
 		},
-		[ads],
+		[internals],
 	);
+	const clock = useCallback(() => internals?.now() ?? Date.now(), [internals]);
 
 	const handleLoaded = useCallback(() => {
+		// A second load in one correlation is the provider's auto-refresh: a new
+		// ad, so a new cycle. Under the old correlation its `loaded` and
+		// `impression` were deduplicated away and revenue went uncounted (ADS-05).
+		// For a refresh, `durationMs` is the time since the previous load.
+		if (loadedInCycleRef.current && internals) {
+			correlationRef.current = internals.nextCorrelationId();
+		}
+		loadedInCycleRef.current = true;
+		const loadedAt = clock();
 		move('ready');
 		emit({
 			type: 'loaded',
-			timestamp: Date.now(),
+			timestamp: loadedAt,
 			placementKey,
 			format: 'banner',
 			correlationId: correlationRef.current ?? undefined,
-			durationMs: Date.now() - startedAtRef.current,
+			durationMs: loadedAt - startedAtRef.current,
 		});
-	}, [emit, move, placementKey]);
+		startedAtRef.current = loadedAt;
+	}, [internals, clock, emit, move, placementKey]);
 
 	const handleFailed = useCallback(
-		(error: unknown) => {
-			const normalized = normalizeProviderError(error, {
-				operation: 'load',
-				placementKey,
-				format: 'banner',
-			});
+		(error: unknown, kind?: EngineFailureKind) => {
+			const normalized = normalizeProviderError(
+				error,
+				{ operation: 'load', placementKey, format: 'banner' },
+				kind,
+			);
 			move('failed');
 			emit({
 				type: 'load_failed',
-				timestamp: Date.now(),
+				timestamp: clock(),
 				placementKey,
 				format: 'banner',
 				correlationId: correlationRef.current ?? undefined,
 				error: normalized,
 			});
 		},
-		[emit, move, placementKey],
+		[clock, emit, move, placementKey],
 	);
 
 	const handleImpression = useCallback(() => {
 		emit({
 			type: 'impression',
-			timestamp: Date.now(),
+			timestamp: clock(),
 			placementKey,
 			format: 'banner',
 			correlationId: correlationRef.current ?? undefined,
@@ -256,17 +283,17 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 			// reconciliation, so it is recorded rather than flattened (R5).
 			source: 'provider',
 		});
-	}, [emit, placementKey]);
+	}, [clock, emit, placementKey]);
 
 	const handleClicked = useCallback(() => {
 		emit({
 			type: 'click',
-			timestamp: Date.now(),
+			timestamp: clock(),
 			placementKey,
 			format: 'banner',
 			correlationId: correlationRef.current ?? undefined,
 		});
-	}, [emit, placementKey]);
+	}, [clock, emit, placementKey]);
 
 	// FR-041: nothing survives unmount. No retained native view, no dangling
 	// correlation, no state written into a disposed instance.
@@ -276,7 +303,7 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 		};
 	}, []);
 
-	if (!ads || !provider) {
+	if (!internals || !banner) {
 		// FR-042, UX-003 — out of the tree entirely, blocking no touch.
 		return null;
 	}
@@ -304,34 +331,22 @@ export function AdsBanner({ placementKey, onStateChange, style }: AdsBannerProps
 		}
 	}
 
-	const { BannerAd, BannerAdSize } = provider;
+	const BannerComponent = banner.Component;
 	const adUnitId = resolution?.ok ? resolution.adUnitId : null;
-	// The provider's polarity is the inverse of the consumer-facing option.
-	const requestNonPersonalizedAdsOnly = resolution?.ok ? !resolution.personalizedAds : false;
 
 	return (
 		<View style={style} onLayout={onLayout} testID={`ads-banner-${placementKey}`}>
-			{usable && adUnitId ? (
-				<BannerAd
+			{usable && adUnitId && resolution?.ok ? (
+				<BannerComponent
 					key={`${placementKey}-${cycle}`}
-					unitId={adUnitId}
-					size={BannerAdSize.ANCHORED_ADAPTIVE_BANNER}
-					requestOptions={{ requestNonPersonalizedAdsOnly }}
-					onAdLoaded={handleLoaded}
-					onAdFailedToLoad={handleFailed}
-					onAdImpression={handleImpression}
-					onAdClicked={handleClicked}
+					adUnitId={adUnitId}
+					personalizedAds={resolution.personalizedAds}
+					onLoaded={handleLoaded}
+					onFailed={handleFailed}
+					onImpression={handleImpression}
+					onClicked={handleClicked}
 				/>
 			) : null}
 		</View>
 	);
 }
-
-/** Exposed for tests that assert the failure taxonomy without a renderer. */
-export function bannerUnavailableError(placementKey: string): AdsError {
-	return new AdsError('unsupported_platform', {
-		operation: 'load',
-		placementKey,
-		format: 'banner',
-	});
-}

package/src/react/AdsProvider.tsx

@@ -10,8 +10,8 @@
  * startup where the app can decide what to do about it.
  */
 
+import { appLifecycle } from '@chipmobilesdk/rn-core';
 import React, { createContext, useContext, useEffect, type ReactNode } from 'react';
-import { AppState, type AppStateStatus } from 'react-native';
 
 import type { AdsInstance } from '../core/adsInstance';
 
@@ -23,7 +23,9 @@ export interface AdsProviderProps {
 	 * Whether the provider forwards foreground/background transitions to the
 	 * instance. On by default: FR-034's "never show while inactive" and
 	 * "re-evaluate a stale ad on return" both depend on the instance being told.
-	 * Turn it off only when the app already drives `setAppActive` itself.
+	 * Turn it off only when the app already drives `setAppActive` itself. The
+	 * transitions come from rn-core's shared `appLifecycle()`; `inactive` counts as
+	 * not active.
 	 */
 	readonly trackAppState?: boolean;
 	readonly children: ReactNode;
@@ -34,12 +36,9 @@ export function AdsProvider({ instance, trackAppState = true, children }: AdsPro
 		if (!trackAppState) {
 			return;
 		}
-		const subscription = AppState.addEventListener('change', (status: AppStateStatus) => {
-			instance.setAppActive(status === 'active');
+		return appLifecycle().subscribe(state => {
+			instance.setAppActive(state === 'active');
 		});
-		return () => {
-			subscription.remove();
-		};
 	}, [instance, trackAppState]);
 
 	return <AdsContext.Provider value={instance}>{children}</AdsContext.Provider>;

package/src/react/hooks.ts

@@ -10,7 +10,8 @@
  * state; it never holds provider-owned memory (FR-027).
  */
 
-import { useEffect, useState } from 'react';
+import { useExternalStore, useLatestCallback } from '@chipmobilesdk/rn-core/react';
+import { useCallback, useEffect } from 'react';
 
 import type { InitStatus, PlacementState } from '../config/types';
 import type { AdEventListener } from '../diagnostics/events';
@@ -19,42 +20,33 @@ import { useAds } from './AdsProvider';
 /** Live state for one placement. `unavailable` outside a provider. */
 export function usePlacementState(placementKey: string): PlacementState {
 	const ads = useAds();
-	const [state, setState] = useState<PlacementState>(() =>
-		ads ? ads.getPlacementState(placementKey) : 'unavailable',
+	const subscribe = useCallback(
+		(listener: () => void) =>
+			ads ? ads.subscribePlacement(placementKey, listener) : NO_SUBSCRIPTION,
+		[ads, placementKey],
 	);
-
-	useEffect(() => {
-		if (!ads) {
-			setState('unavailable');
-			return;
-		}
-		// Re-read on subscribe: the state may have moved between the initial
-		// render and this effect, and dropping that transition would leave the
-		// UI showing a state the instance has already left.
-		setState(ads.getPlacementState(placementKey));
-		return ads.subscribePlacement(placementKey, setState);
-	}, [ads, placementKey]);
-
-	return state;
+	const getSnapshot = useCallback(
+		(): PlacementState => (ads ? ads.getPlacementState(placementKey) : 'unavailable'),
+		[ads, placementKey],
+	);
+	// useSyncExternalStore: tear-free, and no transition lost between render and
+	// subscription, which the useState copy had to re-read to avoid.
+	return useExternalStore(subscribe, getSnapshot);
 }
 
 /** Live initialization status. `unavailable` outside a provider. */
 export function useAdsStatus(): InitStatus {
 	const ads = useAds();
-	const [status, setStatus] = useState<InitStatus>(() => (ads ? ads.getStatus() : 'unavailable'));
-
-	useEffect(() => {
-		if (!ads) {
-			setStatus('unavailable');
-			return;
-		}
-		setStatus(ads.getStatus());
-		return ads.subscribeStatus(setStatus);
-	}, [ads]);
-
-	return status;
+	const subscribe = useCallback(
+		(listener: () => void) => (ads ? ads.subscribeStatus(listener) : NO_SUBSCRIPTION),
+		[ads],
+	);
+	const getSnapshot = useCallback((): InitStatus => (ads ? ads.getStatus() : 'unavailable'), [ads]);
+	return useExternalStore(subscribe, getSnapshot);
 }
 
+const NO_SUBSCRIPTION = (): void => undefined;
+
 /**
  * Forwards every event to a listener without causing a render.
  *
@@ -65,11 +57,14 @@ export function useAdsStatus(): InitStatus {
  */
 export function useAdsEvents(listener: AdEventListener): void {
 	const ads = useAds();
+	// An inline listener is a new function every render; subscribing through the
+	// latest one keeps a single subscription per instance (PERF-13).
+	const latest = useLatestCallback(listener);
 
 	useEffect(() => {
 		if (!ads) {
 			return;
 		}
-		return ads.subscribeEvents(listener);
-	}, [ads, listener]);
+		return ads.subscribeEvents(latest);
+	}, [ads, latest]);
 }

package/src/testing/clock.ts

@@ -0,0 +1,75 @@
+/**
+ * A clock the test drives (ADS-11).
+ *
+ * Every bounded wait in this package — retry backoff, the request throttle, a
+ * consent form that never answers — is measured against a clock. Injecting this
+ * one is what lets a suite assert the behaviour at the boundary instead of
+ * sleeping and hoping.
+ */
+import type { Scheduler } from '../core/timers';
+
+/**
+ * A clock a test can move by hand.
+ *
+ * Retry backoff, app-open expiry, the undecided-state warning, and the
+ * ad-originated-return windows are all time-dependent, and all four must be
+ * assertable exactly rather than approximately. Advancing a clock makes "two
+ * retries, 2s then 4s" a precise assertion; sleeping would make it a flaky one.
+ *
+ * Callbacks fire in due order, and a callback scheduled *during* an advance is
+ * honored within the same advance if its deadline has also passed — matching how
+ * real timers behave when work chains.
+ */
+export interface TestClock {
+	now(): number;
+	advance(ms: number): void;
+	readonly scheduler: Scheduler;
+	pending(): number;
+}
+
+export function createTestClock(startMs = 1_000_000): TestClock {
+	let current = startMs;
+	let sequence = 0;
+	const timers = new Map<number, { at: number; callback: () => void }>();
+
+	const scheduler: Scheduler = {
+		setTimeout(callback, ms) {
+			sequence += 1;
+			timers.set(sequence, { at: current + ms, callback });
+			return sequence;
+		},
+		clearTimeout(handle) {
+			timers.delete(handle as number);
+		},
+	};
+
+	return {
+		now: () => current,
+		advance(ms) {
+			const target = current + ms;
+			// Loop rather than iterate once: a fired callback may schedule another
+			// timer that is also due before `target`, which is exactly what a retry
+			// chain does.
+			for (;;) {
+				let nextId: number | null = null;
+				let nextAt = Number.POSITIVE_INFINITY;
+				for (const [id, timer] of timers) {
+					if (timer.at <= target && timer.at < nextAt) {
+						nextAt = timer.at;
+						nextId = id;
+					}
+				}
+				if (nextId === null) {
+					break;
+				}
+				const timer = timers.get(nextId)!;
+				timers.delete(nextId);
+				current = timer.at;
+				timer.callback();
+			}
+			current = target;
+		},
+		scheduler,
+		pending: () => timers.size,
+	};
+}

package/src/testing/conformance.ts

@@ -0,0 +1,112 @@
+/**
+ * What any `AdsEngine` must do (IOS-12, ADS-13).
+ *
+ * The same checks run against the fake engine and against the AdMob adapter over
+ * the provider mock (or the real provider, from a demo screen on a device), so a
+ * test that drives the fake proves something about the device path. The subject
+ * says how the provider delivers its callbacks; the checks only use the port.
+ */
+import {
+	ensure,
+	runChecks,
+	type Check,
+	type ConformanceReport,
+} from '@chipmobilesdk/rn-core/testing';
+
+import type { Reward } from '../config/types';
+import type { AdsEngine, EngineAdEvent, EngineAdHandle } from '../engine/port';
+
+export interface AdsEngineSubject {
+	readonly engine: AdsEngine;
+	/** The provider finishes loading the ad behind `handle`. */
+	deliverLoad(handle: EngineAdHandle): void;
+	/** The provider grants a reward for the ad behind `handle`. */
+	deliverReward(handle: EngineAdHandle, reward: Reward): void;
+	/** The user closes the ad behind `handle`. */
+	deliverDismiss(handle: EngineAdHandle): void;
+}
+
+export interface AdsEngineHarness {
+	create(): AdsEngineSubject;
+}
+
+/** Lets callbacks a provider delivers on a later microtask arrive. */
+async function settle(): Promise<void> {
+	for (let turn = 0; turn < 3; turn += 1) {
+		await Promise.resolve();
+	}
+}
+
+export const adsEngineChecks: readonly Check<AdsEngineHarness>[] = [
+	{
+		name: 'is available, and initializes with privacy applied',
+		async run(harness) {
+			const { engine } = harness.create();
+			ensure(engine.isAvailable(), 'reported unavailable');
+			await engine.initialize({ childDirected: true, maxAdContentRating: 'G' });
+		},
+	},
+	{
+		name: 'delivers loaded to a subscriber of an interstitial, and nothing after unsubscribing',
+		async run(harness) {
+			const subject = harness.create();
+			const handle = await subject.engine.createFullScreen('interstitial', 'conformance/1');
+			ensure(typeof handle.id === 'string' && handle.id !== '', 'handle has no id');
+			const seen: EngineAdEvent['type'][] = [];
+			const stop = subject.engine.subscribe(handle, event => seen.push(event.type));
+			subject.deliverLoad(handle);
+			await settle();
+			ensure(seen.join(',') === 'loaded', `subscriber saw ${seen.join(',') || 'nothing'}`);
+			stop();
+			stop();
+			subject.deliverDismiss(handle);
+			await settle();
+			ensure(seen.length === 1, `notified after unsubscribing: ${seen.join(',')}`);
+		},
+	},
+	{
+		name: 'delivers the reward and the dismissal of a rewarded ad',
+		async run(harness) {
+			const subject = harness.create();
+			const handle = await subject.engine.createFullScreen('rewarded', 'conformance/2', {
+				personalizedAds: false,
+			});
+			const seen: EngineAdEvent[] = [];
+			subject.engine.subscribe(handle, event => seen.push(event));
+			subject.deliverLoad(handle);
+			await settle();
+			subject.deliverReward(handle, { type: 'coins', amount: 5 });
+			subject.deliverDismiss(handle);
+			await settle();
+			const reward = seen.find(event => event.type === 'rewarded');
+			ensure(reward?.type === 'rewarded', `no reward among ${seen.map(e => e.type).join(',')}`);
+			ensure(
+				reward.reward.type === 'coins' && reward.reward.amount === 5,
+				`reward ${JSON.stringify(reward.reward)}`,
+			);
+			ensure(seen.at(-1)?.type === 'dismissed', `last event ${seen.at(-1)?.type}`);
+		},
+	},
+	{
+		name: 'gives every ad its own handle',
+		async run(harness) {
+			const { engine } = harness.create();
+			const first = await engine.createFullScreen('interstitial', 'conformance/1');
+			const second = await engine.createFullScreen('interstitial', 'conformance/1');
+			ensure(first.id !== second.id, 'two ads share a handle');
+		},
+	},
+	{
+		name: 'disposes safely twice',
+		async run(harness) {
+			const { engine } = harness.create();
+			const handle = await engine.createFullScreen('interstitial', 'conformance/1');
+			engine.dispose(handle);
+			engine.dispose(handle);
+		},
+	},
+];
+
+export function runAdsEngineConformance(harness: AdsEngineHarness): Promise<ConformanceReport> {
+	return runChecks(() => harness, adsEngineChecks);
+}