@mpgd/adapter-ait 0.4.3 → 0.5.0

package/dist/ad-config.d.ts

@@ -0,0 +1,5 @@
+export interface AitAdBridgeConfig {
+  readonly adGroupIds: Readonly<Record<string, string>>;
+  readonly adPlacementTypes: Readonly<Record<string, 'rewarded' | 'interstitial'>>;
+}
+export declare function extractAitAdBridgeConfig(input: unknown, sourceLabel?: string): AitAdBridgeConfig;

package/dist/ad-config.js

@@ -0,0 +1,33 @@
+export function extractAitAdBridgeConfig(input, sourceLabel = 'ad placements') {
+    if (!isRecord(input) || !Array.isArray(input.placements)) {
+        throw new Error(`AIT ad placements are invalid: ${sourceLabel}`);
+    }
+    const placements = input.placements;
+    const adGroupIds = {};
+    const adPlacementTypes = {};
+    const placementIds = new Set();
+    for (const [placementIndex, placement] of placements.entries()) {
+        if (!isRecord(placement)
+            || typeof placement.id !== 'string'
+            || (placement.type !== 'rewarded' && placement.type !== 'interstitial')) {
+            throw new Error(`AIT ad placement entry at index ${placementIndex} is invalid: ${sourceLabel}`);
+        }
+        if (placementIds.has(placement.id)) {
+            throw new Error(`Duplicate AIT ad placement ID "${placement.id}" at index `
+                + `${placementIndex}: ${sourceLabel}`);
+        }
+        placementIds.add(placement.id);
+        const platformPlacementIds = placement.platformPlacementIds;
+        const adGroupId = isRecord(platformPlacementIds) && typeof platformPlacementIds.ait === 'string'
+            ? platformPlacementIds.ait.trim()
+            : '';
+        if (adGroupId.length > 0) {
+            adGroupIds[placement.id] = adGroupId;
+            adPlacementTypes[placement.id] = placement.type;
+        }
+    }
+    return { adGroupIds, adPlacementTypes };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/host.d.ts

@@ -0,0 +1,38 @@
+import { getTossShareLink, isMinVersionSupported, loadFullScreenAd, openGameCenterLeaderboard, share, showFullScreenAd, Storage, submitGameCenterLeaderBoardScore } from '@apps-in-toss/web-framework';
+import type { ShareResult } from '@mpgd/platform';
+import type { GamePlatformBridge } from './index.js';
+export type AitIdentityProvider = () => Promise<unknown>;
+export interface AitHostDependencies {
+  readonly identityProvider: AitIdentityProvider;
+  readonly storage: Pick<typeof Storage, 'getItem' | 'setItem'>;
+  readonly getTossShareLink: typeof getTossShareLink;
+  readonly share: typeof share;
+  readonly isMinVersionSupported: typeof isMinVersionSupported;
+  readonly loadFullScreenAd: typeof loadFullScreenAd;
+  readonly showFullScreenAd: typeof showFullScreenAd;
+  readonly openGameCenterLeaderboard: typeof openGameCenterLeaderboard;
+  readonly submitGameCenterLeaderBoardScore: typeof submitGameCenterLeaderBoardScore;
+}
+export interface InstallAitHostBridgeOptions {
+  readonly appName?: string;
+  readonly adGroupIds?: Readonly<Record<string, string>>;
+  readonly adPlacementTypes?: Readonly<Record<string, 'rewarded' | 'interstitial'>>;
+  /** Maximum total wait for the native show request before display is observed. */
+  readonly adTimeoutMs?: number;
+  /** Maximum wait to acquire the process-wide native full-screen load slot. */
+  readonly adLoadQueueTimeoutMs?: number;
+  /** Upper bound for the requested-to-display portion of the total show timeout. */
+  readonly adDisplayStartTimeoutMs?: number;
+  /** Last-resort cleanup when the native SDK omits its terminal display callback. */
+  readonly adMaximumDisplayMs?: number;
+  readonly dependencies?: Partial<AitHostDependencies>;
+}
+export declare function installAitHostBridge(options?: InstallAitHostBridgeOptions): GamePlatformBridge;
+export declare function createAitHostBridge(options?: InstallAitHostBridgeOptions): GamePlatformBridge;
+interface AitShareDependencies {
+  readonly appName: string;
+  readonly getTossShareLink: typeof getTossShareLink;
+  readonly share: typeof share;
+}
+export declare function shareIntent(payload: unknown, dependencies: AitShareDependencies): Promise<ShareResult>;
+export {};

package/dist/host.js

@@ -0,0 +1,730 @@
+import { getTossShareLink, getUserKeyForGame, isMinVersionSupported, loadFullScreenAd, openGameCenterLeaderboard, 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;
+const invalidBridgeRequestId = 'ait-invalid-request';
+const rewardedAdEvidenceSchema = 'apps-in-toss.rewarded-ad.callback.v1';
+const launchEntries = new Set([
+    'home',
+    'daily',
+    'practice',
+    'free-play',
+    'continue',
+    'leaderboard',
+    'friend-challenge',
+]);
+const defaultDependencies = {
+    identityProvider: getUserKeyForGame,
+    storage: Storage,
+    getTossShareLink,
+    share,
+    isMinVersionSupported,
+    loadFullScreenAd,
+    showFullScreenAd,
+    openGameCenterLeaderboard,
+    submitGameCenterLeaderBoardScore,
+};
+export function installAitHostBridge(options = {}) {
+    const bridge = createAitHostBridge(options);
+    globalThis.__GAME_PLATFORM_BRIDGE__ = bridge;
+    return bridge;
+}
+export function createAitHostBridge(options = {}) {
+    const dependencies = { ...defaultDependencies, ...options.dependencies };
+    const appName = normalizeAppName(options.appName ?? 'mpgd-kit');
+    const adGroupIds = normalizeAdGroupIds(options.adGroupIds);
+    const adPlacementTypes = normalizeAdPlacementTypes(options.adPlacementTypes);
+    const loadedAdGroupIds = new Set();
+    const loadingAdGroups = new Map();
+    const activeAdGroupIds = new Set();
+    let warnedUnsupportedAdPreload = false;
+    const adTimeoutMs = normalizeTimeout(options.adTimeoutMs);
+    const adLoadQueueTimeoutMs = normalizeLoadQueueTimeout(options.adLoadQueueTimeoutMs);
+    const adDisplayStartTimeoutMs = normalizeDisplayStartTimeout(options.adDisplayStartTimeoutMs);
+    const adMaximumDisplayMs = normalizeMaximumDisplayTimeout(options.adMaximumDisplayMs);
+    const adLoadCoordinator = {
+        active: undefined,
+        waitTimeoutMs: adLoadQueueTimeoutMs,
+    };
+    return {
+        async request(input) {
+            try {
+                return await handleRequest(parseBridgeRequest(input));
+            }
+            catch (error) {
+                return createBridgeError(readBridgeRequestId(input), 'AIT_BRIDGE_REQUEST_FAILED', errorMessage(error), true);
+            }
+        },
+    };
+    async function handleRequest(request) {
+        switch (request.method) {
+            case 'runtime.getCapabilities': {
+                const adsSupported = dependencies.loadFullScreenAd.isSupported()
+                    && dependencies.showFullScreenAd.isSupported();
+                const rewardedAds = adsSupported
+                    && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'rewarded');
+                const interstitialAds = adsSupported
+                    && hasConfiguredAdType(adGroupIds, adPlacementTypes, 'interstitial');
+                return ok(request, {
+                    nativeIap: false,
+                    nativeAds: rewardedAds || interstitialAds,
+                    rewardedAds,
+                    interstitialAds,
+                    nativeLeaderboard: isGameCenterSupported(dependencies),
+                    achievements: false,
+                    cloudSave: false,
+                    socialShare: true,
+                    haptics: false,
+                    localizedContent: true,
+                });
+            }
+            case 'identity.getPlayer': {
+                const player = await resolveAitIdentity(dependencies.identityProvider);
+                return player === null
+                    ? createBridgeError(request.id, 'AIT_IDENTITY_UNAVAILABLE', 'AIT user identity is unavailable.')
+                    : ok(request, player);
+            }
+            case 'identity.getSession': {
+                const player = await resolveAitIdentity(dependencies.identityProvider);
+                return ok(request, player === null
+                    ? { identityLevel: 'guest', trustLevel: 'local' }
+                    : {
+                        identityLevel: 'platform-anonymous',
+                        playerId: player.playerId,
+                        trustLevel: 'platform-asserted',
+                    });
+            }
+            case 'identity.requestUpgrade':
+                return ok(request, { status: 'unavailable', reloadExpected: false });
+            case 'presentation.getLaunchIntent':
+                return ok(request, getLaunchIntent());
+            case 'presentation.requestGameSurface':
+                return ok(request, 'already-fullscreen');
+            case 'share.share':
+                return ok(request, await shareIntent(request.payload, {
+                    appName,
+                    getTossShareLink: dependencies.getTossShareLink,
+                    share: dependencies.share,
+                }));
+            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.
+            case 'commerce.getProducts':
+                return ok(request, []);
+            case 'commerce.purchase':
+                return ok(request, { status: 'failed', entitlementIds: [] });
+            case 'commerce.restore':
+                return ok(request, { restoredEntitlements: [] });
+            case 'commerce.getEntitlements':
+                return ok(request, []);
+            case 'ads.preload': {
+                const placementId = readPlacementId(request.payload);
+                const adGroupId = adGroupIds.get(placementId);
+                const placementType = adPlacementTypes.get(placementId);
+                if (adGroupId === undefined || placementType === undefined) {
+                    return createBridgeError(request.id, 'AIT_AD_UNAVAILABLE', `AIT ad placement is unavailable: ${placementId}`);
+                }
+                if (!dependencies.loadFullScreenAd.isSupported()) {
+                    if (!warnedUnsupportedAdPreload) {
+                        warnedUnsupportedAdPreload = true;
+                        console.warn('AIT full-screen ads are not supported; configured preload is a no-op.', placementId);
+                    }
+                    return ok(request, {});
+                }
+                await preloadAdGroupWithDiagnostics(dependencies, adGroupId, loadedAdGroupIds, loadingAdGroups, adLoadCoordinator, adTimeoutMs, placementType);
+                return ok(request, {});
+            }
+            case 'ads.showRewarded': {
+                const placementId = readPlacementId(request.payload);
+                const adGroupId = adGroupIds.get(placementId);
+                if (adGroupId === undefined
+                    || adPlacementTypes.get(placementId) !== 'rewarded'
+                    || !dependencies.loadFullScreenAd.isSupported()
+                    || !dependencies.showFullScreenAd.isSupported()) {
+                    return ok(request, { status: 'unavailable', rewardGranted: false });
+                }
+                const shown = await withLoadedAdSlot(dependencies, adGroupId, loadedAdGroupIds, loadingAdGroups, adLoadCoordinator, activeAdGroupIds, adTimeoutMs, 'rewarded', async () => {
+                    const correlationId = readIdempotencyKey(request.payload, request.id);
+                    const result = await showRewardedAd(dependencies, adGroupId, adTimeoutMs, adDisplayStartTimeoutMs, adMaximumDisplayMs);
+                    return result.rewardGranted
+                        ? {
+                            ...result,
+                            // game-services forwards this as platformImpressionId and compares it
+                            // with the native callback correlationId during authority verification.
+                            ledgerEntryId: correlationId,
+                            evidence: {
+                                schema: rewardedAdEvidenceSchema,
+                                payload: {
+                                    event: 'user-earned-reward',
+                                    correlationId,
+                                    placementId: adGroupId,
+                                },
+                            },
+                        }
+                        : result;
+                });
+                if (!shown.acquired) {
+                    return ok(request, { status: 'unavailable', rewardGranted: false });
+                }
+                return ok(request, shown.value);
+            }
+            case 'ads.showInterstitial': {
+                const placementId = readPlacementId(request.payload);
+                const adGroupId = adGroupIds.get(placementId);
+                if (adGroupId === undefined
+                    || adPlacementTypes.get(placementId) !== 'interstitial'
+                    || !dependencies.loadFullScreenAd.isSupported()
+                    || !dependencies.showFullScreenAd.isSupported()) {
+                    return ok(request, { status: 'unavailable' });
+                }
+                const showInterstitial = () => showInterstitialAd(dependencies, adGroupId, adTimeoutMs, adDisplayStartTimeoutMs, adMaximumDisplayMs);
+                const shown = await withLoadedAdSlot(dependencies, adGroupId, loadedAdGroupIds, loadingAdGroups, adLoadCoordinator, activeAdGroupIds, adTimeoutMs, 'interstitial', showInterstitial);
+                return ok(request, shown.acquired ? shown.value : { status: 'unavailable' });
+            }
+            case 'leaderboard.submitScore': {
+                if (!isGameCenterSupported(dependencies)) {
+                    return ok(request, { submitted: false });
+                }
+                const score = readFiniteScore(request.payload);
+                const result = await dependencies.submitGameCenterLeaderBoardScore({
+                    score: String(score),
+                });
+                return ok(request, { submitted: result?.statusCode === 'SUCCESS' });
+            }
+            case 'leaderboard.open': {
+                if (!isGameCenterSupported(dependencies)) {
+                    return ok(request, {});
+                }
+                dispatchAitLifecycleEvent('pause');
+                try {
+                    await dependencies.openGameCenterLeaderboard();
+                }
+                finally {
+                    dispatchAitLifecycleEvent('resume');
+                }
+                return ok(request, {});
+            }
+            case 'storage.load': {
+                const key = readStorageKey(request.payload);
+                const serialized = await dependencies.storage.getItem(key);
+                return ok(request, decodeStoredValue(serialized));
+            }
+            case 'storage.save': {
+                const key = readStorageKey(request.payload);
+                const value = readPayloadRecord(request.payload).value;
+                const serialized = JSON.stringify(value);
+                if (serialized === undefined) {
+                    throw new TypeError('Storage values must be JSON-serializable.');
+                }
+                await dependencies.storage.setItem(key, serialized);
+                return ok(request, {});
+            }
+            default:
+                return createBridgeError(request.id, 'UNSUPPORTED_METHOD', `Unsupported AIT bridge method: ${request.method}`);
+        }
+    }
+}
+export async function shareIntent(payload, dependencies) {
+    const intent = readPayloadRecord(payload);
+    if (typeof intent.text !== 'string' || typeof intent.deepLink !== 'string') {
+        return { status: 'unavailable' };
+    }
+    const deepLink = toAitDeepLink(intent.deepLink, dependencies.appName);
+    if (deepLink === undefined) {
+        return { status: 'unavailable' };
+    }
+    try {
+        const tossLink = await dependencies.getTossShareLink(deepLink, typeof intent.previewImageUrl === 'string' && intent.previewImageUrl.startsWith('https://')
+            ? intent.previewImageUrl
+            : undefined);
+        await dependencies.share({ message: `${intent.text}\n${tossLink}` });
+        return { status: 'shared', completion: 'presented' };
+    }
+    catch (error) {
+        return isAbortError(error) ? { status: 'cancelled' } : { status: 'unavailable' };
+    }
+}
+async function resolveAitIdentity(provider) {
+    let result;
+    try {
+        result = await provider();
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(result) || result.type !== 'HASH') {
+        return null;
+    }
+    const hash = typeof result.hash === 'string' ? result.hash.trim() : '';
+    return hash.length === 0 ? null : { playerId: hash };
+}
+async function preloadAdGroup(dependencies, adGroupId, loaded, loading, coordinator, timeoutMs) {
+    if (loaded.has(adGroupId)) {
+        return;
+    }
+    const existing = loading.get(adGroupId);
+    if (existing !== undefined) {
+        await existing;
+        return;
+    }
+    const startNativeLoad = () => new Promise((resolve, reject) => {
+        let cleanup = () => { };
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            globalThis.clearTimeout(timer);
+            cleanup();
+            if (error === undefined) {
+                loaded.add(adGroupId);
+                resolve();
+            }
+            else {
+                reject(error);
+            }
+        };
+        const timer = globalThis.setTimeout(() => finish(new Error(`Timed out loading AIT ad group ${adGroupId}.`)), timeoutMs);
+        try {
+            const unregister = dependencies.loadFullScreenAd({
+                options: { adGroupId },
+                onEvent: (event) => {
+                    if (event.type === 'loaded') {
+                        finish();
+                    }
+                },
+                onError: finish,
+            });
+            cleanup = unregister;
+            if (settled) {
+                cleanup();
+            }
+        }
+        catch (error) {
+            finish(error);
+        }
+    });
+    const pending = runSerializedAdLoad(coordinator, adGroupId, startNativeLoad);
+    loading.set(adGroupId, pending);
+    try {
+        await pending;
+    }
+    finally {
+        // Clean up this load attempt. The identity check also protects a future retry
+        // implementation from deleting a replacement promise.
+        if (loading.get(adGroupId) === pending) {
+            loading.delete(adGroupId);
+        }
+    }
+}
+async function runSerializedAdLoad(coordinator, adGroupId, startNativeLoad) {
+    const waitDeadline = Date.now() + coordinator.waitTimeoutMs;
+    while (coordinator.active !== undefined) {
+        const remainingWaitMs = waitDeadline - Date.now();
+        if (remainingWaitMs <= 0) {
+            throw new Error(`Timed out waiting for the AIT ad load slot: ${adGroupId} (queue deadline exceeded).`);
+        }
+        await waitForAdLoadSettlement(coordinator.active.promise, remainingWaitMs, adGroupId);
+    }
+    // Some deployed Toss runtimes lose callbacks when different groups begin
+    // loading together. Acquire the process-wide native boundary synchronously;
+    // the actual native load still receives its complete timeout budget.
+    const pending = startNativeLoad();
+    coordinator.active = { promise: pending };
+    try {
+        await pending;
+    }
+    finally {
+        if (coordinator.active?.promise === pending) {
+            coordinator.active = undefined;
+        }
+    }
+}
+function waitForAdLoadSettlement(active, timeoutMs, adGroupId) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            globalThis.clearTimeout(timer);
+            if (error === undefined) {
+                resolve();
+            }
+            else {
+                reject(error);
+            }
+        };
+        const timer = globalThis.setTimeout(() => finish(new Error(`Timed out waiting for the AIT ad load slot: ${adGroupId} (active load wait expired).`)), timeoutMs);
+        void active.then(() => finish(), () => finish());
+    });
+}
+async function acquireLoadedAdSlot(dependencies, adGroupId, loaded, loading, coordinator, active, timeoutMs, placementType) {
+    if (active.has(adGroupId)) {
+        return false;
+    }
+    const loadedSuccessfully = await preloadAdGroupWithDiagnostics(dependencies, adGroupId, loaded, loading, coordinator, timeoutMs, placementType);
+    if (!loadedSuccessfully) {
+        return false;
+    }
+    // Re-check after the asynchronous load so concurrent callers cannot consume
+    // or display the same native ad slot twice.
+    if (active.has(adGroupId) || !consumeLoadedAd(adGroupId, loaded)) {
+        return false;
+    }
+    active.add(adGroupId);
+    return true;
+}
+async function preloadAdGroupWithDiagnostics(dependencies, adGroupId, loaded, loading, coordinator, timeoutMs, placementType) {
+    // The first caller enters preloadAdGroup synchronously and publishes its promise
+    // before yielding. Remember that ownership so concurrent waiters do not emit the
+    // same diagnostic for one native load failure.
+    const ownsLoadAttempt = !loaded.has(adGroupId) && !loading.has(adGroupId);
+    try {
+        await preloadAdGroup(dependencies, adGroupId, loaded, loading, coordinator, timeoutMs);
+        return true;
+    }
+    catch (error) {
+        // Preloading is opportunistic. A later show request may retry, so keep
+        // gameplay available while retaining one diagnostic per native attempt.
+        if (ownsLoadAttempt) {
+            console.warn(`Failed to preload ${placementType} AIT ad group.`, adGroupId, error);
+        }
+        return false;
+    }
+}
+async function withLoadedAdSlot(dependencies, adGroupId, loaded, loading, coordinator, active, timeoutMs, placementType, display) {
+    const acquired = await acquireLoadedAdSlot(dependencies, adGroupId, loaded, loading, coordinator, active, timeoutMs, placementType);
+    if (!acquired) {
+        return { acquired: false };
+    }
+    try {
+        return { acquired: true, value: await display() };
+    }
+    finally {
+        active.delete(adGroupId);
+    }
+}
+async function showRewardedAd(dependencies, adGroupId, timeoutMs, displayStartTimeoutMs, maximumDisplayMs) {
+    let rewardGranted = false;
+    const status = await showAd(dependencies, adGroupId, timeoutMs, displayStartTimeoutMs, maximumDisplayMs, (eventType) => {
+        if (eventType === 'userEarnedReward') {
+            rewardGranted = true;
+        }
+    });
+    let resultStatus;
+    if (status === 'shown' && rewardGranted) {
+        resultStatus = 'completed';
+    }
+    else if (status === 'failed') {
+        resultStatus = 'failed';
+    }
+    else {
+        resultStatus = 'skipped';
+    }
+    return {
+        status: resultStatus,
+        rewardGranted,
+    };
+}
+async function showInterstitialAd(dependencies, adGroupId, timeoutMs, displayStartTimeoutMs, maximumDisplayMs) {
+    const status = await showAd(dependencies, adGroupId, timeoutMs, displayStartTimeoutMs, maximumDisplayMs);
+    return { status: status === 'failed' ? 'skipped' : status };
+}
+function showAd(dependencies, adGroupId, timeoutMs, displayStartTimeoutMs, maximumDisplayMs, observe) {
+    dispatchAitLifecycleEvent('pause');
+    return new Promise((resolve) => {
+        const startedAt = Date.now();
+        let cleanup = () => { };
+        let settled = false;
+        let maximumDisplayTimeoutArmed = false;
+        let adTimer;
+        const clearAdTimer = () => {
+            if (adTimer !== undefined) {
+                globalThis.clearTimeout(adTimer);
+                adTimer = undefined;
+            }
+        };
+        const finish = (status) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearAdTimer();
+            cleanup();
+            dispatchAitLifecycleEvent('resume');
+            resolve(status);
+        };
+        const armDisplayStartTimeout = () => {
+            clearAdTimer();
+            const elapsedMs = Math.max(0, Date.now() - startedAt);
+            const remainingMs = Math.max(0, timeoutMs - elapsedMs);
+            adTimer = globalThis.setTimeout(() => finish('failed'), Math.min(displayStartTimeoutMs, remainingMs));
+        };
+        const armMaximumDisplayTimeout = () => {
+            if (maximumDisplayTimeoutArmed) {
+                return;
+            }
+            maximumDisplayTimeoutArmed = true;
+            clearAdTimer();
+            adTimer = globalThis.setTimeout(() => {
+                console.warn('AIT full-screen ad omitted its terminal callback; recovering the game lifecycle.', adGroupId);
+                finish('shown');
+            }, maximumDisplayMs);
+        };
+        const failShow = (error) => {
+            if (settled) {
+                return;
+            }
+            console.warn('Failed to show AIT full-screen ad.', adGroupId, error ?? 'unknown native error');
+            finish('failed');
+        };
+        adTimer = globalThis.setTimeout(() => finish('failed'), timeoutMs);
+        try {
+            const unregister = dependencies.showFullScreenAd({
+                options: { adGroupId },
+                onEvent: (event) => {
+                    observe?.(event.type);
+                    switch (event.type) {
+                        case 'requested':
+                            armDisplayStartTimeout();
+                            break;
+                        case 'show':
+                        case 'impression':
+                        case 'clicked':
+                        case 'userEarnedReward':
+                            // Native terminal callbacks remain authoritative. A long, one-shot
+                            // recovery timeout prevents a broken SDK callback from deadlocking
+                            // the game forever without treating ordinary end-card dwell as failure.
+                            armMaximumDisplayTimeout();
+                            break;
+                        case 'dismissed':
+                            finish('shown');
+                            break;
+                        case 'failedToShow':
+                            finish('failed');
+                            break;
+                    }
+                },
+                onError: failShow,
+            });
+            cleanup = unregister;
+            if (settled) {
+                cleanup();
+            }
+        }
+        catch (error) {
+            failShow(error);
+        }
+    });
+}
+function getLaunchIntent() {
+    const params = inboundSearchParams();
+    const challengeToken = nonEmptyParam(params.get('challengeToken'));
+    const puzzleId = nonEmptyParam(params.get('puzzleId'));
+    const requestedEntry = nonEmptyParam(params.get('entry'));
+    let entry;
+    if (requestedEntry !== undefined && launchEntries.has(requestedEntry)) {
+        entry = requestedEntry;
+    }
+    else if (challengeToken === undefined) {
+        entry = 'home';
+    }
+    else {
+        entry = 'friend-challenge';
+    }
+    return {
+        entry,
+        ...(puzzleId === undefined ? {} : { puzzleId }),
+        ...(challengeToken === undefined ? {} : { referralToken: challengeToken }),
+    };
+}
+function readInboundShare() {
+    const params = inboundSearchParams();
+    const puzzleId = nonEmptyParam(params.get('puzzleId'));
+    const challengeToken = nonEmptyParam(params.get('challengeToken'));
+    return puzzleId === undefined && challengeToken === undefined
+        ? null
+        : {
+            ...(puzzleId === undefined ? {} : { puzzleId }),
+            ...(challengeToken === undefined ? {} : { challengeToken }),
+        };
+}
+function inboundSearchParams() {
+    const params = new URLSearchParams(globalThis.location?.search ?? '');
+    const nested = params.get('queryParams');
+    if (nested !== null) {
+        try {
+            const parsed = JSON.parse(nested);
+            if (isRecord(parsed)) {
+                for (const [key, value] of Object.entries(parsed)) {
+                    if (typeof value === 'string' && !params.has(key)) {
+                        params.set(key, value);
+                    }
+                }
+            }
+        }
+        catch {
+            // Deep-link payloads are untrusted; malformed nested query data is ignored.
+        }
+    }
+    return params;
+}
+function toAitDeepLink(input, appName) {
+    if (input.startsWith('//')) {
+        return undefined;
+    }
+    if (input.startsWith('/')) {
+        const baseUrl = new URL('https://mpgd.invalid');
+        const parsed = new URL(input, baseUrl);
+        return parsed.origin === baseUrl.origin
+            ? `intoss://${appName}${parsed.pathname}${parsed.search}${parsed.hash}`
+            : undefined;
+    }
+    try {
+        const parsed = new URL(input);
+        if (parsed.protocol === 'intoss:') {
+            return parsed.hostname === appName ? input : undefined;
+        }
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:'
+            ? `intoss://${appName}${parsed.pathname}${parsed.search}${parsed.hash}`
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isGameCenterSupported(dependencies) {
+    return dependencies.isMinVersionSupported({ android: '5.221.0', ios: '5.221.0' });
+}
+function normalizeAdGroupIds(input) {
+    return new Map(Object.entries(input ?? {})
+        .map(([placementId, adGroupId]) => [placementId.trim(), adGroupId.trim()])
+        .filter(([placementId, adGroupId]) => placementId.length > 0 && adGroupId.length > 0));
+}
+function consumeLoadedAd(adGroupId, loaded) {
+    if (!loaded.has(adGroupId)) {
+        return false;
+    }
+    loaded.delete(adGroupId);
+    return true;
+}
+function decodeStoredValue(serialized) {
+    if (serialized === null) {
+        return { __mpgdBridgeProtocol: bridgeStorageLoadProtocol, found: false };
+    }
+    try {
+        return {
+            __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
+            found: true,
+            value: JSON.parse(serialized),
+        };
+    }
+    catch {
+        // Malformed native state is treated as absent so the game can recover with
+        // its versioned defaults instead of entering a permanent load-error loop.
+        return { __mpgdBridgeProtocol: bridgeStorageLoadProtocol, found: false };
+    }
+}
+function hasConfiguredAdType(adGroupIds, adPlacementTypes, type) {
+    return [...adGroupIds.keys()].some((placementId) => adPlacementTypes.get(placementId) === type);
+}
+function normalizeAdPlacementTypes(input) {
+    return new Map(Object.entries(input ?? {})
+        .map(([placementId, type]) => [placementId.trim(), type])
+        .filter(([placementId]) => placementId.length > 0));
+}
+function normalizeAppName(value) {
+    const normalized = value.trim();
+    if (!/^[A-Za-z0-9-]+$/u.test(normalized)) {
+        throw new Error('AIT appName must contain only letters, numbers, and hyphens.');
+    }
+    return normalized;
+}
+function normalizeTimeout(value) {
+    return normalizePositiveTimeout(value, defaultAdTimeoutMs, 'AIT ad timeout must be a positive finite number.');
+}
+function normalizeLoadQueueTimeout(value) {
+    return normalizePositiveTimeout(value, defaultAdLoadQueueTimeoutMs, 'AIT ad load queue timeout must be a positive finite number.');
+}
+function normalizeDisplayStartTimeout(value) {
+    return normalizePositiveTimeout(value, defaultAdDisplayStartTimeoutMs, 'AIT ad display start timeout must be a positive finite number.');
+}
+function normalizeMaximumDisplayTimeout(value) {
+    return normalizePositiveTimeout(value, defaultAdMaximumDisplayMs, 'AIT ad maximum display timeout must be a positive finite number.');
+}
+function normalizePositiveTimeout(value, defaultValue, message) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(message);
+    }
+    return value;
+}
+function readStorageKey(payload) {
+    const key = readPayloadRecord(payload).key;
+    if (typeof key !== 'string' || key.length === 0) {
+        throw new TypeError('AIT storage key must be a non-empty string.');
+    }
+    return key;
+}
+function readPlacementId(payload) {
+    const placementId = readPayloadRecord(payload).placementId;
+    if (typeof placementId !== 'string' || placementId.length === 0) {
+        throw new TypeError('AIT ad placementId must be a non-empty string.');
+    }
+    return placementId;
+}
+function readIdempotencyKey(payload, fallback) {
+    const value = readPayloadRecord(payload).idempotencyKey;
+    return typeof value === 'string' && value.length > 0 ? value : fallback;
+}
+function readFiniteScore(payload) {
+    const score = readPayloadRecord(payload).score;
+    if (typeof score !== 'number' || !Number.isFinite(score)) {
+        throw new TypeError('AIT leaderboard score must be a finite number.');
+    }
+    return score;
+}
+function readPayloadRecord(payload) {
+    return isRecord(payload) ? payload : {};
+}
+function parseBridgeRequest(input) {
+    // The production host deliberately accepts only the current bridge protocol.
+    // Legacy partial requests are rejected rather than silently inventing metadata.
+    return assertBridgeRequest(input);
+}
+function readBridgeRequestId(input) {
+    if (!isRecord(input) || typeof input.id !== 'string' || input.id.length === 0) {
+        return invalidBridgeRequestId;
+    }
+    return input.id;
+}
+function ok(request, data) {
+    return { id: request.id, ok: true, data };
+}
+function createBridgeError(id, code, message, retryable = false) {
+    return { id, ok: false, error: { code, message, retryable } };
+}
+function nonEmptyParam(value) {
+    return value === null || value.length === 0 ? undefined : value;
+}
+function isAbortError(error) {
+    return isRecord(error) && error.name === 'AbortError';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { BridgeRequest, BridgeResponse } from '@mpgd/bridge';
+import { type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
 import type { PlatformGateway } from '@mpgd/platform';
 export interface GamePlatformBridge {
   request(input: BridgeRequest): Promise<BridgeResponse>;
@@ -9,4 +9,5 @@ export declare function createAitPlatformGateway(input: {
   readonly bridge?: GamePlatformBridge;
   readonly fallbackBridge?: GamePlatformBridge;
 }): PlatformGateway;
+export { aitLifecyclePauseEvent, aitLifecycleResumeEvent, createAitLifecycleAdapter, dispatchAitLifecycleEvent, } from './lifecycle.js';
 export declare function createAitSandboxBridge(): GamePlatformBridge;

package/dist/index.js

@@ -1,3 +1,5 @@
+import { bridgeStorageLoadProtocol, decodeBridgeStorageLoadData, } from '@mpgd/bridge';
+import { createAitLifecycleAdapter } from './lifecycle.js';
 export function createAitPlatformGateway(input) {
     async function request(method, payload) {
         const bridge = input.bridge ?? getBridge() ?? input.fallbackBridge;
@@ -22,7 +24,9 @@ export function createAitPlatformGateway(input) {
     }
     return {
         target: 'ait',
-        getCapabilities: () => request('runtime.getCapabilities', {}),
+        async getCapabilities() {
+            return { ...await request('runtime.getCapabilities', {}) };
+        },
         identity: {
             getPlayer: () => request('identity.getPlayer', {}),
             getSession: () => request('identity.getSession', {}),
@@ -55,23 +59,16 @@ export function createAitPlatformGateway(input) {
             submitScore: (payload) => request('leaderboard.submitScore', payload),
             open: (payload) => request('leaderboard.open', payload ?? {}),
         },
-        lifecycle: {
-            onPause() {
-                return () => { };
-            },
-            onResume() {
-                return () => { };
-            },
-        },
+        lifecycle: createAitLifecycleAdapter(),
         storage: {
             async load(payload) {
-                const value = await request('storage.load', payload);
-                return value === null ? null : { value };
+                return decodeBridgeStorageLoadData(await request('storage.load', payload));
             },
             save: (payload) => request('storage.save', payload),
         },
     };
 }
+export { aitLifecyclePauseEvent, aitLifecycleResumeEvent, createAitLifecycleAdapter, dispatchAitLifecycleEvent, } from './lifecycle.js';
 function getBridge() {
     return globalThis.__GAME_PLATFORM_BRIDGE__;
 }
@@ -170,12 +167,18 @@ export function createAitSandboxBridge() {
                     return ok(input, {});
                 case 'storage.load': {
                     const payload = input.payload;
-                    return ok(input, payload.key === undefined ? null : (storage.get(payload.key) ?? null));
+                    const found = payload.key !== undefined && storage.has(payload.key);
+                    const value = found && payload.key !== undefined
+                        ? cloneJsonValue(storage.get(payload.key))
+                        : undefined;
+                    return ok(input, !found
+                        ? { __mpgdBridgeProtocol: bridgeStorageLoadProtocol, found: false }
+                        : { __mpgdBridgeProtocol: bridgeStorageLoadProtocol, found: true, value });
                 }
                 case 'storage.save': {
                     const payload = input.payload;
                     if (payload.key !== undefined) {
-                        storage.set(payload.key, payload.value);
+                        storage.set(payload.key, cloneJsonValue(payload.value));
                     }
                     return ok(input, {});
                 }
@@ -193,6 +196,13 @@ export function createAitSandboxBridge() {
         },
     };
 }
+function cloneJsonValue(input) {
+    const serialized = JSON.stringify(input);
+    if (serialized === undefined) {
+        throw new Error('AIT sandbox storage values must be JSON-serializable.');
+    }
+    return JSON.parse(serialized);
+}
 function ok(input, data) {
     return {
         id: input.id,

package/dist/lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { LifecycleAdapter } from '@mpgd/platform';
+export declare const aitLifecyclePauseEvent = "mpgd:ait:pause";
+export declare const aitLifecycleResumeEvent = "mpgd:ait:resume";
+export declare function createAitLifecycleAdapter(): LifecycleAdapter;
+export declare function dispatchAitLifecycleEvent(type: 'pause' | 'resume'): void;

package/dist/lifecycle.js

@@ -0,0 +1,45 @@
+export const aitLifecyclePauseEvent = 'mpgd:ait:pause';
+export const aitLifecycleResumeEvent = 'mpgd:ait:resume';
+const lifecycleEventDedupeWindowMs = 500;
+export function createAitLifecycleAdapter() {
+    return {
+        onPause(callback) {
+            return subscribeToAitLifecycle('pause', callback);
+        },
+        onResume(callback) {
+            return subscribeToAitLifecycle('resume', callback);
+        },
+    };
+}
+export function dispatchAitLifecycleEvent(type) {
+    globalThis.dispatchEvent?.(new Event(type === 'pause' ? aitLifecyclePauseEvent : aitLifecycleResumeEvent));
+}
+function subscribeToAitLifecycle(type, callback) {
+    const target = globalThis;
+    const documentTarget = target.document;
+    const eventName = type === 'pause' ? aitLifecyclePauseEvent : aitLifecycleResumeEvent;
+    let lastFiredAt = Number.NEGATIVE_INFINITY;
+    const fire = () => {
+        const now = Date.now();
+        if (now - lastFiredAt < lifecycleEventDedupeWindowMs) {
+            return;
+        }
+        lastFiredAt = now;
+        callback();
+    };
+    const handleCustomEvent = () => fire();
+    const handleVisibilityChange = () => {
+        if (documentTarget?.visibilityState === (type === 'pause' ? 'hidden' : 'visible')) {
+            fire();
+        }
+    };
+    const handlePageTransition = () => fire();
+    target.addEventListener?.(eventName, handleCustomEvent);
+    documentTarget?.addEventListener('visibilitychange', handleVisibilityChange);
+    target.addEventListener?.(type === 'pause' ? 'pagehide' : 'pageshow', handlePageTransition);
+    return () => {
+        target.removeEventListener?.(eventName, handleCustomEvent);
+        documentTarget?.removeEventListener('visibilitychange', handleVisibilityChange);
+        target.removeEventListener?.(type === 'pause' ? 'pagehide' : 'pageshow', handlePageTransition);
+    };
+}

package/dist/wrapper-url.d.ts

@@ -0,0 +1,2 @@
+export declare const aitGameBundleBasePath = "/game/";
+export declare function rewriteAitGameBundleUrl(url: string, origin: string): string;

package/dist/wrapper-url.js

@@ -0,0 +1,45 @@
+export const aitGameBundleBasePath = '/game/';
+export function rewriteAitGameBundleUrl(url, origin) {
+    const trimmedUrl = url.trim();
+    if (trimmedUrl.length === 0) {
+        throw new Error('Game bundle asset URL must not be empty.');
+    }
+    if (trimmedUrl.startsWith('//')) {
+        throw new Error('Protocol-relative game bundle asset URLs are not supported.');
+    }
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmedUrl)) {
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(trimmedUrl);
+        }
+        catch {
+            throw new Error(`Invalid game bundle asset URL: ${trimmedUrl}`);
+        }
+        if ((parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')
+            || parsedUrl.origin !== origin) {
+            throw new Error(`External game bundle asset URL is not supported: ${parsedUrl.protocol}`);
+        }
+        return rewriteAitGameBundleUrl(`${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`, origin);
+    }
+    return rewriteAndValidateGamePath(trimmedUrl, trimmedUrl, origin);
+}
+function rewriteAndValidateGamePath(path, originalUrl, origin) {
+    rejectEncodedTraversal(path, originalUrl);
+    const normalizedPath = path.startsWith('/') && !path.startsWith(aitGameBundleBasePath)
+        ? path.slice(1)
+        : path;
+    const resolvedUrl = new URL(normalizedPath, `${origin}${aitGameBundleBasePath}`);
+    if (resolvedUrl.origin !== origin || !resolvedUrl.pathname.startsWith(aitGameBundleBasePath)) {
+        throw new Error(`Game bundle asset URL escapes the bundle base path: ${originalUrl}`);
+    }
+    return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+}
+function rejectEncodedTraversal(path, originalUrl) {
+    const rawPath = path.toLowerCase();
+    if (rawPath.includes('%25')
+        || rawPath.includes('%2e')
+        || rawPath.includes('%2f')
+        || rawPath.includes('%5c')) {
+        throw new Error(`Game bundle asset URL contains encoded path traversal: ${originalUrl}`);
+    }
+}

package/dist/wrapper.d.ts

@@ -0,0 +1 @@
+export declare function mountAitGameBundle(app: HTMLElement): Promise<void>;

package/dist/wrapper.js

@@ -0,0 +1,267 @@
+import { aitGameBundleBasePath, rewriteAitGameBundleUrl } from './wrapper-url';
+const gameBundleBasePath = aitGameBundleBasePath;
+const gameBundleIndexPath = `${gameBundleBasePath}index.html`;
+const gameAssetAttribute = 'data-mpgd-ait-game-asset';
+const resourceLoadTimeoutMs = 15000;
+const safeScriptAttributes = new Set([
+    'crossorigin',
+    'integrity',
+    'nomodule',
+    'nonce',
+    'referrerpolicy',
+    'type',
+]);
+export function mountAitGameBundle(app) {
+    return loadGameBundle(app);
+}
+async function loadGameBundle(app) {
+    try {
+        const bundleDocument = await fetchGameBundleDocument();
+        const gameMount = bundleDocument.querySelector('#game');
+        if (gameMount === null) {
+            throw new Error('Game bundle mount element was not found.');
+        }
+        const scripts = Array.from(bundleDocument.querySelectorAll('script'));
+        if (scripts.length === 0) {
+            throw new Error('Game bundle script was not found.');
+        }
+        const links = Array.from(bundleDocument.querySelectorAll('link[href]'));
+        await Promise.all(links.map((link) => appendBundleLink(link)));
+        document.title = bundleDocument.title || document.title;
+        app.replaceChildren(createGameMount(gameMount));
+        await appendBundleScripts(scripts);
+    }
+    catch (error) {
+        // Already-executed scripts cannot be un-run; this only removes injected DOM nodes.
+        removeInjectedGameAssets();
+        renderMissingBundleShell(app, error);
+    }
+}
+async function fetchGameBundleDocument() {
+    const controller = new AbortController();
+    const timer = window.setTimeout(() => {
+        controller.abort();
+    }, resourceLoadTimeoutMs);
+    try {
+        const response = await fetch(gameBundleIndexPath, {
+            cache: 'no-store',
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Game bundle request failed with ${response.status}.`);
+        }
+        const contentType = response.headers.get('Content-Type') ?? '';
+        // The wrapper only runs over HTTP(S), where Vite and the AIT container both declare HTML.
+        // Missing metadata fails closed before any URLs from the response are injected.
+        if (!contentType.toLowerCase().startsWith('text/html')) {
+            throw new Error(`Game bundle returned unexpected Content-Type: ${contentType}.`);
+        }
+        const html = await response.text();
+        return new DOMParser().parseFromString(html, 'text/html');
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw new Error(`Timed out loading ${gameBundleIndexPath}.`);
+        }
+        throw error;
+    }
+    finally {
+        window.clearTimeout(timer);
+    }
+}
+async function appendBundleLink(source) {
+    const rel = source.getAttribute('rel');
+    if (rel !== 'stylesheet' && rel !== 'modulepreload') {
+        return;
+    }
+    const href = source.getAttribute('href');
+    if (href === null) {
+        return;
+    }
+    const rewrittenHref = rewriteGameBundleUrl(href);
+    if (hasMarkedElement('link', rewrittenHref)) {
+        return;
+    }
+    const link = document.createElement('link');
+    link.setAttribute(gameAssetAttribute, 'true');
+    copyAttribute(source, link, 'as');
+    copyAttribute(source, link, 'crossorigin');
+    copyAttribute(source, link, 'integrity');
+    copyAttribute(source, link, 'media');
+    copyAttribute(source, link, 'nonce');
+    copyAttribute(source, link, 'referrerpolicy');
+    copyAttribute(source, link, 'type');
+    link.rel = rel;
+    link.setAttribute('href', rewrittenHref);
+    document.head.appendChild(link);
+    if (rel === 'stylesheet') {
+        await waitForElementLoad(link, rewrittenHref);
+    }
+}
+async function appendBundleScripts(scripts) {
+    const runtimeErrorTrap = createRuntimeErrorTrap();
+    try {
+        for (const script of scripts) {
+            const scriptPromise = appendBundleScript(script);
+            // The runtime trap can win while this resource is still loading. Mark its eventual
+            // rejection as handled without changing which error wins the race.
+            void scriptPromise.catch(() => undefined);
+            await Promise.race([scriptPromise, runtimeErrorTrap.promise]);
+            await waitForNextMacrotask();
+            runtimeErrorTrap.throwIfCaught();
+        }
+    }
+    finally {
+        runtimeErrorTrap.dispose();
+    }
+}
+async function appendBundleScript(source) {
+    const src = source.getAttribute('src');
+    if (src === null) {
+        throw new Error('Inline scripts are not supported in AIT wrapper game bundles.');
+    }
+    const rewrittenSrc = rewriteGameBundleUrl(src);
+    if (hasMarkedElement('script', rewrittenSrc)) {
+        return;
+    }
+    const script = document.createElement('script');
+    script.setAttribute(gameAssetAttribute, 'true');
+    copyScriptAttributes(source, script);
+    script.async = false;
+    script.setAttribute('src', rewrittenSrc);
+    const loadPromise = waitForElementLoad(script, rewrittenSrc);
+    document.body.appendChild(script);
+    await loadPromise;
+}
+function rewriteGameBundleUrl(url) {
+    return rewriteAitGameBundleUrl(url, window.location.origin);
+}
+function createGameMount(source) {
+    const tagName = source.tagName.toLowerCase() === 'main' ? 'main' : 'div';
+    const mount = document.createElement(tagName);
+    for (const attribute of source.attributes) {
+        const attributeName = attribute.name.toLowerCase();
+        if (attributeName === 'class' ||
+            attributeName === 'role' ||
+            attributeName.startsWith('aria-') ||
+            attributeName.startsWith('data-')) {
+            mount.setAttribute(attribute.name, attribute.value);
+        }
+    }
+    mount.id = 'game';
+    return mount;
+}
+function copyAttribute(source, target, attributeName) {
+    const value = source.getAttribute(attributeName);
+    if (value !== null) {
+        target.setAttribute(attributeName, value);
+    }
+}
+function copyScriptAttributes(source, target) {
+    for (const attribute of source.attributes) {
+        if (safeScriptAttributes.has(attribute.name)) {
+            target.setAttribute(attribute.name, attribute.value);
+        }
+    }
+}
+function hasMarkedElement(tagName, url) {
+    const attributeName = tagName === 'link' ? 'href' : 'src';
+    const elements = document.querySelectorAll(`${tagName}[${gameAssetAttribute}]`);
+    return Array.from(elements).some((element) => element.getAttribute(attributeName) === url);
+}
+function removeInjectedGameAssets() {
+    document.querySelectorAll(`[${gameAssetAttribute}]`).forEach((element) => element.remove());
+}
+function createRuntimeErrorTrap() {
+    let caughtError = null;
+    let rejectPromise = () => { };
+    const promise = new Promise((_resolve, reject) => {
+        rejectPromise = reject;
+    });
+    promise.catch(() => undefined);
+    const catchError = (error) => {
+        if (caughtError === null) {
+            caughtError = error;
+            rejectPromise(error);
+        }
+    };
+    const onError = (event) => {
+        if (!isGameBundleRuntimeError(event)) {
+            return;
+        }
+        catchError(event.error instanceof Error ? event.error : new Error(event.message));
+    };
+    window.addEventListener('error', onError);
+    return {
+        promise,
+        throwIfCaught() {
+            if (caughtError !== null) {
+                throw caughtError;
+            }
+        },
+        dispose() {
+            window.removeEventListener('error', onError);
+        },
+    };
+}
+function isGameBundleRuntimeError(event) {
+    if (event.filename.length === 0) {
+        return false;
+    }
+    try {
+        const sourceUrl = new URL(event.filename, window.location.href);
+        return sourceUrl.origin === window.location.origin && sourceUrl.pathname.startsWith(gameBundleBasePath);
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForNextMacrotask() {
+    await new Promise((resolve) => {
+        window.setTimeout(() => resolve(), 0);
+    });
+}
+async function waitForElementLoad(element, url) {
+    await new Promise((resolve, reject) => {
+        const controller = new AbortController();
+        let timer = 0;
+        const settle = (callback) => {
+            window.clearTimeout(timer);
+            controller.abort();
+            callback();
+        };
+        timer = window.setTimeout(() => {
+            settle(() => reject(new Error(`Timed out loading ${url}.`)));
+        }, resourceLoadTimeoutMs);
+        element.addEventListener('load', () => {
+            settle(resolve);
+        }, { once: true, signal: controller.signal });
+        element.addEventListener('error', () => {
+            settle(() => reject(new Error(`Failed to load ${url}.`)));
+        }, {
+            once: true,
+            signal: controller.signal,
+        });
+    });
+}
+function renderMissingBundleShell(app, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const section = document.createElement('section');
+    section.className = 'shell';
+    const title = document.createElement('h1');
+    title.textContent = 'MPGD AIT Target';
+    const guide = document.createElement('p');
+    guide.append('Bridge installed. Run ');
+    const command = document.createElement('code');
+    command.textContent = 'pnpm build:ait';
+    guide.append(command, ' from a generated game to copy its bundle into ');
+    const outputPath = document.createElement('code');
+    outputPath.textContent = 'public/game';
+    guide.append(outputPath, '.');
+    const errorMessage = document.createElement('p');
+    const errorCode = document.createElement('code');
+    errorCode.textContent = detail;
+    errorMessage.append(errorCode);
+    section.append(title, guide, errorMessage);
+    app.replaceChildren(section);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-ait",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Apps in Toss WebView platform adapter for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -28,16 +28,38 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./host": {
+      "types": "./dist/host.d.ts",
+      "default": "./dist/host.js"
+    },
+    "./wrapper": {
+      "types": "./dist/wrapper.d.ts",
+      "default": "./dist/wrapper.js"
+    },
+    "./ad-config": {
+      "types": "./dist/ad-config.d.ts",
+      "default": "./dist/ad-config.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@mpgd/bridge": "0.6.0",
-    "@mpgd/platform": "0.6.0"
+    "@mpgd/bridge": "0.6.1",
+    "@mpgd/platform": "0.7.0"
+  },
+  "peerDependencies": {
+    "@apps-in-toss/web-framework": ">=2.10.4 <3"
+  },
+  "peerDependenciesMeta": {
+    "@apps-in-toss/web-framework": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@apps-in-toss/web-framework": "^2.10.6",
     "ttsc": "0.18.4",
     "typescript": "7.0.2",
     "vitest": "^4.0.0"