@mpgd/target-config 0.11.0 → 0.12.0

package/dist/effective.js

@@ -126,6 +126,9 @@ 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) {

package/dist/runtime.js

@@ -111,6 +111,7 @@ export function applyTargetConfigToCapabilities(capabilities, config) {
         rewardedAds: capabilities.rewardedAds && config.features.rewardedAds,
         interstitialAds: capabilities.interstitialAds && config.features.interstitialAds,
         nativeLeaderboard: capabilities.nativeLeaderboard && config.features.leaderboard,
+        remoteLeaderboard: capabilities.remoteLeaderboard && config.features.leaderboard,
         localizedContent: capabilities.localizedContent && config.features.localization,
     };
 }
@@ -206,6 +207,13 @@ 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) {
@@ -303,16 +311,21 @@ export function withTargetAvailability(gateway, config, options = {}) {
                 return gateway.ads.showInterstitial(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) {
@@ -335,7 +348,7 @@ function isFeatureCapabilitySupported(feature, capabilities) {
         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.12.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.6.0",
+    "@mpgd/i18n": "0.5.5",
+    "@mpgd/platform": "0.9.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
       },