@mpgd/target-config 0.11.0 → 0.13.0

package/dist/effective.d.ts

@@ -39,6 +39,7 @@ export interface EffectiveMonetizationConfig {
   readonly products: readonly EffectiveProductConfig[];
 }
 export interface EffectiveAdsConfig {
+  readonly bannerAds: boolean;
   readonly rewardedAds: boolean;
   readonly interstitialAds: boolean;
   readonly placements: readonly EffectiveAdPlacementConfig[];

package/dist/effective.js

@@ -1,8 +1,9 @@
 import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
-import { assertTargetIntegrationRuntimeBounds, } from './runtime.js';
+import { adPlacementFeatureFor, assertTargetIntegrationRuntimeBounds, } from './runtime.js';
 export const defaultLeaderboardId = 'default';
 const disabledAuthoritativeMonetization = {
     iap: false,
+    bannerAds: false,
     rewardedAds: false,
     interstitialAds: false,
 };
@@ -44,6 +45,7 @@ export function createEffectiveTargetConfig(input) {
             products,
         },
         ads: {
+            bannerAds: config.monetization.bannerAds === true,
             rewardedAds: config.monetization.rewardedAds,
             interstitialAds: config.monetization.interstitialAds,
             placements,
@@ -126,12 +128,13 @@ function effectiveProductReason(runtime, targetEnabled, product, platformProduct
     if (runtime === 'verse8-web' && product.grant.type === 'resource') {
         return 'capability-unsupported';
     }
+    if (runtime === 'microsoft-store-pwa' && product.type !== 'consumable') {
+        return 'capability-unsupported';
+    }
     return effectiveItemReason(targetEnabled, platformProductId);
 }
 function createEffectiveAdPlacementConfig(target, config, placement) {
-    const featureEnabled = isRewardedPlacement(placement)
-        ? config.features.rewardedAds
-        : config.features.interstitialAds;
+    const featureEnabled = config.features[adPlacementFeatureFor(placement.type)] === true;
     const platformPlacementId = resolveAdPlacementPlatformId(placement, target);
     const reason = effectiveItemReason(featureEnabled, platformPlacementId);
     return {
@@ -153,6 +156,3 @@ function effectiveItemReason(targetEnabled, platformId) {
 function effectiveTargetConfigVersion(input) {
     return `${input.targetConfig}+catalog.${input.productCatalog}+ads.${input.adPlacements}`;
 }
-function isRewardedPlacement(placement) {
-    return placement.type === 'rewarded';
-}

package/dist/index.js

@@ -179,7 +179,12 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>)",
         value: input.amount
     }, _errorFactory));
-    const _ao14 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.placements) || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao14 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.bannerAds || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".bannerAds",
+        expected: "boolean",
+        value: input.bannerAds
+    }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.placements) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".placements",
         expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
@@ -200,10 +205,10 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
         value: input.placements
     }, _errorFactory));
-    const _ao15 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable) && ("interstitial" === input.type || "rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao15 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable) && ("banner" === input.type || "interstitial" === input.type || "rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
-        expected: "(\"interstitial\" | \"rewarded\")",
+        expected: "(\"banner\" | \"interstitial\" | \"rewarded\")",
         value: input.type
     }, _errorFactory)) && (undefined === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
@@ -409,7 +414,12 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(\"app-store\" | \"apps-in-toss\" | \"devvit\" | \"google-play\" | \"microsoft-store\" | \"verse8\" | \"web\" | \"web-preview\")",
         value: input.profile
     }, _errorFactory);
-    const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && (undefined === input.bannerAds || "boolean" === typeof input.bannerAds || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".bannerAds",
+        expected: "(boolean | undefined)",
+        value: input.bannerAds
+    }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".leaderboard",
         expected: "boolean",
@@ -564,8 +574,8 @@ export const assertEffectiveTargetConfigMatrix = (() => {
     const _io11 = input => _ip8(input) && _ip9(input) && _ip10(input);
     const _io12 = input => "entitlement" === input.type && "string" === typeof input.entitlement;
     const _io13 = input => "resource" === input.type && ("string" === typeof input.resource && 1 <= input.resource.length) && ("number" === typeof input.amount && (0 < input.amount && input.amount <= 1.7976931348623157e+308));
-    const _io14 = input => _ip2(input) && _ip3(input) && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io15(elem)));
-    const _io15 = input => _ip5(input) && ("interstitial" === input.type || "rewarded" === input.type) && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)) && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io18(input.frequencyCap)) && _ip6(input) && _ip7(input) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId);
+    const _io14 = input => "boolean" === typeof input.bannerAds && _ip2(input) && _ip3(input) && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io15(elem)));
+    const _io15 = input => _ip5(input) && ("banner" === input.type || "interstitial" === input.type || "rewarded" === input.type) && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)) && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io18(input.frequencyCap)) && _ip6(input) && _ip7(input) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId);
     const _io16 = input => "continue" === input.type && _ip10(input);
     const _io17 = input => _ip8(input) && _ip10(input) && _ip9(input);
     const _io18 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
@@ -574,7 +584,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
     const _io20 = input => ("local" === input.support || "native" === input.support || "none" === input.support) && _ip6(input);
     const _io21 = input => _ip6(input) && ("en" === input.fallbackLocale || "ko" === input.fallbackLocale);
     const _io3 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "devvit" === input.profile || "google-play" === input.profile || "microsoft-store" === input.profile || "verse8" === input.profile || "web" === input.profile || "web-preview" === input.profile;
-    const _io4 = input => _ip1(input) && _ip2(input) && _ip3(input) && "boolean" === typeof input.leaderboard && _ip4(input);
+    const _io4 = input => _ip1(input) && (undefined === input.bannerAds || "boolean" === typeof input.bannerAds) && _ip2(input) && _ip3(input) && "boolean" === typeof input.leaderboard && _ip4(input);
     const _io5 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip4(input);
     const _io6 = input => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode);
     const _io7 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
@@ -620,9 +630,10 @@ export const assertEffectiveTargetConfigMatrix = (() => {
 })();
 export const assertTargetConfigMatrix = (() => {
     const _ip0 = input => "boolean" === typeof input["iap"];
-    const _ip1 = input => "boolean" === typeof input["rewardedAds"];
-    const _ip2 = input => "boolean" === typeof input["interstitialAds"];
-    const _ip3 = input => "boolean" === typeof input["localization"];
+    const _ip1 = input => undefined === input["bannerAds"] || "boolean" === typeof input["bannerAds"];
+    const _ip2 = input => "boolean" === typeof input["rewardedAds"];
+    const _ip3 = input => "boolean" === typeof input["interstitialAds"];
+    const _ip4 = input => "boolean" === typeof input["localization"];
     const _ae0 = "(\"apps-in-toss\" | \"capacitor-android\" | \"capacitor-ios\" | \"devvit-web\" | \"microsoft-store-pwa\" | \"verse8-web\" | \"web\" | \"web-preview\")";
     const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
@@ -630,19 +641,25 @@ export const assertTargetConfigMatrix = (() => {
         expected: "boolean",
         value: input["iap"]
     }, _errorFactory);
-    const _ap1 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ap1 = (input, _path, _exceptionable = true) => undefined === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".bannerAds",
+        expected: "(boolean | undefined)",
+        value: input["bannerAds"]
+    }, _errorFactory);
+    const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".rewardedAds",
         expected: "boolean",
         value: input["rewardedAds"]
     }, _errorFactory);
-    const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".interstitialAds",
         expected: "boolean",
         value: input["interstitialAds"]
     }, _errorFactory);
-    const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".localization",
         expected: "boolean",
@@ -797,25 +814,25 @@ export const assertTargetConfigMatrix = (() => {
         expected: "(TargetIntegrationConfig | undefined)",
         value: input.integrations
     }, _errorFactory));
-    const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".leaderboard",
         expected: "boolean",
         value: input.leaderboard
-    }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
+    }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
     const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".storage",
         expected: "(\"local\" | \"native\" | \"none\")",
         value: input.storage
-    }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
+    }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
     const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".fallbackLocale",
         expected: "(\"en\" | \"ko\")",
         value: input.fallbackLocale
     }, _errorFactory);
-    const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable);
+    const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable);
     const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".native",
@@ -863,10 +880,10 @@ export const assertTargetConfigMatrix = (() => {
     });
     const _io10 = input => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode);
     const _io2 = input => ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "devvit-web" === input.runtime || "microsoft-store-pwa" === input.runtime || "verse8-web" === input.runtime || "web" === input.runtime || "web-preview" === input.runtime) && ("object" === typeof input.features && null !== input.features && _io3(input.features)) && ("object" === typeof input.capabilities && null !== input.capabilities && _io4(input.capabilities)) && ("object" === typeof input.localization && null !== input.localization && _io5(input.localization)) && ("object" === typeof input.monetization && null !== input.monetization && _io6(input.monetization)) && ("object" === typeof input.leaderboard && null !== input.leaderboard && _io7(input.leaderboard)) && ("object" === typeof input.release && null !== input.release && _io8(input.release)) && ("object" === typeof input.policy && null !== input.policy && _io9(input.policy)) && (undefined === input.integrations || "object" === typeof input.integrations && null !== input.integrations && _io10(input.integrations));
-    const _io3 = input => _ip0(input) && _ip1(input) && _ip2(input) && "boolean" === typeof input.leaderboard && _ip3(input);
-    const _io4 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip3(input);
+    const _io3 = input => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && "boolean" === typeof input.leaderboard && _ip4(input);
+    const _io4 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip4(input);
     const _io5 = input => "en" === input.fallbackLocale || "ko" === input.fallbackLocale;
-    const _io6 = input => _ip0(input) && _ip1(input) && _ip2(input);
+    const _io6 = input => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input);
     const _io7 = input => "boolean" === typeof input.native;
     const _io8 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "devvit" === input.profile || "google-play" === input.profile || "microsoft-store" === input.profile || "verse8" === input.profile || "web" === input.profile || "web-preview" === input.profile;
     const _io9 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;

package/dist/runtime.d.ts

@@ -1,8 +1,8 @@
 import type { MpgdLocale } from '@mpgd/i18n';
 import type { PlatformCapabilities, PlatformGateway } from '@mpgd/platform';
 import type { EffectiveTargetConfig } from './effective.js';
-export type PlatformFeature = 'iap' | 'rewardedAds' | 'interstitialAds' | 'leaderboard' | 'localization';
-export type AdPlacementType = 'rewarded' | 'interstitial';
+export type PlatformFeature = 'iap' | 'bannerAds' | 'rewardedAds' | 'interstitialAds' | 'leaderboard' | 'localization';
+export type AdPlacementType = 'rewarded' | 'interstitial' | 'banner';
 type PlatformConfigTarget = PlatformGateway['target'];
 export type TargetRuntimeKind = 'web' | 'web-preview' | 'microsoft-store-pwa' | 'capacitor-android' | 'capacitor-ios' | 'apps-in-toss' | 'devvit-web' | 'verse8-web';
 export type ReleaseProfile = 'web' | 'web-preview' | 'microsoft-store' | 'google-play' | 'app-store' | 'apps-in-toss' | 'devvit' | 'verse8';
@@ -20,6 +20,8 @@ export interface TargetIntegrationConfig {
 }
 export interface TargetFeatureConfig {
   readonly iap: boolean;
+  /** Optional for target matrices authored before inline banner support. */
+  readonly bannerAds?: boolean;
   readonly rewardedAds: boolean;
   readonly interstitialAds: boolean;
   readonly leaderboard: boolean;
@@ -34,6 +36,8 @@ export interface TargetLocalizationConfig {
 }
 export interface TargetMonetizationConfig {
   readonly iap: boolean;
+  /** Optional for target matrices authored before inline banner support. */
+  readonly bannerAds?: boolean;
   readonly rewardedAds: boolean;
   readonly interstitialAds: boolean;
 }
@@ -112,7 +116,8 @@ export interface TargetConfiguredGateway extends PlatformGateway {
   readonly effectiveConfig?: EffectiveTargetConfig;
   getTargetRuntime(): Promise<TargetRuntimeSnapshot>;
 }
-export declare const platformFeatures: readonly ["iap", "rewardedAds", "interstitialAds", "leaderboard", "localization"];
+export declare const platformFeatures: readonly ["iap", "bannerAds", "rewardedAds", "interstitialAds", "leaderboard", "localization"];
+export declare function adPlacementFeatureFor(type: AdPlacementType): PlatformFeature;
 export declare const targetIntegrations: readonly ["identityUpgrade", "presentation", "sharing", "inboundShare", "notifications"];
 type CompleteValueList<Union, Values extends readonly Union[]> = Exclude<Union, Values[number]> extends never ? Values : never;
 declare const integrationAvailabilityStateValues: readonly ["available", "disabled", "approval-required", "configuration-required", "unsupported"];

package/dist/runtime.js

@@ -1,10 +1,19 @@
+const adPlacementFeatureByType = {
+    rewarded: 'rewardedAds',
+    interstitial: 'interstitialAds',
+    banner: 'bannerAds',
+};
 export const platformFeatures = [
     'iap',
+    'bannerAds',
     'rewardedAds',
     'interstitialAds',
     'leaderboard',
     'localization',
 ];
+export function adPlacementFeatureFor(type) {
+    return adPlacementFeatureByType[type];
+}
 export const targetIntegrations = [
     'identityUpgrade',
     'presentation',
@@ -100,22 +109,27 @@ export function getTargetConfig(matrix, target) {
     return config;
 }
 export function isPlatformFeatureEnabled(config, feature) {
-    return config.features[feature];
+    return config.features[feature] === true;
 }
 export function applyTargetConfigToCapabilities(capabilities, config) {
+    const bannerAds = capabilities.bannerAds === true && config.features.bannerAds === true;
+    const rewardedAds = capabilities.rewardedAds && config.features.rewardedAds;
+    const interstitialAds = capabilities.interstitialAds && config.features.interstitialAds;
     return {
         ...capabilities,
         nativeIap: capabilities.nativeIap && config.features.iap,
         nativeAds: capabilities.nativeAds &&
-            (config.features.rewardedAds || config.features.interstitialAds),
-        rewardedAds: capabilities.rewardedAds && config.features.rewardedAds,
-        interstitialAds: capabilities.interstitialAds && config.features.interstitialAds,
+            (bannerAds || rewardedAds || interstitialAds),
+        bannerAds,
+        rewardedAds,
+        interstitialAds,
         nativeLeaderboard: capabilities.nativeLeaderboard && config.features.leaderboard,
+        remoteLeaderboard: capabilities.remoteLeaderboard && config.features.leaderboard,
         localizedContent: capabilities.localizedContent && config.features.localization,
     };
 }
 export function getFeatureAvailability(feature, config, capabilities) {
-    const targetEnabled = config.features[feature];
+    const targetEnabled = config.features[feature] === true;
     const capabilitySupported = isFeatureCapabilitySupported(feature, capabilities);
     const enabled = targetEnabled && capabilitySupported;
     return {
@@ -139,6 +153,7 @@ export function createTargetRuntimeSnapshot(input) {
     const availabilityConfig = resolveAvailabilityConfig(input.config, input.effectiveConfig);
     const features = {
         iap: getFeatureAvailability('iap', availabilityConfig, input.capabilities),
+        bannerAds: getFeatureAvailability('bannerAds', availabilityConfig, input.capabilities),
         rewardedAds: getFeatureAvailability('rewardedAds', availabilityConfig, input.capabilities),
         interstitialAds: getFeatureAvailability('interstitialAds', availabilityConfig, input.capabilities),
         leaderboard: getFeatureAvailability('leaderboard', availabilityConfig, input.capabilities),
@@ -160,7 +175,7 @@ export function createTargetRuntimeSnapshot(input) {
         features,
         integrations,
         adPlacements: (input.adPlacements ?? []).map((placement) => {
-            const feature = placement.type === 'rewarded' ? 'rewardedAds' : 'interstitialAds';
+            const feature = adPlacementFeatureFor(placement.type);
             const availability = features[feature];
             return {
                 id: placement.id,
@@ -206,25 +221,28 @@ export function withTargetAvailability(gateway, config, options = {}) {
         };
     const notifications = notificationsAvailable ? gatewayNotifications : undefined;
     const isIapAvailable = async () => (availabilityConfig.features.iap && (await getGatewayCapabilities()).nativeIap);
+    const isLeaderboardAvailable = async () => {
+        if (!availabilityConfig.features.leaderboard) {
+            return false;
+        }
+        const capabilities = await getGatewayCapabilities();
+        return capabilities.nativeLeaderboard || capabilities.remoteLeaderboard;
+    };
     const isAdPlacementAllowed = (placementId, expectedType) => {
         const actualType = options.resolveAdPlacementType?.(placementId);
         if (actualType !== undefined && actualType !== expectedType) {
             return false;
         }
-        return expectedType === 'rewarded'
-            ? availabilityConfig.features.rewardedAds
-            : availabilityConfig.features.interstitialAds;
+        return availabilityConfig.features[adPlacementFeatureFor(expectedType)] === true;
     };
     const canPreloadAdPlacement = (placementId) => {
         const actualType = options.resolveAdPlacementType?.(placementId);
-        if (actualType === 'rewarded') {
-            return availabilityConfig.features.rewardedAds;
-        }
-        if (actualType === 'interstitial') {
-            return availabilityConfig.features.interstitialAds;
+        if (actualType !== undefined) {
+            return availabilityConfig.features[adPlacementFeatureFor(actualType)] === true;
         }
         return (availabilityConfig.features.rewardedAds ||
-            availabilityConfig.features.interstitialAds);
+            availabilityConfig.features.interstitialAds ||
+            availabilityConfig.features.bannerAds === true);
     };
     return {
         ...gatewayWithoutIntegrations,
@@ -302,17 +320,34 @@ export function withTargetAvailability(gateway, config, options = {}) {
                 }
                 return gateway.ads.showInterstitial(input);
             },
+            async mountBanner(input) {
+                if (!isAdPlacementAllowed(input.placementId, 'banner')
+                    || gateway.ads.mountBanner === undefined) {
+                    return { status: 'unavailable' };
+                }
+                return gateway.ads.mountBanner(input);
+            },
+            async unmountBanner(input) {
+                if (gateway.ads.unmountBanner !== undefined) {
+                    await gateway.ads.unmountBanner(input);
+                }
+            },
         },
-        leaderboard: availabilityConfig.features.leaderboard
-            ? gateway.leaderboard
-            : {
-                async submitScore() {
+        leaderboard: {
+            async submitScore(input) {
+                if (!await isLeaderboardAvailable()) {
                     return {
                         submitted: false,
                     };
-                },
-                async open() { },
+                }
+                return gateway.leaderboard.submitScore(input);
             },
+            async open(input) {
+                if (await isLeaderboardAvailable()) {
+                    await gateway.leaderboard.open(input);
+                }
+            },
+        },
     };
 }
 function resolveAvailabilityConfig(config, effectiveConfig) {
@@ -330,12 +365,14 @@ function isFeatureCapabilitySupported(feature, capabilities) {
     switch (feature) {
         case 'iap':
             return capabilities.nativeIap;
+        case 'bannerAds':
+            return capabilities.bannerAds === true;
         case 'rewardedAds':
             return capabilities.rewardedAds;
         case 'interstitialAds':
             return capabilities.interstitialAds;
         case 'leaderboard':
-            return capabilities.nativeLeaderboard;
+            return capabilities.nativeLeaderboard || capabilities.remoteLeaderboard;
         case 'localization':
             return capabilities.localizedContent;
     }

package/dist/viewport.d.ts

@@ -15,6 +15,10 @@ export type TargetViewportMeasurementSource = 'container' | 'visual-viewport' |
 export type TargetViewportControlPlacement = 'bottom' | 'side';
 /** Recommended placement for secondary game panels. */
 export type TargetViewportPanelPlacement = 'below' | 'side' | 'drawer';
+/** Adaptive shell arrangement for a game surface and its surrounding UI. */
+export type TargetViewportCompositionMode = 'side-rails' | 'bottom-controls' | 'compact-portrait';
+/** Optional expanded-screen arrangement requested by a game. */
+export type TargetViewportExpandedLayout = 'none' | 'side-rails';
 /** Width thresholds used to classify target viewports. */
 export interface TargetViewportBreakpoints {
   readonly compactMaxWidth: number;
@@ -109,6 +113,36 @@ export interface TargetViewportSnapshot extends TargetViewportPlan {
   readonly safeArea: TargetViewportSafeArea;
 }
 /**
+* Input for resolving a concrete adaptive game shell from an existing viewport
+* snapshot. The aspect ratio is expressed as width divided by height.
+*/
+export interface TargetViewportCompositionInput {
+  readonly viewport: Pick<TargetViewportSnapshot, 'layout' | 'safeArea'>;
+  readonly gameAspectRatio: number;
+  readonly expandedLayout?: TargetViewportExpandedLayout;
+  readonly minRailWidth?: number;
+}
+interface TargetViewportCompositionBounds {
+  readonly contentBounds: TargetViewportBounds;
+  readonly gameBounds: TargetViewportBounds;
+}
+/** Concrete safe-area-relative geometry for an adaptive game shell. */
+export type TargetViewportComposition = TargetViewportCompositionBounds & ({
+  readonly mode: 'side-rails';
+  readonly leftRailBounds: TargetViewportBounds;
+  readonly rightRailBounds: TargetViewportBounds;
+  readonly primaryControls: 'side';
+  readonly secondaryPanels: 'side';
+} | {
+  readonly mode: 'bottom-controls';
+  readonly primaryControls: 'bottom';
+  readonly secondaryPanels: 'below';
+} | {
+  readonly mode: 'compact-portrait';
+  readonly primaryControls: 'bottom';
+  readonly secondaryPanels: 'drawer';
+});
+/**
 * The minimal browser style surface needed to read CSS safe-area custom
 * properties. Keeping this structural avoids a runtime DOM dependency in the
 * target-config package.
@@ -151,6 +185,8 @@ export declare const defaultTargetViewportSafeAreaCssVariables: {
   readonly bottom: '--mpgd-safe-area-bottom';
   readonly left: '--mpgd-safe-area-left';
 };
+/** Default minimum width for each expanded-layout side rail. */
+export declare const defaultTargetViewportCompositionMinRailWidth = 160;
 /** Map a configured target runtime to its viewport host shell. */
 export declare function targetViewportShellForRuntime(runtime: TargetRuntimeKind): TargetViewportShell;
 /** Resolve a viewport shell from the runtime field of a target config. */
@@ -171,6 +207,15 @@ export declare function resolveTargetViewportPlan(input: TargetViewportInput, br
 */
 export declare function resolveTargetViewportSnapshot(input: TargetViewportSnapshotInput, breakpoints?: TargetViewportBreakpoints): TargetViewportSnapshot;
 /**
+* Resolve an adaptive game shell inside the snapshot's safe content bounds.
+*
+* A landscape viewport uses side rails only when the requested game aspect and
+* both minimum rails fit at full content height. Portrait viewports remain
+* full-bleed so phone shells do not inherit desktop letterboxing. Intermediate
+* layouts keep the full game bounds and move persistent controls to the bottom.
+*/
+export declare function resolveTargetViewportComposition(input: TargetViewportCompositionInput): TargetViewportComposition;
+/**
 * Resolve safe-area insets and content bounds for a given layout.
 *
 * Insets are clamped sequentially (top before bottom, left before right) so
@@ -185,3 +230,4 @@ export declare function resolveTargetViewportSafeArea(layout: Pick<TargetViewpor
 * the same full-viewport layout as before.
 */
 export declare function readTargetViewportSafeAreaInsets(style: TargetViewportComputedStyle, variables?: TargetViewportSafeAreaCssVariables): TargetViewportSafeAreaInsets;
+export {};

package/dist/viewport.js

@@ -26,6 +26,8 @@ export const defaultTargetViewportSafeAreaCssVariables = {
     bottom: '--mpgd-safe-area-bottom',
     left: '--mpgd-safe-area-left',
 };
+/** Default minimum width for each expanded-layout side rail. */
+export const defaultTargetViewportCompositionMinRailWidth = 160;
 const targetViewportOrientationPolicyModeDescriptors = {
     responsive: {
         preferredOrientation: undefined,
@@ -147,6 +149,80 @@ export function resolveTargetViewportSnapshot(input, breakpoints = defaultTarget
         safeArea: resolveTargetViewportSafeArea(plan.layout, input.safeAreaInsets),
     };
 }
+/**
+ * Resolve an adaptive game shell inside the snapshot's safe content bounds.
+ *
+ * A landscape viewport uses side rails only when the requested game aspect and
+ * both minimum rails fit at full content height. Portrait viewports remain
+ * full-bleed so phone shells do not inherit desktop letterboxing. Intermediate
+ * layouts keep the full game bounds and move persistent controls to the bottom.
+ */
+export function resolveTargetViewportComposition(input) {
+    const gameAspectRatio = normalizeViewportAspectRatio(input.gameAspectRatio);
+    const minRailWidth = normalizeViewportMinimum(input.minRailWidth ?? defaultTargetViewportCompositionMinRailWidth, 'minRailWidth');
+    const contentBounds = { ...input.viewport.safeArea.contentBounds };
+    const portrait = input.viewport.layout.orientation === 'portrait';
+    if (portrait) {
+        if (input.viewport.layout.sizeClass === 'compact') {
+            return {
+                mode: 'compact-portrait',
+                contentBounds,
+                gameBounds: contentBounds,
+                primaryControls: 'bottom',
+                secondaryPanels: 'drawer',
+            };
+        }
+        return {
+            mode: 'bottom-controls',
+            contentBounds,
+            gameBounds: contentBounds,
+            primaryControls: 'bottom',
+            secondaryPanels: 'below',
+        };
+    }
+    const requestedSideRails = input.expandedLayout === 'side-rails';
+    const minimumGameWidth = contentBounds.width > 0 && contentBounds.height > 0 ? 1 : 0;
+    const desiredGameWidth = Math.max(minimumGameWidth, Math.round(contentBounds.height * gameAspectRatio));
+    const fittedGameWidth = Math.min(contentBounds.width, desiredGameWidth);
+    const availableRailWidth = (contentBounds.width - fittedGameWidth) / 2;
+    if (requestedSideRails &&
+        input.viewport.layout.sizeClass === 'expanded' &&
+        desiredGameWidth <= contentBounds.width &&
+        availableRailWidth >= minRailWidth) {
+        const gameBounds = {
+            x: contentBounds.x + availableRailWidth,
+            y: contentBounds.y,
+            width: fittedGameWidth,
+            height: contentBounds.height,
+        };
+        return {
+            mode: 'side-rails',
+            contentBounds,
+            gameBounds,
+            leftRailBounds: {
+                x: contentBounds.x,
+                y: contentBounds.y,
+                width: availableRailWidth,
+                height: contentBounds.height,
+            },
+            rightRailBounds: {
+                x: gameBounds.x + gameBounds.width,
+                y: contentBounds.y,
+                width: availableRailWidth,
+                height: contentBounds.height,
+            },
+            primaryControls: 'side',
+            secondaryPanels: 'side',
+        };
+    }
+    return {
+        mode: 'bottom-controls',
+        contentBounds,
+        gameBounds: contentBounds,
+        primaryControls: 'bottom',
+        secondaryPanels: 'below',
+    };
+}
 /**
  * Resolve safe-area insets and content bounds for a given layout.
  *
@@ -246,6 +322,20 @@ function normalizeViewportInset(value, name) {
     }
     return Math.round(value);
 }
+/** Validate a non-negative CSS-pixel minimum without discarding fractions. */
+function normalizeViewportMinimum(value, name) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Viewport ${name} must be a non-negative finite number.`);
+    }
+    return value;
+}
+/** Validate a finite positive width-to-height aspect ratio. */
+function normalizeViewportAspectRatio(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error('Viewport gameAspectRatio must be a positive finite number.');
+    }
+    return value;
+}
 /** Parse a non-negative CSS pixel custom-property value. */
 function readTargetViewportCssPixels(style, property) {
     const value = style.getPropertyValue(property).trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/target-config",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Target-specific platform feature availability and effective config helpers for mpgd.",
   "license": "MIT",
   "repository": {
@@ -37,9 +37,9 @@
   ],
   "dependencies": {
     "typia": "13.0.2",
-    "@mpgd/catalog": "0.5.2",
-    "@mpgd/i18n": "0.5.4",
-    "@mpgd/platform": "0.8.0"
+    "@mpgd/catalog": "0.7.0",
+    "@mpgd/i18n": "0.5.6",
+    "@mpgd/platform": "0.10.0"
   },
   "devDependencies": {
     "ttsc": "0.18.4",

package/targets.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026-07-19.1",
+  "version": "2026-08-12",
   "targets": {
     "web-preview": {
       "runtime": "web-preview",
@@ -47,10 +47,10 @@
     "microsoft-store": {
       "runtime": "microsoft-store-pwa",
       "features": {
-        "iap": false,
+        "iap": true,
         "rewardedAds": false,
         "interstitialAds": false,
-        "leaderboard": false,
+        "leaderboard": true,
         "localization": true
       },
       "capabilities": {
@@ -61,7 +61,7 @@
         "fallbackLocale": "en"
       },
       "monetization": {
-        "iap": false,
+        "iap": true,
         "rewardedAds": false,
         "interstitialAds": false
       },
@@ -220,6 +220,7 @@
       "runtime": "apps-in-toss",
       "features": {
         "iap": true,
+        "bannerAds": true,
         "rewardedAds": true,
         "interstitialAds": true,
         "leaderboard": true,
@@ -234,6 +235,7 @@
       },
       "monetization": {
         "iap": true,
+        "bannerAds": true,
         "rewardedAds": true,
         "interstitialAds": true
       },