@mpgd/adapter-ait 0.8.0 → 0.10.0

package/dist/host.js

@@ -1,14 +1,34 @@
-import { getTossShareLink, getUserKeyForGame, grantPromotionRewardForGame as grantPromotionReward, isMinVersionSupported, loadFullScreenAd, openGameCenterLeaderboard, requestNotificationAgreement, share, showFullScreenAd, Storage, submitGameCenterLeaderBoardScore, } from '@apps-in-toss/web-framework';
+import { getTossShareLink, getUserKeyForGame, grantPromotionRewardForGame as grantPromotionReward, IAP, isMinVersionSupported, loadFullScreenAd, openGameCenterLeaderboard, requestNotificationAgreement, share, showFullScreenAd, Storage, submitGameCenterLeaderBoardScore, TossAds, } from '@apps-in-toss/web-framework';
 import { assertBridgeRequest, bridgeStorageLoadProtocol, } from '@mpgd/bridge';
 import { dispatchAitLifecycleEvent } from './lifecycle.js';
 const defaultAdTimeoutMs = 60000;
 const defaultAdLoadQueueTimeoutMs = 5000;
 const defaultAdDisplayStartTimeoutMs = 60000;
 const defaultAdMaximumDisplayMs = 30 * 60000;
+const defaultBannerRenderTimeoutMs = 15000;
+/** Leaves five seconds of headroom inside the native IAP 30-second grant callback. */
+const defaultIapProductGrantTimeoutMs = 25000;
+/** Bounds abandoned checkout UI while still allowing the user to finish an interactive purchase. */
+const defaultIapPurchaseSessionTimeoutMs = 30 * 60000;
+/** A provider response is untrusted input; keep restore work bounded per launch. */
+const maximumPendingIapOrders = 20;
 const invalidBridgeRequestId = 'ait-invalid-request';
 const rewardedAdEvidenceSchema = 'apps-in-toss.rewarded-ad.callback.v1';
+const iapEvidenceSchema = 'apps-in-toss.iap.callback.v1';
 const minimumPromotionTossAppVersion = '5.232.0';
 const promotionGrantStoragePrefix = 'mpgd:ait:promotion-grant:v1:';
+/**
+ * A client idempotency key must survive a bridge reload. The authoritative
+ * backend still owns entitlements; this marker only prevents a second native
+ * checkout while the first checkout is known to be terminal or ambiguous.
+ */
+const iapPurchaseAttemptStoragePrefix = 'mpgd:ait:iap-purchase-attempt:v1:';
+const iapCompletedPurchaseAttemptIndexStorageKey = 'mpgd:ait:iap-completed-purchase-index:v1';
+const maximumIndexedCompletedIapPurchaseAttempts = 64;
+/** A crashed pre-checkout attempt can be retried only after provider recovery finds no order. */
+const pendingIapPurchaseAttemptRecoveryAgeMs = defaultIapPurchaseSessionTimeoutMs;
+/** Rotates bounded pending-order recovery so an early rejected order cannot starve later work. */
+const iapPendingOrderCursorStorageKey = 'mpgd:ait:pending-order-cursor:v1';
 const defaultNotificationAgreementTimeoutMs = 120000;
 const notificationTopics = new Set([
     'daily-ready',
@@ -34,8 +54,10 @@ const defaultDependencies = {
     isMinVersionSupported,
     loadFullScreenAd,
     showFullScreenAd,
+    tossAds: TossAds,
     openGameCenterLeaderboard,
     submitGameCenterLeaderBoardScore,
+    iap: IAP,
 };
 export function installAitHostBridge(options = {}) {
     const bridge = createAitHostBridge(options);
@@ -51,20 +73,43 @@ export function createAitHostBridge(options = {}) {
     const authorizePromotionGrant = options.authorizePromotionGrant;
     const resolvePendingPromotionGrant = options.resolvePendingPromotionGrant;
     const notificationTemplateCodes = normalizeNotificationTemplateCodes(options.notificationTemplateCodes);
+    const iapProducts = normalizeIapProducts(options.iapProducts);
+    const iapProductGrantTimeoutMs = normalizeIapProductGrantTimeout(options.iapProductGrantTimeoutMs);
     const promotionGrantsInFlight = new Map();
+    const iapPurchasesInFlight = new Map();
+    let completedIapAttemptRetention = Promise.resolve();
     const notificationSubscriptions = new Set();
     const loadedAdGroupIds = new Set();
     const loadingAdGroups = new Map();
     const activeAdGroupIds = new Set();
+    const activeBannerAttachments = new Map();
+    const bannerMountOwners = new Map();
+    const pendingBannerMountSettlements = new Map();
+    let bannerInitialization;
     let warnedUnsupportedAdPreload = false;
     const adTimeoutMs = normalizeTimeout(options.adTimeoutMs);
     const adLoadQueueTimeoutMs = normalizeLoadQueueTimeout(options.adLoadQueueTimeoutMs);
     const adDisplayStartTimeoutMs = normalizeDisplayStartTimeout(options.adDisplayStartTimeoutMs);
     const adMaximumDisplayMs = normalizeMaximumDisplayTimeout(options.adMaximumDisplayMs);
+    const bannerRenderTimeoutMs = normalizeBannerRenderTimeout(options.bannerRenderTimeoutMs);
+    const bannerAppearance = {
+        theme: options.bannerAppearance?.theme ?? 'dark',
+        tone: options.bannerAppearance?.tone ?? 'blackAndWhite',
+        variant: options.bannerAppearance?.variant ?? 'expanded',
+    };
     const adLoadCoordinator = {
         active: undefined,
         waitTimeoutMs: adLoadQueueTimeoutMs,
     };
+    const enqueueCompletedIapAttemptRetention = (storage, storageKey) => {
+        const scheduled = completedIapAttemptRetention.then(async () => {
+            await retainCompletedAitIapPurchaseAttempt(storage, storageKey, iapProductGrantTimeoutMs);
+        });
+        const next = scheduled.then(() => undefined, () => undefined);
+        void next;
+        void (completedIapAttemptRetention = next);
+        return next;
+    };
     return {
         async request(input) {
             try {
@@ -83,12 +128,24 @@ export function createAitHostBridge(options = {}) {
                     && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'rewarded');
                 const interstitialAds = adsSupported
                     && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'interstitial');
+                const bannerAds = areBannerAdsSupported(dependencies)
+                    && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'banner');
+                const nativeIap = isAitIapSupported({
+                    dependencies,
+                    products: iapProducts,
+                    prepare: options.prepareIap,
+                    verifier: options.verifyIapProductGrant,
+                    entitlementReader: options.readIapEntitlements,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                });
                 return ok(request, {
-                    nativeIap: false,
-                    nativeAds: rewardedAds || interstitialAds,
+                    nativeIap,
+                    nativeAds: rewardedAds || interstitialAds || bannerAds,
+                    bannerAds,
                     rewardedAds,
                     interstitialAds,
                     nativeLeaderboard: isGameCenterSupported(dependencies),
+                    remoteLeaderboard: false,
                     achievements: false,
                     cloudSave: false,
                     socialShare: true,
@@ -132,7 +189,7 @@ export function createAitHostBridge(options = {}) {
                 const topic = readNotificationTopic(request.payload);
                 const templateCode = notificationTemplateCodes.get(topic);
                 if (templateCode === undefined
-                    || !isCapabilitySupported(() => dependencies.requestNotificationAgreement.isSupported())) {
+                    || !isAitNativeMethodSupported(dependencies.requestNotificationAgreement)) {
                     return ok(request, 'unavailable');
                 }
                 const result = await requestAitNotificationAgreement(dependencies.requestNotificationAgreement, templateCode);
@@ -188,15 +245,84 @@ export function createAitHostBridge(options = {}) {
                     }
                 }
             }
-            // IAP must be installed with game-owned server verification. Never return demo grants.
+            // IAP is opt-in and server-authoritative. Never return demo grants.
             case 'commerce.getProducts':
-                return ok(request, []);
-            case 'commerce.purchase':
-                return ok(request, { status: 'failed', entitlementIds: [] });
+                return ok(request, await listAitIapProducts({
+                    dependencies,
+                    products: iapProducts,
+                    prepare: options.prepareIap,
+                    verifier: options.verifyIapProductGrant,
+                    entitlementReader: options.readIapEntitlements,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                }));
+            case 'commerce.purchase': {
+                const purchase = readCommercePurchase(request.payload);
+                const product = iapProducts.byProductId.get(purchase.productId);
+                const prepareIap = options.prepareIap;
+                const verifyIapProductGrant = options.verifyIapProductGrant;
+                const iapSupported = isAitIapSupported({
+                    dependencies,
+                    products: iapProducts,
+                    prepare: prepareIap,
+                    verifier: verifyIapProductGrant,
+                    entitlementReader: options.readIapEntitlements,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                });
+                if (product === undefined
+                    || !iapSupported
+                    || prepareIap === undefined
+                    || verifyIapProductGrant === undefined) {
+                    return ok(request, failedPurchase());
+                }
+                const persisted = await resolvePersistedAitIapPurchaseAttempt({
+                    dependencies,
+                    storage: dependencies.storage,
+                    product,
+                    idempotencyKey: purchase.idempotencyKey,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                });
+                if (persisted !== undefined) {
+                    return ok(request, persisted);
+                }
+                const isOneTimeProduct = await isAitOneTimeIapProduct(dependencies, product, iapProductGrantTimeoutMs);
+                if (!isOneTimeProduct) {
+                    return ok(request, failedPurchase());
+                }
+                const purchaseRequestKey = createAitIapPurchaseRequestKey(purchase.productId, purchase.idempotencyKey);
+                const existing = iapPurchasesInFlight.get(purchaseRequestKey);
+                if (existing !== undefined) {
+                    return ok(request, await existing);
+                }
+                const pending = purchaseAitIapProduct({
+                    dependencies,
+                    product,
+                    idempotencyKey: purchase.idempotencyKey,
+                    prepare: prepareIap,
+                    verifier: verifyIapProductGrant,
+                    retainCompletedAttempt: enqueueCompletedIapAttemptRetention,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                });
+                iapPurchasesInFlight.set(purchaseRequestKey, pending);
+                try {
+                    return ok(request, await pending);
+                }
+                finally {
+                    if (iapPurchasesInFlight.get(purchaseRequestKey) === pending) {
+                        iapPurchasesInFlight.delete(purchaseRequestKey);
+                    }
+                }
+            }
             case 'commerce.restore':
-                return ok(request, { restoredEntitlements: [] });
+                return ok(request, await restoreAitIapProducts({
+                    dependencies,
+                    products: iapProducts,
+                    prepare: options.prepareIap,
+                    verifier: options.verifyIapProductGrant,
+                    entitlementReader: options.readIapEntitlements,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                }));
             case 'commerce.getEntitlements':
-                return ok(request, []);
+                return ok(request, await readAitIapEntitlements(options.readIapEntitlements, iapProductGrantTimeoutMs));
             case 'ads.preload': {
                 const placementId = readPlacementId(request.payload);
                 const adGroupId = adGroupIds.get(placementId);
@@ -204,7 +330,10 @@ export function createAitHostBridge(options = {}) {
                 if (adGroupId === undefined || placementType === undefined) {
                     return createBridgeError(request.id, 'AIT_AD_UNAVAILABLE', `AIT ad placement is unavailable: ${placementId}`);
                 }
-                if (!isCapabilitySupported(() => dependencies.loadFullScreenAd.isSupported())) {
+                if (placementType === 'banner') {
+                    return ok(request, {});
+                }
+                if (!isAitNativeMethodSupported(dependencies.loadFullScreenAd)) {
                     if (!warnedUnsupportedAdPreload) {
                         warnedUnsupportedAdPreload = true;
                         console.warn('AIT full-screen ads are not supported; configured preload is a no-op.', placementId);
@@ -259,6 +388,61 @@ export function createAitHostBridge(options = {}) {
                 const shown = await withLoadedAdSlot(dependencies, adGroupId, loadedAdGroupIds, loadingAdGroups, adLoadCoordinator, activeAdGroupIds, adTimeoutMs, 'interstitial', showInterstitial);
                 return ok(request, shown.acquired ? shown.value : { status: 'unavailable' });
             }
+            case 'ads.mountBanner': {
+                const placementId = readPlacementId(request.payload);
+                const surfaceId = readBannerSurfaceId(request.payload);
+                const adGroupId = adGroupIds.get(placementId);
+                if (adGroupId === undefined
+                    || adPlacementTypes.get(placementId) !== 'banner'
+                    || !areBannerAdsSupported(dependencies)) {
+                    return ok(request, { status: 'unavailable' });
+                }
+                const target = globalThis.document?.getElementById(surfaceId);
+                if (target === null || target === undefined) {
+                    return ok(request, { status: 'failed' });
+                }
+                pendingBannerMountSettlements.get(surfaceId)?.settleUnavailable();
+                const mountOwner = Symbol(surfaceId);
+                bannerMountOwners.set(surfaceId, mountOwner);
+                activeBannerAttachments.get(surfaceId)?.destroy();
+                activeBannerAttachments.delete(surfaceId);
+                const initializeBanner = bannerInitialization
+                    ?? initializeAitBannerAds(dependencies, bannerRenderTimeoutMs);
+                void (bannerInitialization = initializeBanner);
+                if (!await initializeBanner) {
+                    bannerInitialization = undefined;
+                    if (bannerMountOwners.get(surfaceId) === mountOwner) {
+                        bannerMountOwners.delete(surfaceId);
+                    }
+                    return ok(request, { status: 'failed' });
+                }
+                if (bannerMountOwners.get(surfaceId) !== mountOwner) {
+                    return ok(request, { status: 'unavailable' });
+                }
+                activeBannerAttachments.get(surfaceId)?.destroy();
+                activeBannerAttachments.delete(surfaceId);
+                const result = await attachAitBanner({
+                    dependencies,
+                    adGroupId,
+                    surfaceId,
+                    target,
+                    timeoutMs: bannerRenderTimeoutMs,
+                    appearance: bannerAppearance,
+                    activeAttachments: activeBannerAttachments,
+                    mountOwner,
+                    mountOwners: bannerMountOwners,
+                    pendingSettlements: pendingBannerMountSettlements,
+                });
+                return ok(request, result);
+            }
+            case 'ads.unmountBanner': {
+                const surfaceId = readBannerSurfaceId(request.payload);
+                pendingBannerMountSettlements.get(surfaceId)?.settleUnavailable();
+                bannerMountOwners.delete(surfaceId);
+                activeBannerAttachments.get(surfaceId)?.destroy();
+                activeBannerAttachments.delete(surfaceId);
+                return ok(request, {});
+            }
             case 'leaderboard.submitScore': {
                 if (!isGameCenterSupported(dependencies)) {
                     return ok(request, { submitted: false });
@@ -306,7 +490,7 @@ function getNotificationStatus(topic, templateCodes, subscriptions, dependencies
     if (!templateCodes.has(topic)) {
         return 'configuration-required';
     }
-    if (!isCapabilitySupported(() => dependencies.requestNotificationAgreement.isSupported())) {
+    if (!isAitNativeMethodSupported(dependencies.requestNotificationAgreement)) {
         return 'unsupported';
     }
     return subscriptions.has(topic) ? 'subscribed' : 'not-subscribed';
@@ -901,9 +1085,949 @@ function isGameCenterSupported(dependencies) {
         ios: '5.221.0',
     }));
 }
+const aitIapPurchaseAttemptStatus = {
+    pending: 'pending',
+    serverGranted: 'server-granted',
+    completed: 'completed',
+};
+function isAitIapSupported(input) {
+    if (input.products.byProductId.size === 0
+        || input.prepare === undefined
+        || input.verifier === undefined
+        || input.entitlementReader === undefined) {
+        return false;
+    }
+    return isAitNativeMethodSupported(input.dependencies.iap.createOneTimePurchaseOrder)
+        && isAitNativeMethodSupported(input.dependencies.iap.getProductItemList)
+        && isAitNativeMethodSupported(input.dependencies.iap.getPendingOrders)
+        && isAitNativeMethodSupported(input.dependencies.iap.completeProductGrant);
+}
+async function listAitIapProducts(input) {
+    if (!isAitIapSupported(input)) {
+        return [];
+    }
+    try {
+        const result = await waitForAitIapNativeCall(() => input.dependencies.iap.getProductItemList(), input.timeoutMs);
+        if (result === undefined) {
+            return [];
+        }
+        const products = [];
+        for (const nativeProduct of result.products) {
+            const configured = input.products.bySku.get(nativeProduct.sku);
+            if (configured === undefined) {
+                continue;
+            }
+            const product = toAitIapProductInfo(nativeProduct, configured);
+            if (product !== undefined) {
+                products.push(product);
+            }
+        }
+        return products;
+    }
+    catch {
+        // Product metadata is not authoritative. If the native catalog cannot be
+        // read, hide it instead of rendering stale game-owned prices.
+        return [];
+    }
+}
+async function readAitIapEntitlements(reader, timeoutMs) {
+    if (reader === undefined || timeoutMs <= 0) {
+        return [];
+    }
+    try {
+        const entitlements = await waitForAitIapNativeCall(reader, timeoutMs);
+        return entitlements === undefined ? [] : [...entitlements];
+    }
+    catch (error) {
+        // The game authority owns durable purchase state. A read failure must not
+        // turn stale local data into a visible entitlement.
+        console.warn('AIT IAP entitlement read failed; reporting no entitlements.', errorMessage(error));
+        return [];
+    }
+}
+/**
+ * Return a durable result before consulting the provider catalog. This makes a
+ * repeated client idempotency key safe after a reload or after the in-memory
+ * coalescing map has been cleared.
+ */
+async function resolvePersistedAitIapPurchaseAttempt(input) {
+    const storageKey = aitIapPurchaseAttemptStorageKey(input.product.productId, input.idempotencyKey);
+    let serialized;
+    try {
+        serialized = await waitForAitIapNativeCall(() => input.storage.getItem(storageKey), input.timeoutMs);
+    }
+    catch (error) {
+        console.warn('AIT IAP purchase attempt storage read failed; treating the attempt as pending.', errorMessage(error));
+        return pendingPurchase();
+    }
+    if (serialized === undefined) {
+        return pendingPurchase();
+    }
+    if (serialized === null) {
+        return undefined;
+    }
+    let state;
+    try {
+        state = JSON.parse(serialized);
+    }
+    catch (error) {
+        console.warn('AIT IAP purchase attempt marker is invalid; treating the attempt as pending.', errorMessage(error));
+        return pendingPurchase();
+    }
+    if (!isRecord(state)
+        || state.productId !== input.product.productId
+        || state.idempotencyKey !== input.idempotencyKey) {
+        return pendingPurchase();
+    }
+    if (state.status === aitIapPurchaseAttemptStatus.pending) {
+        if (typeof state.orderId === 'string' && isAitIapOrderId(state.orderId)) {
+            return pendingPurchase(state.orderId);
+        }
+        const pendingSince = normalizePendingSince(state.pendingSince);
+        if (pendingSince === undefined
+            || !isAitIapPendingAttemptPastRecoveryWindow(pendingSince)) {
+            return pendingPurchase();
+        }
+        const hasPendingProviderOrder = await hasAitIapPendingOrderForSku(input.dependencies, input.product.sku, input.timeoutMs);
+        if (hasPendingProviderOrder !== false) {
+            return pendingPurchase();
+        }
+        const cleared = await clearAitIapPurchaseAttempt(input);
+        return cleared ? undefined : pendingPurchase();
+    }
+    if (state.status === aitIapPurchaseAttemptStatus.serverGranted
+        && typeof state.orderId === 'string'
+        && isAitIapOrderId(state.orderId)) {
+        return pendingPurchase(state.orderId);
+    }
+    if (state.status === aitIapPurchaseAttemptStatus.completed
+        && typeof state.orderId === 'string'
+        && isAitIapOrderId(state.orderId)) {
+        return completedAitIapPurchase(input.product, state.orderId);
+    }
+    return pendingPurchase();
+}
+async function persistAitIapPurchaseAttempt(input) {
+    return await writeAitIapStorage(input.storage, aitIapPurchaseAttemptStorageKey(input.product.productId, input.idempotencyKey), JSON.stringify({
+        status: input.status,
+        productId: input.product.productId,
+        idempotencyKey: input.idempotencyKey,
+        ...(input.status === aitIapPurchaseAttemptStatus.pending
+            ? { pendingSince: new Date().toISOString() }
+            : {}),
+        ...(input.orderId === undefined ? {} : { orderId: input.orderId }),
+    }), input.timeoutMs);
+}
+async function clearAitIapPurchaseAttempt(input) {
+    return await removeAitIapStorage(input.storage, aitIapPurchaseAttemptStorageKey(input.product.productId, input.idempotencyKey), input.timeoutMs);
+}
+async function verifyAndPersistAitIapProductGrant(input) {
+    const startedAt = Date.now();
+    const correlated = await persistAitIapPurchaseAttempt({
+        storage: input.storage,
+        product: input.product,
+        idempotencyKey: input.idempotencyKey,
+        orderId: input.orderId,
+        status: aitIapPurchaseAttemptStatus.pending,
+        timeoutMs: input.timeoutMs,
+    });
+    if (!correlated) {
+        // Never let the backend commit a grant unless the provider order is first
+        // durably tied to the client attempt. Otherwise a lost response could let
+        // the same client idempotency key open a second checkout after restore.
+        return false;
+    }
+    const verificationTimeoutMs = remainingAitIapOperationTimeout(startedAt, input.timeoutMs);
+    if (verificationTimeoutMs === 0) {
+        return false;
+    }
+    const granted = await verifyAitIapProductGrant({
+        verifier: input.verifier,
+        orderId: input.orderId,
+        product: input.product,
+        idempotencyKey: input.orderIdempotencyKey,
+        source: input.source,
+        timeoutMs: verificationTimeoutMs,
+    });
+    if (!granted) {
+        return false;
+    }
+    const remainingTimeoutMs = remainingAitIapOperationTimeout(startedAt, input.timeoutMs);
+    if (remainingTimeoutMs === 0) {
+        return false;
+    }
+    return await persistAitIapPurchaseAttempt({
+        storage: input.storage,
+        product: input.product,
+        idempotencyKey: input.idempotencyKey,
+        orderId: input.orderId,
+        status: aitIapPurchaseAttemptStatus.serverGranted,
+        timeoutMs: remainingTimeoutMs,
+    });
+}
+function remainingAitIapOperationTimeout(startedAt, timeoutMs) {
+    return Math.max(0, timeoutMs - Math.max(0, Date.now() - startedAt));
+}
+async function writeAitIapStorage(storage, key, value, timeoutMs) {
+    return await waitForAitIapStorageOperation(() => storage.setItem(key, value), timeoutMs);
+}
+async function removeAitIapStorage(storage, key, timeoutMs) {
+    return await waitForAitIapStorageOperation(() => storage.removeItem(key), timeoutMs);
+}
+async function waitForAitIapStorageOperation(operation, timeoutMs) {
+    let timeout;
+    const timeoutResult = new Promise((resolve) => {
+        timeout = globalThis.setTimeout(() => resolve(false), timeoutMs);
+    });
+    const operationResult = Promise.resolve()
+        .then(operation)
+        .then(() => true, () => false);
+    try {
+        return await Promise.race([operationResult, timeoutResult]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            globalThis.clearTimeout(timeout);
+        }
+    }
+}
+function aitIapPurchaseAttemptStorageKey(productId, idempotencyKey) {
+    return `${iapPurchaseAttemptStoragePrefix}${encodeURIComponent(productId)}:${encodeURIComponent(idempotencyKey)}`;
+}
+function isAitIapPendingAttemptPastRecoveryWindow(pendingSince) {
+    const startedAt = Date.parse(pendingSince);
+    return Number.isFinite(startedAt)
+        && Date.now() - startedAt >= pendingIapPurchaseAttemptRecoveryAgeMs;
+}
+async function hasAitIapPendingOrderForSku(dependencies, sku, timeoutMs) {
+    try {
+        const result = await waitForAitIapNativeCall(() => dependencies.iap.getPendingOrders(), timeoutMs);
+        if (result === undefined) {
+            return undefined;
+        }
+        return result.orders.some((order) => order.sku === sku && isAitIapOrderId(order.orderId));
+    }
+    catch (error) {
+        console.warn('AIT IAP pending-order lookup failed; preserving the client retry barrier.', errorMessage(error));
+        return undefined;
+    }
+}
+/**
+ * Keep the completed-attempt index bounded without deleting terminal retry
+ * markers. A client idempotency key may be replayed indefinitely, so removing
+ * its durable result could open a second native checkout. The index is only
+ * bookkeeping for recent entries; all storage failures leave markers intact.
+ */
+async function retainCompletedAitIapPurchaseAttempt(storage, storageKey, timeoutMs) {
+    const startedAt = Date.now();
+    try {
+        const serialized = await waitForAitIapNativeCall(() => storage.getItem(iapCompletedPurchaseAttemptIndexStorageKey), timeoutMs);
+        const knownKeys = parseAitIapCompletedPurchaseAttemptIndex(serialized);
+        const keys = [...knownKeys.filter((knownKey) => knownKey !== storageKey), storageKey];
+        const retainedKeys = keys.slice(-maximumIndexedCompletedIapPurchaseAttempts);
+        const retentionTimeoutMs = remainingAitIapOperationTimeout(startedAt, timeoutMs);
+        if (retentionTimeoutMs === 0) {
+            return;
+        }
+        await writeAitIapStorage(storage, iapCompletedPurchaseAttemptIndexStorageKey, JSON.stringify(retainedKeys), retentionTimeoutMs);
+    }
+    catch {
+        // Index maintenance is best effort. The terminal marker remains the
+        // durable retry barrier even when its recent-entry index cannot be written.
+    }
+}
+function parseAitIapCompletedPurchaseAttemptIndex(serialized) {
+    if (serialized === null || serialized === undefined) {
+        return [];
+    }
+    try {
+        const value = JSON.parse(serialized);
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        const keys = value.filter((key) => (typeof key === 'string'
+            && key.startsWith(iapPurchaseAttemptStoragePrefix)
+            && key.length <= 4096));
+        return [...new Set(keys)].slice(-maximumIndexedCompletedIapPurchaseAttempts);
+    }
+    catch {
+        return [];
+    }
+}
+async function readAitIapPendingOrderCursor(storage, timeoutMs) {
+    try {
+        const cursor = await waitForAitIapNativeCall(() => storage.getItem(iapPendingOrderCursorStorageKey), timeoutMs);
+        return typeof cursor === 'string' && isAitIapOrderId(cursor) ? cursor : undefined;
+    }
+    catch (error) {
+        console.warn('AIT IAP pending-order cursor read failed; starting from the first eligible order.', errorMessage(error));
+        return undefined;
+    }
+}
+async function writeAitIapPendingOrderCursor(storage, orderId, timeoutMs) {
+    return await writeAitIapStorage(storage, iapPendingOrderCursorStorageKey, orderId, timeoutMs);
+}
+function rotateAitIapPendingOrders(orders, cursor, limit) {
+    if (orders.length === 0) {
+        return [];
+    }
+    const cursorIndex = cursor === undefined
+        ? -1
+        : orders.findIndex(({ order }) => order.orderId === cursor);
+    const startIndex = cursorIndex < 0 ? 0 : (cursorIndex + 1) % orders.length;
+    const selected = [];
+    const count = Math.min(limit, orders.length);
+    for (let offset = 0; offset < count; offset += 1) {
+        const next = orders[(startIndex + offset) % orders.length];
+        if (next !== undefined) {
+            selected.push(next);
+        }
+    }
+    return selected;
+}
+async function purchaseAitIapProduct(input) {
+    const prepared = await prepareAitIap(input.prepare, {
+        intent: 'purchase',
+        productId: input.product.productId,
+        platformSku: input.product.sku,
+    }, input.timeoutMs);
+    if (!prepared) {
+        return failedPurchase();
+    }
+    const started = await persistAitIapPurchaseAttempt({
+        storage: input.dependencies.storage,
+        product: input.product,
+        idempotencyKey: input.idempotencyKey,
+        status: aitIapPurchaseAttemptStatus.pending,
+        timeoutMs: input.timeoutMs,
+    });
+    if (!started) {
+        // We cannot tell whether a delayed native-storage write eventually
+        // succeeded. Do not open a checkout without a durable retry barrier.
+        return pendingPurchase();
+    }
+    return new Promise((resolve) => {
+        const grantAttempts = new Map();
+        let settled = false;
+        let cleanup;
+        let cleanupRequested = false;
+        let sessionTimeout;
+        let providerOrderId;
+        let grantedOrderId;
+        let markerDeletionStarted = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (sessionTimeout !== undefined) {
+                globalThis.clearTimeout(sessionTimeout);
+                sessionTimeout = undefined;
+            }
+            if (cleanup === undefined) {
+                cleanupRequested = true;
+            }
+            else {
+                safelyCleanupAitIapPurchase(cleanup);
+            }
+            resolve(result);
+        };
+        const startMarkerDeletion = (clearedResult) => {
+            markerDeletionStarted = true;
+            void clearAitIapPurchaseAttempt({
+                storage: input.dependencies.storage,
+                product: input.product,
+                idempotencyKey: input.idempotencyKey,
+                timeoutMs: input.timeoutMs,
+            }).then((cleared) => {
+                finish(cleared ? clearedResult : pendingPurchase());
+            });
+        };
+        const processProductGrant = (orderId) => {
+            if (markerDeletionStarted) {
+                // Cancellation won the serialization race. Do not let a later queued
+                // grant callback commit after its retry barrier starts disappearing.
+                return Promise.resolve(false);
+            }
+            const existing = grantAttempts.get(orderId);
+            if (existing !== undefined) {
+                return existing;
+            }
+            if (!isAitIapOrderId(orderId)
+                || (providerOrderId !== undefined && providerOrderId !== orderId)) {
+                return Promise.resolve(false);
+            }
+            providerOrderId = orderId;
+            const attempt = verifyAndPersistAitIapProductGrant({
+                verifier: input.verifier,
+                storage: input.dependencies.storage,
+                orderId,
+                product: input.product,
+                idempotencyKey: input.idempotencyKey,
+                orderIdempotencyKey: createAitIapOrderIdempotencyKey(orderId),
+                source: 'process-product-grant',
+                timeoutMs: input.timeoutMs,
+            }).then((granted) => {
+                if (granted) {
+                    grantedOrderId = orderId;
+                }
+                return granted;
+            });
+            grantAttempts.set(orderId, attempt);
+            return attempt;
+        };
+        sessionTimeout = globalThis.setTimeout(() => {
+            // The native SDK may have dispatched an order even when it fails to
+            // deliver a terminal callback. Preserve the marker and let retry or
+            // restore reconcile it instead of opening a second checkout.
+            finish(pendingPurchase(grantedOrderId));
+        }, defaultIapPurchaseSessionTimeoutMs);
+        try {
+            cleanup = input.dependencies.iap.createOneTimePurchaseOrder({
+                options: {
+                    sku: input.product.sku,
+                    processProductGrant: ({ orderId }) => processProductGrant(orderId),
+                },
+                onEvent: async ({ data }) => {
+                    const granted = await (grantAttempts.get(data.orderId) ?? processProductGrant(data.orderId));
+                    if (!granted) {
+                        finish(pendingPurchase(providerOrderId));
+                        return;
+                    }
+                    const result = completedAitIapPurchase(input.product, data.orderId);
+                    const persisted = await persistAitIapPurchaseAttempt({
+                        storage: input.dependencies.storage,
+                        product: input.product,
+                        idempotencyKey: input.idempotencyKey,
+                        orderId: data.orderId,
+                        status: aitIapPurchaseAttemptStatus.completed,
+                        timeoutMs: input.timeoutMs,
+                    });
+                    if (persisted) {
+                        void input.retainCompletedAttempt(input.dependencies.storage, aitIapPurchaseAttemptStorageKey(input.product.productId, input.idempotencyKey));
+                    }
+                    finish(persisted ? result : pendingPurchase(data.orderId));
+                },
+                onError: (error) => {
+                    if (grantedOrderId !== undefined
+                        || providerOrderId !== undefined
+                        || grantAttempts.size > 0
+                        || !isAitIapCancellation(error)) {
+                        // A cancellation racing an authoritative grant is ambiguous. Keep
+                        // the durable client retry barrier until retry/restore observes
+                        // the verifier's eventual result.
+                        finish(pendingPurchase(grantedOrderId ?? providerOrderId));
+                        return;
+                    }
+                    startMarkerDeletion(cancelledPurchase());
+                },
+            });
+            if (cleanupRequested) {
+                safelyCleanupAitIapPurchase(cleanup);
+            }
+        }
+        catch {
+            // A malformed SDK can invoke a grant callback and then throw during
+            // registration. Preserve that active order; only a throw with no grant
+            // startup proves there is no authoritative commit racing deletion.
+            if (providerOrderId !== undefined || grantAttempts.size > 0) {
+                finish(pendingPurchase(providerOrderId));
+                return;
+            }
+            startMarkerDeletion(failedPurchase());
+        }
+    });
+}
+async function restoreAitIapProducts(input) {
+    const prepare = input.prepare;
+    const verifier = input.verifier;
+    if (!isAitIapSupported(input) || prepare === undefined || verifier === undefined) {
+        return { restoredEntitlements: [] };
+    }
+    const restoreStartedAt = Date.now();
+    const getRemainingRestoreTimeout = () => {
+        return remainingAitIapOperationTimeout(restoreStartedAt, input.timeoutMs);
+    };
+    const prepared = await prepareAitIap(prepare, { intent: 'restore' }, getRemainingRestoreTimeout());
+    if (!prepared) {
+        return { restoredEntitlements: [] };
+    }
+    const postPrepareTimeoutMs = getRemainingRestoreTimeout();
+    const reservedEntitlementReadTimeoutMs = Math.max(1, Math.ceil(postPrepareTimeoutMs / 3));
+    const reconciliationTimeoutMs = Math.max(0, postPrepareTimeoutMs - reservedEntitlementReadTimeoutMs);
+    const reconciliationStartedAt = Date.now();
+    const getRemainingReconciliationTimeout = () => {
+        return Math.min(getRemainingRestoreTimeout(), remainingAitIapOperationTimeout(reconciliationStartedAt, reconciliationTimeoutMs));
+    };
+    const finishRestore = async (locallyRestoredEntitlements = []) => {
+        const entitlementTimeoutMs = getRemainingRestoreTimeout();
+        const authoritativeEntitlements = await readAitIapEntitlements(input.entitlementReader, entitlementTimeoutMs);
+        return {
+            restoredEntitlements: mergeAitIapRestoredEntitlements(locallyRestoredEntitlements, authoritativeEntitlements, input.products),
+        };
+    };
+    if (reconciliationTimeoutMs === 0) {
+        return await finishRestore();
+    }
+    let pendingOrders;
+    try {
+        const pendingOrderTimeoutMs = getRemainingReconciliationTimeout();
+        if (pendingOrderTimeoutMs === 0) {
+            return await finishRestore();
+        }
+        pendingOrders = await waitForAitIapNativeCall(() => input.dependencies.iap.getPendingOrders(), pendingOrderTimeoutMs);
+    }
+    catch {
+        return await finishRestore();
+    }
+    if (pendingOrders === undefined) {
+        return await finishRestore();
+    }
+    const eligibleOrders = [];
+    const seenOrderIds = new Set();
+    for (const order of pendingOrders.orders) {
+        const product = input.products.bySku.get(order.sku);
+        if (product === undefined
+            || !isAitIapOrderId(order.orderId)
+            || seenOrderIds.has(order.orderId)) {
+            continue;
+        }
+        seenOrderIds.add(order.orderId);
+        eligibleOrders.push({ order, product });
+    }
+    const restoredEntitlements = [];
+    const cursorTimeoutMs = getRemainingReconciliationTimeout();
+    const cursor = cursorTimeoutMs === 0
+        ? undefined
+        : await readAitIapPendingOrderCursor(input.dependencies.storage, cursorTimeoutMs);
+    const orders = rotateAitIapPendingOrders(eligibleOrders, cursor, maximumPendingIapOrders);
+    if (eligibleOrders.length > orders.length) {
+        console.warn('AIT IAP pending-order restore reached its per-launch limit.', {
+            limit: maximumPendingIapOrders,
+            ignoredOrderCount: eligibleOrders.length - orders.length,
+        });
+    }
+    for (const selectedOrder of orders) {
+        const { order, product } = selectedOrder;
+        const cursorWriteTimeoutMs = getRemainingReconciliationTimeout();
+        if (cursorWriteTimeoutMs === 0) {
+            break;
+        }
+        const cursorAdvanced = await writeAitIapPendingOrderCursor(input.dependencies.storage, order.orderId, cursorWriteTimeoutMs);
+        if (!cursorAdvanced) {
+            break;
+        }
+        const verificationTimeoutMs = getRemainingReconciliationTimeout();
+        if (verificationTimeoutMs === 0) {
+            break;
+        }
+        const granted = await verifyAitIapProductGrant({
+            verifier,
+            orderId: order.orderId,
+            product,
+            idempotencyKey: createAitIapOrderIdempotencyKey(order.orderId),
+            source: 'pending-order-restore',
+            timeoutMs: verificationTimeoutMs,
+        });
+        if (!granted) {
+            continue;
+        }
+        try {
+            const completionTimeoutMs = getRemainingReconciliationTimeout();
+            if (completionTimeoutMs === 0) {
+                break;
+            }
+            const completed = await waitForAitIapNativeCall(() => input.dependencies.iap.completeProductGrant({
+                params: { orderId: order.orderId },
+            }), completionTimeoutMs);
+            if (completed === true) {
+                restoredEntitlements.push({
+                    id: product.productId,
+                    source: 'purchase',
+                    grantedAt: normalizeAitIapGrantTime(order.paymentCompletedDate),
+                });
+            }
+        }
+        catch {
+            // Keep provider state pending when its completion acknowledgement fails.
+        }
+    }
+    return await finishRestore(restoredEntitlements);
+}
+function mergeAitIapRestoredEntitlements(restoredEntitlements, authoritativeEntitlements, products) {
+    const entitlementsById = new Map();
+    for (const entitlement of restoredEntitlements) {
+        entitlementsById.set(entitlement.id, entitlement);
+    }
+    for (const entitlement of authoritativeEntitlements) {
+        if (entitlement.source !== 'purchase'
+            || !products.byProductId.has(entitlement.id)) {
+            continue;
+        }
+        entitlementsById.set(entitlement.id, entitlement);
+    }
+    return [...entitlementsById.values()];
+}
+async function prepareAitIap(prepare, input, timeoutMs) {
+    if (prepare === undefined) {
+        return false;
+    }
+    let timeout;
+    const timeoutResult = new Promise((resolve) => {
+        timeout = globalThis.setTimeout(() => resolve(false), timeoutMs);
+    });
+    const preparationResult = Promise.resolve()
+        .then(async () => prepare(input))
+        .then((result) => result === true, () => false);
+    try {
+        return await Promise.race([preparationResult, timeoutResult]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            globalThis.clearTimeout(timeout);
+        }
+    }
+}
+async function isAitOneTimeIapProduct(dependencies, configured, timeoutMs) {
+    try {
+        const result = await waitForAitIapNativeCall(() => dependencies.iap.getProductItemList(), timeoutMs);
+        if (result === undefined) {
+            return false;
+        }
+        const nativeProduct = result.products.find(({ sku }) => sku === configured.sku);
+        if (nativeProduct === undefined) {
+            return false;
+        }
+        return nativeProduct.type === 'CONSUMABLE' || nativeProduct.type === 'NON_CONSUMABLE';
+    }
+    catch {
+        // The provider catalog is the authoritative source for the purchase flow.
+        // Do not route an unknown or unavailable SKU into a one-time order.
+        return false;
+    }
+}
+async function waitForAitIapNativeCall(operation, timeoutMs) {
+    let timeout;
+    const timeoutResult = new Promise((resolve) => {
+        timeout = globalThis.setTimeout(() => resolve(undefined), timeoutMs);
+    });
+    try {
+        const operationResult = operation();
+        return await Promise.race([operationResult, timeoutResult]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            globalThis.clearTimeout(timeout);
+        }
+    }
+}
+async function verifyAitIapProductGrant(input) {
+    const controller = new AbortController();
+    let timeout;
+    const timeoutResult = new Promise((resolve) => {
+        timeout = globalThis.setTimeout(() => {
+            controller.abort();
+            resolve(false);
+        }, input.timeoutMs);
+    });
+    const verifierResult = Promise.resolve()
+        .then(async () => input.verifier({
+        orderId: input.orderId,
+        productId: input.product.productId,
+        platformSku: input.product.sku,
+        idempotencyKey: input.idempotencyKey,
+        source: input.source,
+        purchasedAt: new Date().toISOString(),
+        signal: controller.signal,
+        timeoutMs: input.timeoutMs,
+    }))
+        .then((result) => result === true, () => false);
+    try {
+        return await Promise.race([verifierResult, timeoutResult]);
+    }
+    finally {
+        if (timeout !== undefined) {
+            globalThis.clearTimeout(timeout);
+        }
+    }
+}
+function completedAitIapPurchase(product, orderId) {
+    return {
+        status: 'completed',
+        transactionId: orderId,
+        entitlementIds: [product.productId],
+        evidence: createAitIapEvidence(orderId, product.sku, 'process-product-grant'),
+    };
+}
+function failedPurchase() {
+    return { status: 'failed', entitlementIds: [] };
+}
+function cancelledPurchase() {
+    return { status: 'cancelled', entitlementIds: [] };
+}
+function pendingPurchase(transactionId) {
+    return {
+        status: 'pending',
+        ...(transactionId === undefined ? {} : { transactionId }),
+        entitlementIds: [],
+    };
+}
+function createAitIapEvidence(orderId, sku, source) {
+    return {
+        schema: iapEvidenceSchema,
+        payload: { orderId, sku, source },
+    };
+}
+function createAitIapOrderIdempotencyKey(orderId) {
+    return `apps-in-toss:purchase:${encodeURIComponent(orderId)}`;
+}
+function createAitIapPurchaseRequestKey(productId, idempotencyKey) {
+    return `${encodeURIComponent(productId)}:${encodeURIComponent(idempotencyKey)}`;
+}
+function safelyCleanupAitIapPurchase(cleanup) {
+    try {
+        cleanup();
+    }
+    catch {
+        // The bridge has already reached a terminal result; cleanup failures must
+        // not turn a completed server grant into a client-visible failure.
+    }
+}
+function isAitIapOrderId(value) {
+    return value.length > 0 && value.length <= 2048 && !/[\p{Cc}\p{Cf}]/u.test(value);
+}
+function isAitIapCancellation(error) {
+    if (isAbortError(error)) {
+        return true;
+    }
+    if (!isRecord(error)) {
+        return false;
+    }
+    const code = typeof error.code === 'string' ? error.code : '';
+    return /CANCEL|ABORT/u.test(code);
+}
+function normalizeAitIapGrantTime(value) {
+    if (value.length === 0 || value.length > 2048 || /[\p{Cc}\p{Cf}]/u.test(value)) {
+        return new Date().toISOString();
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : new Date().toISOString();
+}
+function toAitIapProductInfo(nativeProduct, configured) {
+    const title = normalizeAitIapDisplayText(nativeProduct.displayName);
+    const description = normalizeAitIapDisplayText(nativeProduct.description);
+    const formattedPrice = normalizeAitIapDisplayText(nativeProduct.displayAmount);
+    if (title === undefined || description === undefined || formattedPrice === undefined) {
+        return undefined;
+    }
+    if (nativeProduct.type === 'SUBSCRIPTION') {
+        // Subscription creation, renewal, and expiry need a different native and
+        // server-authority lifecycle. This bridge only owns one-time orders.
+        console.warn('AIT subscription IAP is unavailable through the one-time order bridge.', {
+            productId: configured.productId,
+            sku: nativeProduct.sku,
+        });
+        return undefined;
+    }
+    let type;
+    if (nativeProduct.type === 'CONSUMABLE') {
+        type = 'consumable';
+    }
+    else if (nativeProduct.type === 'NON_CONSUMABLE') {
+        type = 'non_consumable';
+    }
+    if (type === undefined) {
+        console.warn('AIT native IAP product has an unsupported type; hiding product.', {
+            productId: configured.productId,
+            sku: nativeProduct.sku,
+            nativeType: nativeProduct.type,
+        });
+        return undefined;
+    }
+    return {
+        id: configured.productId,
+        type,
+        title,
+        description,
+        price: {
+            formatted: formattedPrice,
+            currencyCode: configured.currencyCode,
+        },
+    };
+}
+function normalizeAitIapDisplayText(value) {
+    const normalized = value.trim();
+    return normalized.length > 0 && normalized.length <= 2048 && !/[\p{Cc}\p{Cf}]/u.test(normalized)
+        ? normalized
+        : undefined;
+}
+function normalizeIapProducts(input) {
+    const byProductId = new Map();
+    const bySku = new Map();
+    for (const rawProduct of input ?? []) {
+        const productId = typeof rawProduct.productId === 'string'
+            ? normalizeAitIapConfigIdentifier(rawProduct.productId, 'productId', 128)
+            : undefined;
+        const sku = typeof rawProduct.sku === 'string'
+            ? normalizeAitIapConfigIdentifier(rawProduct.sku, 'sku', 2048)
+            : undefined;
+        const currencyCode = normalizeAitIapCurrencyCode(rawProduct.currencyCode);
+        if (productId === undefined || sku === undefined || currencyCode === undefined) {
+            console.warn('AIT IAP product configuration is invalid; disabling one product.', {
+                productId: rawProduct.productId,
+                sku: rawProduct.sku,
+            });
+            continue;
+        }
+        if (byProductId.has(productId) || bySku.has(sku)) {
+            console.warn('AIT IAP product configuration has a duplicate product id or SKU; disabling one product.', { productId, sku });
+            continue;
+        }
+        const product = {
+            productId: productId,
+            sku,
+            currencyCode,
+        };
+        byProductId.set(product.productId, product);
+        bySku.set(product.sku, product);
+    }
+    return { byProductId, bySku };
+}
+function normalizeAitIapConfigIdentifier(value, field, maximumLength) {
+    const normalized = value.trim();
+    if (normalized.length === 0
+        || normalized.length > maximumLength
+        || /[\p{Cc}\p{Cf}]/u.test(normalized)) {
+        return undefined;
+    }
+    return normalized;
+}
+function normalizeAitIapCurrencyCode(value) {
+    const normalized = value?.trim().toUpperCase() ?? 'KRW';
+    return /^[A-Z]{3}$/u.test(normalized) ? normalized : undefined;
+}
 function areFullScreenAdsSupported(dependencies) {
-    return isCapabilitySupported(() => dependencies.loadFullScreenAd.isSupported())
-        && isCapabilitySupported(() => dependencies.showFullScreenAd.isSupported());
+    return isAitNativeMethodSupported(dependencies.loadFullScreenAd)
+        && isAitNativeMethodSupported(dependencies.showFullScreenAd);
+}
+function areBannerAdsSupported(dependencies) {
+    return isAitNativeMethodSupported(dependencies.tossAds.initialize)
+        && isAitNativeMethodSupported(dependencies.tossAds.attachBanner);
+}
+function initializeAitBannerAds(dependencies, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (initialized) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            globalThis.clearTimeout(timer);
+            resolve(initialized);
+        };
+        const timer = globalThis.setTimeout(() => finish(false), timeoutMs);
+        try {
+            dependencies.tossAds.initialize({
+                callbacks: {
+                    onInitialized: () => finish(true),
+                    onInitializationFailed: () => finish(false),
+                },
+            });
+        }
+        catch (error) {
+            console.warn('Failed to initialize AIT banner ads.', error);
+            finish(false);
+        }
+    });
+}
+async function attachAitBanner(input) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let terminalStatus;
+        let attachment;
+        const finish = (requestedStatus) => {
+            const ownsSurface = input.mountOwners.get(input.surfaceId) === input.mountOwner;
+            const status = requestedStatus === 'mounted' && !ownsSurface
+                ? 'unavailable'
+                : requestedStatus;
+            if (settled) {
+                if (status !== 'mounted' && input.activeAttachments.get(input.surfaceId) === attachment) {
+                    attachment?.destroy();
+                    input.activeAttachments.delete(input.surfaceId);
+                }
+                if (status !== 'mounted' && ownsSurface) {
+                    input.mountOwners.delete(input.surfaceId);
+                }
+                return;
+            }
+            settled = true;
+            terminalStatus = status;
+            globalThis.clearTimeout(timer);
+            if (input.pendingSettlements.get(input.surfaceId)?.mountOwner === input.mountOwner) {
+                input.pendingSettlements.delete(input.surfaceId);
+            }
+            if (status !== 'mounted') {
+                attachment?.destroy();
+                if (input.activeAttachments.get(input.surfaceId) === attachment) {
+                    input.activeAttachments.delete(input.surfaceId);
+                }
+                if (ownsSurface) {
+                    input.mountOwners.delete(input.surfaceId);
+                }
+            }
+            resolve({ status });
+        };
+        const timer = globalThis.setTimeout(() => finish('failed'), input.timeoutMs);
+        input.pendingSettlements.set(input.surfaceId, {
+            mountOwner: input.mountOwner,
+            settleUnavailable: () => finish('unavailable'),
+        });
+        try {
+            const sdkAttachment = input.dependencies.tossAds.attachBanner(input.adGroupId, input.target, {
+                theme: input.appearance.theme,
+                tone: input.appearance.tone,
+                variant: input.appearance.variant,
+                callbacks: {
+                    onAdRendered: () => finish('mounted'),
+                    onNoFill: () => finish('unavailable'),
+                    onAdFailedToRender: (payload) => {
+                        console.warn('Failed to render an AIT banner ad.', input.adGroupId, payload.error);
+                        finish('failed');
+                    },
+                },
+            });
+            let attachmentDestroyed = false;
+            attachment = {
+                destroy() {
+                    if (!attachmentDestroyed) {
+                        attachmentDestroyed = true;
+                        sdkAttachment.destroy();
+                    }
+                },
+            };
+            if (terminalStatus === 'unavailable' || terminalStatus === 'failed') {
+                attachment.destroy();
+                return;
+            }
+            if (input.mountOwners.get(input.surfaceId) !== input.mountOwner) {
+                attachment.destroy();
+                finish('unavailable');
+                return;
+            }
+            const existingAttachment = input.activeAttachments.get(input.surfaceId);
+            if (existingAttachment !== undefined && existingAttachment !== attachment) {
+                existingAttachment.destroy();
+            }
+            input.activeAttachments.set(input.surfaceId, attachment);
+        }
+        catch (error) {
+            console.warn('Failed to attach an AIT banner ad.', input.adGroupId, error);
+            finish('failed');
+        }
+    });
+}
+function isAitNativeMethodSupported(method) {
+    return isCapabilitySupported(() => method.isSupported?.() === true);
 }
 function isCapabilitySupported(check) {
     try {
@@ -995,6 +2119,16 @@ function normalizeDisplayStartTimeout(value) {
 function normalizeMaximumDisplayTimeout(value) {
     return normalizePositiveTimeout(value, defaultAdMaximumDisplayMs, 'AIT ad maximum display timeout must be a positive finite number.');
 }
+function normalizeBannerRenderTimeout(value) {
+    return normalizePositiveTimeout(value, defaultBannerRenderTimeoutMs, 'AIT banner render timeout must be a positive finite number.');
+}
+function normalizeIapProductGrantTimeout(value) {
+    const timeout = normalizePositiveTimeout(value, defaultIapProductGrantTimeoutMs, 'AIT IAP product-grant timeout must be a positive finite number.');
+    if (timeout > defaultIapProductGrantTimeoutMs) {
+        throw new Error(`AIT IAP product-grant timeout cannot exceed ${defaultIapProductGrantTimeoutMs}ms.`);
+    }
+    return timeout;
+}
 function normalizePositiveTimeout(value, defaultValue, message) {
     if (value === undefined) {
         return defaultValue;
@@ -1018,10 +2152,35 @@ function readPlacementId(payload) {
     }
     return placementId;
 }
+function readBannerSurfaceId(payload) {
+    const surfaceId = readPayloadRecord(payload).surfaceId;
+    if (typeof surfaceId !== 'string' || surfaceId.length === 0) {
+        throw new TypeError('AIT banner surfaceId must be a valid non-empty element id.');
+    }
+    return surfaceId;
+}
 function readIdempotencyKey(payload, fallback) {
     const value = readPayloadRecord(payload).idempotencyKey;
     return typeof value === 'string' && value.length > 0 ? value : fallback;
 }
+function readCommercePurchase(payload) {
+    const value = readPayloadRecord(payload);
+    const productId = value.productId;
+    const idempotencyKey = value.idempotencyKey;
+    if (typeof productId !== 'string'
+        || productId.length === 0
+        || productId.length > 128
+        || /[\p{Cc}\p{Cf}]/u.test(productId)) {
+        throw new TypeError('AIT IAP productId must contain 1 to 128 visible characters.');
+    }
+    if (typeof idempotencyKey !== 'string'
+        || idempotencyKey.length === 0
+        || idempotencyKey.length > 256
+        || /[\p{Cc}\p{Cf}]/u.test(idempotencyKey)) {
+        throw new TypeError('AIT IAP idempotencyKey must contain 1 to 256 visible characters.');
+    }
+    return { productId: productId, idempotencyKey };
+}
 function readRequiredIdempotencyKey(payload) {
     const value = readPayloadRecord(payload).idempotencyKey;
     if (typeof value !== 'string' || value.length === 0 || value.length > 256) {