@mpgd/target-config 0.8.0 → 0.9.0

package/dist/effective.d.ts

@@ -4,6 +4,7 @@ export type EffectiveAvailabilityReason = FeatureAvailabilityReason | 'missing-p
 export interface EffectivePlatformTargetMetadata {
   readonly kind: string;
   readonly adapter: string;
+  readonly authoritativeGameServices?: boolean;
   readonly artifact?: string;
   readonly output?: string;
   readonly webDir?: string;

package/dist/effective.js

@@ -1,11 +1,17 @@
 import { normalizeTargetIntegrationConfig, } from './runtime.js';
 export const defaultLeaderboardId = 'default';
+const disabledAuthoritativeMonetization = {
+    iap: false,
+    rewardedAds: false,
+    interstitialAds: false,
+};
 export function createEffectiveTargetConfig(input) {
-    const products = input.catalog.products.map((product) => createEffectiveProductConfig(input.target, input.config, product));
-    const placements = input.adPlacements.placements.map((placement) => createEffectiveAdPlacementConfig(input.target, input.config, placement));
-    const leaderboardEnabled = input.config.features.leaderboard;
+    const config = resolveAuthoritativeGameServicesConfig(input.config, input.platformTarget);
+    const products = input.catalog.products.map((product) => createEffectiveProductConfig(input.target, config, product));
+    const placements = input.adPlacements.placements.map((placement) => createEffectiveAdPlacementConfig(input.target, config, placement));
+    const leaderboardEnabled = config.features.leaderboard;
     const integrations = normalizeTargetIntegrationConfig({
-        ...input.config.integrations,
+        ...config.integrations,
         ...input.platformTarget?.integrations,
     });
     return {
@@ -15,12 +21,12 @@ export function createEffectiveTargetConfig(input) {
             adPlacements: input.adPlacements.version,
         }),
         target: input.target,
-        runtime: input.config.runtime,
-        release: input.config.release,
-        features: input.config.features,
-        capabilities: input.config.capabilities,
+        runtime: config.runtime,
+        release: config.release,
+        features: config.features,
+        capabilities: config.capabilities,
         integrations,
-        policy: input.config.policy,
+        policy: config.policy,
         sources: {
             targetConfig: input.targetConfigVersion,
             productCatalog: input.catalog.version,
@@ -33,30 +39,43 @@ export function createEffectiveTargetConfig(input) {
                 }),
         },
         monetization: {
-            iap: input.config.monetization.iap,
+            iap: config.monetization.iap,
             products,
         },
         ads: {
-            rewardedAds: input.config.monetization.rewardedAds,
-            interstitialAds: input.config.monetization.interstitialAds,
+            rewardedAds: config.monetization.rewardedAds,
+            interstitialAds: config.monetization.interstitialAds,
             placements,
         },
         leaderboard: {
-            native: input.config.leaderboard.native,
+            native: config.leaderboard.native,
             enabled: leaderboardEnabled,
             reason: leaderboardEnabled ? 'available' : 'target-disabled',
             ...(leaderboardEnabled ? { defaultLeaderboardId } : {}),
         },
         storage: {
-            support: input.config.capabilities.storage,
-            enabled: input.config.capabilities.storage !== 'none',
+            support: config.capabilities.storage,
+            enabled: config.capabilities.storage !== 'none',
         },
         localization: {
-            enabled: input.config.capabilities.localization,
-            fallbackLocale: input.config.localization.fallbackLocale,
+            enabled: config.capabilities.localization,
+            fallbackLocale: config.localization.fallbackLocale,
         },
     };
 }
+function resolveAuthoritativeGameServicesConfig(config, platformTarget) {
+    if (platformTarget?.authoritativeGameServices !== false) {
+        return config;
+    }
+    return {
+        ...config,
+        features: {
+            ...config.features,
+            ...disabledAuthoritativeMonetization,
+        },
+        monetization: disabledAuthoritativeMonetization,
+    };
+}
 export function createEffectiveTargetConfigMatrix(input) {
     const targets = Object.fromEntries(Object.entries(input.configMatrix.targets).map(([target, config]) => {
         const platformTarget = input.platformTargets?.[target];

package/dist/runtime.js

@@ -95,12 +95,13 @@ export function getIntegrationAvailability(integration, config, gateway) {
 }
 export function createTargetRuntimeSnapshot(input) {
     const configTarget = input.configTarget ?? targetConfigKeyForPlatform(input.target);
+    const availabilityConfig = resolveAvailabilityConfig(input.config, input.effectiveConfig);
     const features = {
-        iap: getFeatureAvailability('iap', input.config, input.capabilities),
-        rewardedAds: getFeatureAvailability('rewardedAds', input.config, input.capabilities),
-        interstitialAds: getFeatureAvailability('interstitialAds', input.config, input.capabilities),
-        leaderboard: getFeatureAvailability('leaderboard', input.config, input.capabilities),
-        localization: getFeatureAvailability('localization', input.config, input.capabilities),
+        iap: getFeatureAvailability('iap', availabilityConfig, input.capabilities),
+        rewardedAds: getFeatureAvailability('rewardedAds', availabilityConfig, input.capabilities),
+        interstitialAds: getFeatureAvailability('interstitialAds', availabilityConfig, input.capabilities),
+        leaderboard: getFeatureAvailability('leaderboard', availabilityConfig, input.capabilities),
+        localization: getFeatureAvailability('localization', availabilityConfig, input.capabilities),
     };
     const integrationConfig = normalizeTargetIntegrationConfig(input.effectiveConfig?.integrations ?? input.config.integrations);
     const integrationEntries = targetIntegrations.map((integration) => {
@@ -130,6 +131,7 @@ export function createTargetRuntimeSnapshot(input) {
     };
 }
 export function withTargetAvailability(gateway, config, options = {}) {
+    const availabilityConfig = resolveAvailabilityConfig(config, options.effectiveConfig);
     const getGatewayCapabilities = () => (gateway.getCapabilities());
     const configTarget = options.configTarget ?? targetConfigKeyForPlatform(gateway.target);
     const { identity: gatewayIdentity, presentation: gatewayPresentation, sharing: gatewaySharing, notifications: gatewayNotifications, ...gatewayWithoutIntegrations } = gateway;
@@ -162,25 +164,26 @@ export function withTargetAvailability(gateway, config, options = {}) {
             ...(exposeInboundShare ? { readInboundShare } : {}),
         };
     const notifications = notificationsAvailable ? gatewayNotifications : undefined;
-    const isIapAvailable = async () => (config.features.iap && (await getGatewayCapabilities()).nativeIap);
+    const isIapAvailable = async () => (availabilityConfig.features.iap && (await getGatewayCapabilities()).nativeIap);
     const isAdPlacementAllowed = (placementId, expectedType) => {
         const actualType = options.resolveAdPlacementType?.(placementId);
         if (actualType !== undefined && actualType !== expectedType) {
             return false;
         }
         return expectedType === 'rewarded'
-            ? config.features.rewardedAds
-            : config.features.interstitialAds;
+            ? availabilityConfig.features.rewardedAds
+            : availabilityConfig.features.interstitialAds;
     };
     const canPreloadAdPlacement = (placementId) => {
         const actualType = options.resolveAdPlacementType?.(placementId);
         if (actualType === 'rewarded') {
-            return config.features.rewardedAds;
+            return availabilityConfig.features.rewardedAds;
         }
         if (actualType === 'interstitial') {
-            return config.features.interstitialAds;
+            return availabilityConfig.features.interstitialAds;
         }
-        return config.features.rewardedAds || config.features.interstitialAds;
+        return (availabilityConfig.features.rewardedAds ||
+            availabilityConfig.features.interstitialAds);
     };
     return {
         ...gatewayWithoutIntegrations,
@@ -201,13 +204,13 @@ export function withTargetAvailability(gateway, config, options = {}) {
                 ...(options.effectiveConfig === undefined
                     ? {}
                     : { effectiveConfig: options.effectiveConfig }),
-                capabilities: applyTargetConfigToCapabilities(await getGatewayCapabilities(), config),
+                capabilities: applyTargetConfigToCapabilities(await getGatewayCapabilities(), availabilityConfig),
                 adPlacements: options.adPlacements ?? [],
                 gateway,
             });
         },
         async getCapabilities() {
-            return applyTargetConfigToCapabilities(await getGatewayCapabilities(), config);
+            return applyTargetConfigToCapabilities(await getGatewayCapabilities(), availabilityConfig);
         },
         commerce: {
             async getProducts() {
@@ -259,7 +262,7 @@ export function withTargetAvailability(gateway, config, options = {}) {
                 return gateway.ads.showInterstitial(input);
             },
         },
-        leaderboard: config.features.leaderboard
+        leaderboard: availabilityConfig.features.leaderboard
             ? gateway.leaderboard
             : {
                 async submitScore() {
@@ -271,6 +274,14 @@ export function withTargetAvailability(gateway, config, options = {}) {
             },
     };
 }
+function resolveAvailabilityConfig(config, effectiveConfig) {
+    return effectiveConfig === undefined
+        ? config
+        : {
+            ...config,
+            features: effectiveConfig.features,
+        };
+}
 export function isTargetConfiguredGateway(gateway) {
     return typeof gateway.getTargetRuntime === 'function';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/target-config",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Target-specific platform feature availability and effective config helpers for mpgd.",
   "license": "MIT",
   "repository": {

package/targets.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026-07-16.2",
+  "version": "2026-07-19.1",
   "targets": {
     "web-preview": {
       "runtime": "web-preview",
@@ -226,7 +226,7 @@
         "localization": true
       },
       "capabilities": {
-        "storage": "none",
+        "storage": "native",
         "localization": true
       },
       "localization": {