@mpgd/adapter-ait 0.7.0 → 0.9.0

package/dist/host.js

@@ -1,12 +1,39 @@
-import { getTossShareLink, getUserKeyForGame, isMinVersionSupported, loadFullScreenAd, openGameCenterLeaderboard, 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, } 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;
+/** 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',
+    'streak-at-risk',
+    'friend-challenge',
+]);
 const launchEntries = new Set([
     'home',
     'daily',
@@ -21,11 +48,14 @@ const defaultDependencies = {
     storage: Storage,
     getTossShareLink,
     share,
+    grantPromotionReward,
+    requestNotificationAgreement,
     isMinVersionSupported,
     loadFullScreenAd,
     showFullScreenAd,
     openGameCenterLeaderboard,
     submitGameCenterLeaderBoardScore,
+    iap: IAP,
 };
 export function installAitHostBridge(options = {}) {
     const bridge = createAitHostBridge(options);
@@ -37,6 +67,16 @@ export function createAitHostBridge(options = {}) {
     const appName = normalizeAppName(options.appName ?? 'mpgd-kit');
     const adGroupIds = normalizeAdGroupIds(options.adGroupIds);
     const adPlacementTypes = normalizeAdPlacementTypes(options.adPlacementTypes);
+    const promotionRewards = normalizePromotionRewards(options.promotionRewards);
+    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();
@@ -49,6 +89,15 @@ export function createAitHostBridge(options = {}) {
         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 {
@@ -67,12 +116,21 @@ export function createAitHostBridge(options = {}) {
                     && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'rewarded');
                 const interstitialAds = adsSupported
                     && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'interstitial');
+                const nativeIap = isAitIapSupported({
+                    dependencies,
+                    products: iapProducts,
+                    prepare: options.prepareIap,
+                    verifier: options.verifyIapProductGrant,
+                    entitlementReader: options.readIapEntitlements,
+                    timeoutMs: iapProductGrantTimeoutMs,
+                });
                 return ok(request, {
-                    nativeIap: false,
+                    nativeIap,
                     nativeAds: rewardedAds || interstitialAds,
                     rewardedAds,
                     interstitialAds,
                     nativeLeaderboard: isGameCenterSupported(dependencies),
+                    remoteLeaderboard: false,
                     achievements: false,
                     cloudSave: false,
                     socialShare: true,
@@ -111,18 +169,145 @@ export function createAitHostBridge(options = {}) {
             case 'share.readInboundShare':
                 return ok(request, readInboundShare());
             case 'notifications.getStatus':
-                return ok(request, 'unsupported');
-            case 'notifications.requestSubscription':
-                return ok(request, 'unavailable');
-            // IAP must be installed with game-owned server verification. Never return demo grants.
+                return ok(request, getNotificationStatus(readNotificationTopic(request.payload), notificationTemplateCodes, notificationSubscriptions, dependencies));
+            case 'notifications.requestSubscription': {
+                const topic = readNotificationTopic(request.payload);
+                const templateCode = notificationTemplateCodes.get(topic);
+                if (templateCode === undefined
+                    || !isAitNativeMethodSupported(dependencies.requestNotificationAgreement)) {
+                    return ok(request, 'unavailable');
+                }
+                const result = await requestAitNotificationAgreement(dependencies.requestNotificationAgreement, templateCode);
+                if (result === 'subscribed') {
+                    notificationSubscriptions.add(topic);
+                }
+                return ok(request, result);
+            }
+            case 'promotions.getAvailability': {
+                const campaignId = readCampaignId(request.payload);
+                const availability = getPromotionAvailability(campaignId, promotionRewards, authorizePromotionGrant, dependencies);
+                return ok(request, availability);
+            }
+            case 'promotions.grantReward': {
+                const campaignId = readCampaignId(request.payload);
+                const reward = promotionRewards.get(campaignId);
+                const idempotencyKey = readRequiredIdempotencyKey(request.payload);
+                if (reward === undefined
+                    || !isPromotionSupported(dependencies)) {
+                    return ok(request, { status: 'unavailable' });
+                }
+                const persisted = await resolvePersistedPromotionGrant({
+                    campaignId,
+                    idempotencyKey,
+                    storage: dependencies.storage,
+                    ...(resolvePendingPromotionGrant === undefined
+                        ? {}
+                        : { resolver: resolvePendingPromotionGrant }),
+                });
+                if (persisted.result !== undefined) {
+                    return ok(request, persisted.result);
+                }
+                const existing = promotionGrantsInFlight.get(idempotencyKey);
+                if (existing !== undefined) {
+                    return ok(request, await existing);
+                }
+                const pending = authorizeAndGrantAitPromotionReward({
+                    campaignId,
+                    idempotencyKey,
+                    reward,
+                    dependencies,
+                    ...(authorizePromotionGrant === undefined
+                        ? {}
+                        : { authorizer: authorizePromotionGrant }),
+                });
+                promotionGrantsInFlight.set(idempotencyKey, pending);
+                try {
+                    return ok(request, await pending);
+                }
+                finally {
+                    if (promotionGrantsInFlight.get(idempotencyKey) === pending) {
+                        promotionGrantsInFlight.delete(idempotencyKey);
+                    }
+                }
+            }
+            // 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);
@@ -130,7 +315,7 @@ 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 (!isAitNativeMethodSupported(dependencies.loadFullScreenAd)) {
                     if (!warnedUnsupportedAdPreload) {
                         warnedUnsupportedAdPreload = true;
                         console.warn('AIT full-screen ads are not supported; configured preload is a no-op.', placementId);
@@ -228,6 +413,227 @@ export function createAitHostBridge(options = {}) {
         }
     }
 }
+function getNotificationStatus(topic, templateCodes, subscriptions, dependencies) {
+    if (!templateCodes.has(topic)) {
+        return 'configuration-required';
+    }
+    if (!isAitNativeMethodSupported(dependencies.requestNotificationAgreement)) {
+        return 'unsupported';
+    }
+    return subscriptions.has(topic) ? 'subscribed' : 'not-subscribed';
+}
+function requestAitNotificationAgreement(requestAgreement, templateCode) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let cleanup = () => { };
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            globalThis.clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const timer = globalThis.setTimeout(() => finish('unavailable'), defaultNotificationAgreementTimeoutMs);
+        try {
+            const unregister = requestAgreement({
+                options: { templateCode },
+                onEvent: ({ type }) => {
+                    finish(type === 'agreementRejected' ? 'rejected' : 'subscribed');
+                },
+                onError: () => finish('unavailable'),
+            });
+            cleanup = unregister;
+            if (settled) {
+                cleanup();
+            }
+        }
+        catch {
+            finish('unavailable');
+        }
+    });
+}
+function getPromotionAvailability(campaignId, rewards, authorizer, dependencies) {
+    if (!rewards.has(campaignId) || authorizer === undefined) {
+        return 'configuration-required';
+    }
+    return isPromotionSupported(dependencies) ? 'available' : 'unsupported';
+}
+async function authorizeAndGrantAitPromotionReward(input) {
+    if (input.authorizer === undefined) {
+        return { status: 'unavailable' };
+    }
+    let authorization;
+    try {
+        authorization = await input.authorizer({
+            campaignId: input.campaignId,
+            idempotencyKey: input.idempotencyKey,
+        });
+    }
+    catch (error) {
+        console.warn('AIT promotion grant authorization failed; keeping the claim pending.', input.campaignId, error);
+        return { status: 'pending' };
+    }
+    if (authorization.status !== 'authorized') {
+        return {
+            status: authorization.status === 'pending' ? 'pending' : 'unavailable',
+        };
+    }
+    return grantAitPromotionReward(input.dependencies, input.reward, input.idempotencyKey);
+}
+function isPromotionSupported(dependencies) {
+    return isCapabilitySupported(() => dependencies.isMinVersionSupported({
+        android: minimumPromotionTossAppVersion,
+        ios: minimumPromotionTossAppVersion,
+    }));
+}
+async function grantAitPromotionReward(dependencies, reward, idempotencyKey) {
+    const storageKey = promotionGrantStorageKey(idempotencyKey);
+    await dependencies.storage.setItem(storageKey, JSON.stringify({
+        status: 'pending',
+        pendingSince: new Date().toISOString(),
+    }));
+    try {
+        const response = await dependencies.grantPromotionReward({
+            params: {
+                promotionCode: reward.promotionCode,
+                amount: reward.amount,
+            },
+        });
+        if (isExplicitPromotionFailure(response)) {
+            return clearFailedPromotionGrant(dependencies.storage, storageKey);
+        }
+        if (!isRecord(response)
+            || typeof response.key !== 'string'
+            || response.key.trim().length === 0) {
+            // An undocumented shape is ambiguous after native dispatch. Preserve the
+            // marker so a backend resolver can determine whether a grant happened.
+            return { status: 'pending' };
+        }
+        const result = { status: 'granted', receiptKey: response.key };
+        try {
+            await dependencies.storage.setItem(storageKey, JSON.stringify(result));
+        }
+        catch (error) {
+            console.warn('AIT native promotion receipt could not be cached; keeping it terminal.', reward.promotionCode, error);
+        }
+        return result;
+    }
+    catch {
+        // Keep the pending marker. A provider error after dispatch is ambiguous and
+        // retrying the same promotion blindly can double-grant Toss points.
+        return { status: 'pending' };
+    }
+}
+function isExplicitPromotionFailure(value) {
+    if (value === 'ERROR') {
+        return true;
+    }
+    return isRecord(value)
+        && typeof value.errorCode === 'string'
+        && value.errorCode.trim().length > 0
+        && typeof value.message === 'string';
+}
+async function clearFailedPromotionGrant(storage, storageKey) {
+    try {
+        await storage.removeItem(storageKey);
+        return { status: 'failed' };
+    }
+    catch (error) {
+        console.warn('AIT failed promotion marker could not be cleared; keeping the claim pending.', storageKey, error);
+        return { status: 'pending' };
+    }
+}
+async function resolvePersistedPromotionGrant(input) {
+    const storageKey = promotionGrantStorageKey(input.idempotencyKey);
+    const serialized = await input.storage.getItem(storageKey);
+    if (serialized === null) {
+        return {};
+    }
+    let state;
+    try {
+        state = JSON.parse(serialized);
+    }
+    catch (error) {
+        console.warn('AIT persisted promotion state is unreadable; keeping the claim pending.', input.campaignId, error);
+        return { result: { status: 'pending' } };
+    }
+    if (!isRecord(state)) {
+        console.warn('AIT persisted promotion state is malformed; keeping the claim pending.', input.campaignId);
+        return { result: { status: 'pending' } };
+    }
+    try {
+        if (state.status === 'granted'
+            && typeof state.receiptKey === 'string'
+            && state.receiptKey.trim().length > 0) {
+            return { result: { status: 'granted', receiptKey: state.receiptKey } };
+        }
+        if (state.status === 'pending') {
+            const pendingSince = normalizePendingSince(state.pendingSince);
+            if (pendingSince === undefined) {
+                return { result: { status: 'pending' } };
+            }
+            if (input.resolver === undefined) {
+                return { result: { status: 'pending' } };
+            }
+            let resolution;
+            try {
+                resolution = await input.resolver({
+                    campaignId: input.campaignId,
+                    idempotencyKey: input.idempotencyKey,
+                    pendingSince,
+                });
+            }
+            catch (error) {
+                console.warn('AIT pending promotion grant resolver failed; keeping the claim pending.', input.campaignId, error);
+                return { result: { status: 'pending' } };
+            }
+            if (resolution.status === 'pending') {
+                return { result: { status: 'pending' } };
+            }
+            if (resolution.status === 'granted') {
+                if (typeof resolution.receiptKey !== 'string'
+                    || resolution.receiptKey.trim().length === 0) {
+                    return { result: { status: 'pending' } };
+                }
+                const result = { status: 'granted', receiptKey: resolution.receiptKey };
+                try {
+                    await input.storage.setItem(storageKey, JSON.stringify(result));
+                }
+                catch (error) {
+                    console.warn('AIT reconciled promotion receipt could not be cached; keeping it terminal.', input.campaignId, error);
+                }
+                return { result };
+            }
+            return removeInvalidPersistedPromotionGrant(input.storage, storageKey);
+        }
+        console.warn('AIT persisted promotion state has an unknown status; keeping the claim pending.', input.campaignId);
+        return { result: { status: 'pending' } };
+    }
+    catch (error) {
+        console.warn('AIT persisted promotion state could not be reconciled; keeping the claim pending.', input.campaignId, error);
+        return { result: { status: 'pending' } };
+    }
+}
+async function removeInvalidPersistedPromotionGrant(storage, storageKey) {
+    try {
+        await storage.removeItem(storageKey);
+        return {};
+    }
+    catch {
+        return { result: { status: 'pending' } };
+    }
+}
+function promotionGrantStorageKey(idempotencyKey) {
+    return `${promotionGrantStoragePrefix}${encodeURIComponent(idempotencyKey)}`;
+}
+function normalizePendingSince(value) {
+    if (typeof value !== 'string' || value.length === 0) {
+        return undefined;
+    }
+    return Number.isFinite(Date.parse(value)) ? value : undefined;
+}
 export async function shareIntent(payload, dependencies) {
     const intent = readPayloadRecord(payload);
     if (typeof intent.text !== 'string' || typeof intent.deepLink !== 'string') {
@@ -606,9 +1012,833 @@ 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 isAitNativeMethodSupported(method) {
+    return isCapabilitySupported(() => method.isSupported?.() === true);
 }
 function isCapabilitySupported(check) {
     try {
@@ -655,6 +1885,32 @@ function normalizeAdPlacementTypes(input) {
         .map(([placementId, type]) => [placementId.trim(), type])
         .filter(([placementId]) => placementId.length > 0));
 }
+function normalizePromotionRewards(input) {
+    const rewards = new Map();
+    for (const [rawCampaignId, rawReward] of Object.entries(input ?? {})) {
+        const campaignId = rawCampaignId.trim();
+        const promotionCode = rawReward.promotionCode.trim();
+        if (campaignId.length === 0 || promotionCode.length === 0) {
+            continue;
+        }
+        if (!Number.isSafeInteger(rawReward.amount) || rawReward.amount <= 0) {
+            console.warn(`AIT promotion amount must be a positive safe integer; disabling campaign: ${campaignId}`);
+            continue;
+        }
+        rewards.set(campaignId, { promotionCode, amount: rawReward.amount });
+    }
+    return rewards;
+}
+function normalizeNotificationTemplateCodes(input) {
+    const templateCodes = new Map();
+    for (const topic of notificationTopics) {
+        const templateCode = input?.[topic]?.trim();
+        if (templateCode !== undefined && templateCode.length > 0) {
+            templateCodes.set(topic, templateCode);
+        }
+    }
+    return templateCodes;
+}
 function normalizeAppName(value) {
     const normalized = value.trim();
     if (!/^[A-Za-z0-9-]+$/u.test(normalized)) {
@@ -674,6 +1930,13 @@ function normalizeDisplayStartTimeout(value) {
 function normalizeMaximumDisplayTimeout(value) {
     return normalizePositiveTimeout(value, defaultAdMaximumDisplayMs, 'AIT ad maximum display 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;
@@ -701,6 +1964,45 @@ 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) {
+        throw new TypeError('AIT promotion idempotencyKey must contain 1 to 256 characters.');
+    }
+    return value;
+}
+function readCampaignId(payload) {
+    const value = readPayloadRecord(payload).campaignId;
+    if (typeof value !== 'string' || value.length === 0 || value.length > 128) {
+        throw new TypeError('AIT promotion campaignId must contain 1 to 128 characters.');
+    }
+    return value;
+}
+function readNotificationTopic(payload) {
+    const value = readPayloadRecord(payload).topic;
+    if (typeof value !== 'string' || !notificationTopics.has(value)) {
+        throw new TypeError('AIT notification topic is invalid.');
+    }
+    return value;
+}
 function readFiniteScore(payload) {
     const score = readPayloadRecord(payload).score;
     if (typeof score !== 'number' || !Number.isFinite(score)) {