@mpgd/cli 0.46.1 → 0.48.0

package/templates/phaser-game/apps/target-ait/vite.config.ts

@@ -1,11 +1,14 @@
 import { readFileSync } from 'node:fs';
 
+import type { AitIapProductConfig } from '@mpgd/adapter-ait';
 import { extractAitAdBridgeConfig, type AitAdBridgeConfig } from '@mpgd/adapter-ait/ad-config';
+import { extractAitIapProductConfig } from '@mpgd/adapter-ait/iap-config';
 import ttsc from '@ttsc/unplugin/vite';
 import { defineConfig, type Plugin } from 'vite';
 
 const aitAppName = process.env.MPGD_AIT_APP_NAME?.trim() || '__GAME_NAME__';
 const aitAdConfig = readAitAdConfig(process.env.MPGD_AD_PLACEMENTS_FILE);
+const aitIapProducts = readAitIapProducts(process.env.MPGD_PRODUCT_CATALOG_FILE);
 
 export default defineConfig(({ command, isPreview }) => {
   const enableLocalAitMock = command === 'serve'
@@ -29,6 +32,7 @@ export default defineConfig(({ command, isPreview }) => {
         appName: aitAppName,
         adGroupIds: aitAdConfig.adGroupIds,
         adPlacementTypes: aitAdConfig.adPlacementTypes,
+        iapProducts: aitIapProducts,
       }),
       ...(command === 'build'
         ? [ttsc({ project: 'tsconfig.json', plugins: false })]
@@ -46,6 +50,7 @@ function createAitRuntimeConfigPlugin(input: Readonly<{
   readonly appName: string;
   readonly adGroupIds: Readonly<Record<string, string>>;
   readonly adPlacementTypes: AitAdBridgeConfig['adPlacementTypes'];
+  readonly iapProducts: readonly AitIapProductConfig[];
 }>): Plugin {
   const publicId = 'virtual:mpgd-ait-runtime-config';
   const resolvedId = `\0${publicId}`;
@@ -76,3 +81,25 @@ function readAitAdConfig(path: string | undefined): AitAdBridgeConfig {
 
   return extractAitAdBridgeConfig(parsed, path);
 }
+
+/**
+ * The Apps in Toss SKUs come from the product catalog (`platformProductIds.ait`)
+ * so the wrapper and the game share one source; without a configured catalog
+ * file the wrapper sells nothing and the host bridge fails every purchase closed.
+ */
+function readAitIapProducts(path: string | undefined): readonly AitIapProductConfig[] {
+  if (path === undefined || path.trim().length === 0) {
+    return [];
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+  } catch (error) {
+    throw new Error(`AIT product catalog file is unreadable or invalid JSON: ${path}`, {
+      cause: error,
+    });
+  }
+
+  return extractAitIapProductConfig(parsed, { sourceLabel: path });
+}

package/templates/phaser-game/apps/target-devvit/package.json

@@ -21,7 +21,8 @@
   "dependencies": {
     "@devvit/web": "0.14.1",
     "@mpgd/adapter-devvit": "__MPGD_DEPENDENCY_VERSION_ADAPTER_DEVVIT__",
-    "@mpgd/bridge": "__MPGD_DEPENDENCY_VERSION_BRIDGE__"
+    "@mpgd/bridge": "__MPGD_DEPENDENCY_VERSION_BRIDGE__",
+    "@mpgd/catalog": "__MPGD_DEPENDENCY_VERSION_CATALOG__"
   },
   "devDependencies": {
     "@devvit/start": "0.14.1",

package/templates/phaser-game/apps/target-devvit/src/server/bridge.ts

@@ -1,7 +1,10 @@
 import {
+  bridgeEventProtocol,
   bridgeStorageLoadProtocol,
   createBridgeError,
   createCommerceV2UnavailableBridgeError,
+  createNotificationsV2UnavailableBridgeError,
+  isBridgeNotificationsV2Method,
   type BridgeRequest,
   type BridgeResponse,
   type BridgeStorageLoadData,
@@ -90,10 +93,15 @@ export function createDevvitBridgeHandler(
   }
 
   return async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse> {
+    // Notifications v2 arrives with the Devvit provider (P3), which serves the
+    // game-rendered opt-in from this bridge; until then every v2 method
+    // answers the dedicated code, and the v1 `notifications.*` answers stay.
+    if (isBridgeNotificationsV2Method(input.method)) {
+      return createNotificationsV2UnavailableBridgeError(input, 'Devvit server bridge');
+    }
     switch (input.method) {
       case 'runtime.getCapabilities':
         return ok(input, {
-          nativeIap: false,
           nativeAds: false,
           rewardedAds: false,
           interstitialAds: false,
@@ -104,6 +112,7 @@ export function createDevvitBridgeHandler(
           socialShare: false,
           haptics: false,
           localizedContent: true,
+          commerce: await readCommerceCapabilities(input, dependencies.commerce),
         });
 
       case 'identity.getPlayer': {
@@ -164,21 +173,6 @@ export function createDevvitBridgeHandler(
       case 'notifications.requestSubscription':
         return ok(input, 'unavailable');
 
-      case 'commerce.getProducts':
-      case 'commerce.getEntitlements':
-        return ok(input, []);
-
-      case 'commerce.purchase':
-        return ok(input, {
-          status: 'cancelled',
-          entitlementIds: [],
-        });
-
-      case 'commerce.restore':
-        return ok(input, {
-          restoredEntitlements: [],
-        });
-
       case 'ads.preload':
         return ok(input, {});
 
@@ -211,8 +205,9 @@ export function createDevvitBridgeHandler(
       case 'storage.save':
         return saveStorage(input, dependencies, storageKeyNamespace, warn);
 
-      // Commerce v2 (B6): served by the configured handler over the payments
-      // plugin; the checkout itself opens in the webview.
+      // Commerce v2: served by the configured handler over the payments
+      // plugin; the checkout itself opens in the webview. The removed v1
+      // `commerce.*` methods fall to UNSUPPORTED_METHOD below.
       case 'commerce.v2.getCapabilities':
       case 'commerce.v2.fetchProducts':
       case 'commerce.v2.requestPurchase':
@@ -233,6 +228,130 @@ export function createDevvitBridgeHandler(
   };
 }
 
+/**
+ * The all-false commerce capability block of a server that sells nothing
+ * (`createUnsupportedCommerceCapabilities()` of `@mpgd/platform`, kept equal by
+ * the bridge test). A fresh object on every read.
+ */
+function createUnsupportedCommerceBlock() {
+  return {
+    purchase: { consumable: false, durable: false, subscription: false, quantity: false },
+    catalog: { products: false, offers: false, localizedPrice: false },
+    lifecycle: {
+      availablePurchases: false,
+      pending: false,
+      restore: false,
+      events: false,
+      finish: 'none',
+    },
+    authority: { evidence: 'client-token', accountBinding: 'optional' },
+    availability: 'unsupported',
+  };
+}
+
+const commerceBlockShape = {
+  purchase: {
+    consumable: 'boolean',
+    durable: 'boolean',
+    subscription: 'boolean',
+    quantity: 'boolean',
+  },
+  catalog: { products: 'boolean', offers: 'boolean', localizedPrice: 'boolean' },
+  lifecycle: {
+    availablePurchases: 'boolean',
+    pending: 'boolean',
+    restore: 'boolean',
+    events: 'boolean',
+    finish: ['client', 'server', 'host', 'none'],
+  },
+  authority: {
+    evidence: ['client-token', 'host-callback', 'adapter-settled', 'server-push'],
+    accountBinding: ['required', 'optional', 'host'],
+  },
+} as const;
+const commerceAvailabilities: readonly unknown[] = [
+  'available',
+  'unsupported',
+  'configuration-required',
+  'action-required',
+  'temporarily-unavailable',
+];
+
+function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
+  const own = Object.keys(value);
+  return own.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+
+/**
+ * A fresh copy of a well-formed commerce capability block (the exact keys and
+ * values `PlatformCapabilities.commerce` allows), or undefined for anything
+ * else, so a malformed handler answer never reaches the snapshot.
+ */
+function copyCommerceBlock(value: unknown): Record<string, unknown> | undefined {
+  if (!isPlainRecord(value)
+    || !hasExactKeys(value, [...Object.keys(commerceBlockShape), 'availability'])
+    || !commerceAvailabilities.includes(value.availability)) {
+    return undefined;
+  }
+  const copy: Record<string, unknown> = { availability: value.availability };
+  for (const [section, fields] of Object.entries(commerceBlockShape)) {
+    const source = value[section];
+    if (!isPlainRecord(source) || !hasExactKeys(source, Object.keys(fields))) {
+      return undefined;
+    }
+    const sectionCopy: Record<string, unknown> = {};
+    for (const [field, rule] of Object.entries(fields)) {
+      const fieldValue = source[field];
+      const valid = rule === 'boolean'
+        ? typeof fieldValue === 'boolean'
+        : (rule as readonly unknown[]).includes(fieldValue);
+      if (!valid) {
+        return undefined;
+      }
+      sectionCopy[field] = fieldValue;
+    }
+    copy[section] = sectionCopy;
+  }
+  return copy;
+}
+
+/**
+ * The `commerce` block of the server snapshot: what the configured commerce
+ * handler reports for this server, otherwise the unsupported block. It fails
+ * closed: a missing handler, a handler that throws or answers an error, or an
+ * answer without a well-formed capability block sells nothing. The webview
+ * gateway owns the block it finally reports (its provider's, or the
+ * unsupported one).
+ */
+async function readCommerceCapabilities(
+  input: BridgeRequest,
+  handler: DevvitBridgeCommerceHandler | undefined,
+): Promise<unknown> {
+  if (handler === undefined) {
+    return createUnsupportedCommerceBlock();
+  }
+
+  try {
+    const response = await handler.request({
+      ...input,
+      method: 'commerce.v2.getCapabilities',
+      payload: { protocol: bridgeEventProtocol },
+    });
+    const data: unknown = response.ok ? response.data : undefined;
+    const capabilities = typeof data === 'object' && data !== null
+      ? (data as { readonly capabilities?: unknown }).capabilities
+      : undefined;
+
+    return copyCommerceBlock(capabilities) ?? createUnsupportedCommerceBlock();
+  } catch {
+    return createUnsupportedCommerceBlock();
+  }
+}
+
 async function loadStorage(
   input: BridgeRequest,
   dependencies: DevvitBridgeHandlerDependencies,

package/templates/phaser-game/apps/target-devvit/src/server/index.ts

@@ -1,20 +1,49 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 
-import { context, createServer, getServerPort, reddit, redis } from '@devvit/web/server';
+import { context, createServer, getServerPort, payments, reddit, redis } from '@devvit/web/server';
 import type { UiResponse } from '@devvit/web/shared';
+import {
+  createDevvitCommerceBridgeProducts,
+  createDevvitCommerceV2BridgeHandler,
+} from '@mpgd/adapter-devvit/server';
 import { createBridgeRpcRouter, defaultBridgeRpcEndpoint } from '@mpgd/bridge/orpc';
 import { createBridgeRpcNodeHandler } from '@mpgd/bridge/orpc/node';
+import type { ProductCatalog } from '@mpgd/catalog';
+import productCatalogJson from '@mpgd/catalog/catalog.json';
 
+import devvitManifest from '../../devvit.json';
 import { createDevvitBridgeHandler } from './bridge.js';
 
 const maxRequestBodySize = 1_048_576;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
+/**
+ * Commerce v2 opt-in: the catalog's Reddit SKUs (`platformProductIds.reddit`),
+ * the `payments` plugin (`permissions.payments` in devvit.json), and a
+ * fulfillment endpoint (`payments.endpoints.fulfillOrder`, the handler that
+ * writes the backend ledger entry) must all be present. Otherwise the bridge
+ * keeps every `commerce.v2.*` method failing closed with
+ * `COMMERCE_V2_UNAVAILABLE`, so no checkout opens for an order nothing could
+ * grant. The handler only lists orders and products; the grant stays with the
+ * fulfillment handler's ledger entry.
+ */
+const commerceProducts = createDevvitCommerceBridgeProducts(productCatalogJson as ProductCatalog);
+const fulfillOrderEndpoint = (devvitManifest as {
+  readonly payments?: { readonly endpoints?: { readonly fulfillOrder?: unknown } };
+}).payments?.endpoints?.fulfillOrder;
+const commerceEnabled = devvitManifest.permissions.payments === true
+  && typeof fulfillOrderEndpoint === 'string'
+  && fulfillOrderEndpoint.trim().length > 0
+  && commerceProducts.length > 0;
+const commerce = commerceEnabled
+  ? createDevvitCommerceV2BridgeHandler({ payments, products: commerceProducts })
+  : undefined;
 const handleBridgeRequest = createDevvitBridgeHandler({
   redis,
   currentPlayerId,
   currentDisplayName,
   storageKeyNamespace: gameName,
+  ...(commerce === undefined ? {} : { commerce }),
 });
 const bridgeRpcHandler = createBridgeRpcNodeHandler(createBridgeRpcRouter(handleBridgeRequest), {
   maxBodySize: maxRequestBodySize,
@@ -122,6 +151,11 @@ server.on('error', (error) => {
 
 server.listen(port, () => {
   console.log(`devvit server listening on ${port}`);
+  console.log(
+    commerceEnabled
+      ? `devvit commerce v2 serving ${commerceProducts.length} catalog product(s) over the payments plugin`
+      : 'devvit commerce v2 disabled: needs permissions.payments, payments.endpoints.fulfillOrder, and reddit SKUs in the catalog',
+  );
 });
 
 function errorMessage(error: unknown): string {

package/templates/phaser-game/package.json

@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@ait-co/polyfill": "^0.1.19",
-    "@apps-in-toss/web-framework": "3.5.0",
+    "@apps-in-toss/web-framework": "3.6.0",
     "@capacitor/app": "8.1.1",
     "@capacitor/core": "8.5.2",
     "@mpgd/adapter-ait": "__MPGD_DEPENDENCY_VERSION_ADAPTER_AIT__",
@@ -66,6 +66,8 @@
     "@mpgd/adapter-verse8": "__MPGD_DEPENDENCY_VERSION_ADAPTER_VERSE8__",
     "@mpgd/analytics": "__MPGD_DEPENDENCY_VERSION_ANALYTICS__",
     "@mpgd/bridge": "__MPGD_DEPENDENCY_VERSION_BRIDGE__",
+    "@mpgd/capacitor-play-billing": "__MPGD_DEPENDENCY_VERSION_CAPACITOR_PLAY_BILLING__",
+    "@mpgd/capacitor-storekit": "__MPGD_DEPENDENCY_VERSION_CAPACITOR_STOREKIT__",
     "@mpgd/catalog": "__MPGD_DEPENDENCY_VERSION_CATALOG__",
     "@mpgd/game-services": "__MPGD_DEPENDENCY_VERSION_GAME_SERVICES__",
     "@mpgd/i18n": "__MPGD_DEPENDENCY_VERSION_I18N__",

package/templates/phaser-game/pnpm-workspace.yaml

@@ -1,3 +1,5 @@
+# Run the generated POSIX target scripts consistently on Windows and Unix.
+shellEmulator: true
 packages:
   - '.'
   - 'apps/*'

package/templates/phaser-game/src/env.d.ts

@@ -2,6 +2,8 @@
 
 declare const __APP_TARGET__: string;
 declare const __MPGD_CONFIG_TARGET__: string;
+/** The Apps in Toss app name `intoss://` share links carry; see `vite.shared.ts`. */
+declare const __MPGD_AIT_APP_NAME__: string;
 declare const __MPGD_PLATFORM_TARGET__:
   | import('@mpgd/target-config').EffectivePlatformTargetMetadata
   | undefined;

package/templates/phaser-game/src/main.ts

@@ -112,7 +112,14 @@ async function bootstrap(options: { readonly monetization?: StarterMonetizationP
     });
     gameRuntime = ownedRuntime;
     const gameServices = ownedRuntime.services;
-    await ownedRuntime.reconcile();
+    try {
+      await ownedRuntime.reconcile();
+    } catch (error) {
+      // A journal the platform storage cannot read must not stop the game:
+      // recovery runs again on resume, and purchases and rewarded ads fail
+      // closed until the journal is readable.
+      console.error('[game-services] startup recovery failed', error);
+    }
 
     await analytics.track({
       name: 'game_started',

package/templates/phaser-game/src/platform/buildGateways/ait.ts

@@ -3,6 +3,15 @@ import type { PlatformGateway } from '@mpgd/platform';
 
 import type { RuntimeConfig } from '../runtimeDetector';
 
+/**
+ * Apps in Toss gateway over the wrapper's host bridge. Commerce lives on the
+ * host side: the wrapper (`apps/target-ait`) installs the IAP products from
+ * the catalog's `platformProductIds.ait` entries and serves the six
+ * `commerce.v2.*` methods plus the `commerceV2` event channel, so the gateway
+ * exposes `commerce` whenever the installed bridge has that channel. The
+ * host's grant callback only confirms through the game backend; nothing is
+ * granted from this side.
+ */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
   return createAitPlatformGateway({
     appVersion: runtime.appVersion,

package/templates/phaser-game/src/platform/buildGateways/aitSandbox.ts

@@ -3,10 +3,22 @@ import type { PlatformGateway } from '@mpgd/platform';
 
 import type { RuntimeConfig } from '../runtimeDetector';
 
+/**
+ * Local Apps in Toss playtest. The sandbox bridge keeps its build-id gate: only
+ * the `ait-sandbox` build (`pnpm dev:ait`) gets the commerce event channel and
+ * the evidence-only v2 stub; any other build id gets no channel, so the
+ * gateway offers no `commerce` provider and the v2 methods answer
+ * `COMMERCE_V2_UNAVAILABLE`. Every build answers the `notifications.v2.*`
+ * methods with `NOTIFICATIONS_V2_UNAVAILABLE` until the Apps in Toss
+ * notifications provider lands.
+ */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
   return createAitPlatformGateway({
     appVersion: runtime.appVersion,
     buildId: runtime.buildId,
-    fallbackBridge: createAitSandboxBridge({ buildId: runtime.buildId }),
+    fallbackBridge: createAitSandboxBridge({
+      appName: __MPGD_AIT_APP_NAME__,
+      buildId: runtime.buildId,
+    }),
   });
 }

package/templates/phaser-game/src/platform/buildGateways/capacitorAndroid.ts

@@ -1,12 +1,61 @@
-import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import {
+  createCapacitorPlatformGateway,
+  type CapacitorServiceProvider,
+} from '@mpgd/adapter-capacitor';
+import {
+  createCapacitorPlayBillingServiceProvider,
+  type PlayBillingCommerceProductMapping,
+} from '@mpgd/capacitor-play-billing';
+import type { ProductCatalog } from '@mpgd/catalog';
+import productCatalogJson from '@mpgd/catalog/catalog.json';
 import type { PlatformGateway } from '@mpgd/platform';
 
+import { resolvePlayBillingAccountBinding } from '../commerceAccountBinding';
+import { resolveStarterStoreProducts } from '../commerceProducts';
 import type { RuntimeConfig } from '../runtimeDetector';
 
+const productCatalog = productCatalogJson as ProductCatalog;
+
+/**
+ * Android gateway with the Google Play Billing commerce v2 service provider
+ * (`@mpgd/capacitor-play-billing`) registered for the catalog products that
+ * name a Play SKU. The provider serves the `commerce.v2.*` and v1 `commerce.*`
+ * bridge methods and never grants: the game-services reconciler verifies each
+ * purchase through the backend ledger. A shell built without the native
+ * plugin (`mpgd target init capacitor --providers play-billing` installs it)
+ * still runs; the store then answers `configuration-required`.
+ */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
-  return createCapacitorPlatformGateway({
+  let gateway: PlatformGateway | undefined;
+  const providers = createStoreProviders(runtime, () => gateway);
+  gateway = createCapacitorPlatformGateway({
     target: 'android',
     appVersion: runtime.appVersion,
     buildId: runtime.buildId,
+    providers,
   });
+  return gateway;
+}
+
+function createStoreProviders(
+  runtime: RuntimeConfig,
+  resolveGateway: () => PlatformGateway | undefined,
+): readonly CapacitorServiceProvider[] {
+  // Play sells one-time products only (RFC D-02); a subscription stays off the store.
+  const products = resolveStarterStoreProducts(productCatalog, runtime.configTarget)
+    .flatMap((product): PlayBillingCommerceProductMapping[] =>
+      product.kind === 'subscription' ? [] : [{ ...product, kind: product.kind }]);
+  if (products.length === 0) {
+    return [];
+  }
+  return [
+    createCapacitorPlayBillingServiceProvider({
+      products,
+      // The backend's resolveObfuscatedAccountId must derive the same value; see commerceAccountBinding.ts.
+      accountBinding: async () => {
+        const gateway = resolveGateway();
+        return gateway === undefined ? undefined : resolvePlayBillingAccountBinding(gateway);
+      },
+    }),
+  ];
 }

package/templates/phaser-game/src/platform/buildGateways/capacitorIos.ts

@@ -1,12 +1,61 @@
-import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import {
+  createCapacitorPlatformGateway,
+  type CapacitorServiceProvider,
+} from '@mpgd/adapter-capacitor';
+import { createCapacitorStoreKitServiceProvider } from '@mpgd/capacitor-storekit';
+import type { ProductCatalog } from '@mpgd/catalog';
+import productCatalogJson from '@mpgd/catalog/catalog.json';
 import type { PlatformGateway } from '@mpgd/platform';
 
+import { resolveStoreKitAppAccountToken } from '../commerceAccountBinding';
+import { resolveStarterStoreProducts } from '../commerceProducts';
 import type { RuntimeConfig } from '../runtimeDetector';
 
+const productCatalog = productCatalogJson as ProductCatalog;
+
+/**
+ * iOS gateway with the StoreKit commerce v2 service provider
+ * (`@mpgd/capacitor-storekit`) registered for the catalog products that name
+ * an App Store product id. The provider serves the `commerce.v2.*` and v1
+ * `commerce.*` bridge methods and never grants or finishes on its own: the
+ * game-services reconciler verifies the signed transaction through the
+ * backend ledger and only then finishes it. A shell built without the native
+ * plugin (`mpgd target init capacitor --providers storekit` installs it)
+ * still runs; the store then answers `configuration-required`.
+ */
 export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
-  return createCapacitorPlatformGateway({
+  let gateway: PlatformGateway | undefined;
+  const providers = createStoreProviders(runtime, () => gateway);
+  gateway = createCapacitorPlatformGateway({
     target: 'ios',
     appVersion: runtime.appVersion,
     buildId: runtime.buildId,
+    providers,
   });
+  return gateway;
+}
+
+function createStoreProviders(
+  runtime: RuntimeConfig,
+  resolveGateway: () => PlatformGateway | undefined,
+): readonly CapacitorServiceProvider[] {
+  // StoreKit sells one-time products only (RFC D-02); a subscription stays off the store.
+  const products = resolveStarterStoreProducts(productCatalog, runtime.configTarget)
+    .filter((product) => product.kind !== 'subscription');
+  if (products.length === 0) {
+    return [];
+  }
+  return [
+    createCapacitorStoreKitServiceProvider({
+      products,
+      // The backend's resolveAppAccountToken must derive the same value; see commerceAccountBinding.ts.
+      getAppAccountToken: async () => {
+        const gateway = resolveGateway();
+        if (gateway === undefined) {
+          throw new Error('The iOS gateway is not ready for a StoreKit purchase.');
+        }
+        return resolveStoreKitAppAccountToken(gateway);
+      },
+    }),
+  ];
 }

package/templates/phaser-game/src/platform/buildGateways/microsoftStore.ts

@@ -1,37 +1,70 @@
 import { createBrowserPlatformGateway } from '@mpgd/adapter-browser';
 import {
-  createMicrosoftStoreCommerceAdapter,
-  withMicrosoftStoreCommerceAdapter,
+  createMicrosoftStoreCommerceProvider,
+  withMicrosoftStoreCommerceProvider,
+  type MicrosoftStoreCommerceProduct,
 } from '@mpgd/adapter-browser/microsoft-store';
+import { resolveProductPlatformId, type ProductCatalog } from '@mpgd/catalog';
+import productCatalogJson from '@mpgd/catalog/catalog.json';
 import type { PlatformGateway } from '@mpgd/platform';
 
 import type { RuntimeConfig } from '../runtimeDetector';
 
+const productCatalog = productCatalogJson as ProductCatalog;
 const browser = createBrowserPlatformGateway();
 const base: PlatformGateway = { ...browser, target: 'microsoft-store' };
-const commerce = createMicrosoftStoreCommerceAdapter({
-  getRecoveryScope: () => 'configuration-required',
-  products: [],
-  authority: {
-    async getAvailability() {
-      return 'configuration-required';
-    },
-    async claimRecoveryOwnership() {
-      return { status: 'denied' } as const;
-    },
-    async hasRecoveryOwnership() {
-      return { status: 'denied' } as const;
-    },
-    async verifyAndGrant() {
-      return { status: 'failed' };
-    },
-    async getEntitlements() {
-      return [];
-    },
-  },
-});
 
-/** Configure Store products, authenticated recovery scope, and authority before checkout. */
-export async function createBuildGateway(_runtime: RuntimeConfig): Promise<PlatformGateway> {
-  return withMicrosoftStoreCommerceAdapter(base, commerce);
+/**
+ * Microsoft Store products from the catalog: the Partner Center add-on
+ * product id is `platformProductIds['microsoft-store']`, and the Digital
+ * Goods API currently sells consumables only. Title, description, and price
+ * are replaced by the Store's own details when the catalog loads.
+ */
+function resolveMicrosoftStoreProducts(target: string): readonly MicrosoftStoreCommerceProduct[] {
+  return productCatalog.products.flatMap((product) => {
+    const inAppOfferToken = resolveProductPlatformId(product, target);
+    return inAppOfferToken === undefined || product.type !== 'consumable'
+      ? []
+      : [
+          {
+            info: {
+              id: product.id,
+              type: product.type,
+              title: product.id,
+              description: '',
+              price: { formatted: '', currencyCode: 'USD' },
+            },
+            inAppOfferToken,
+          },
+        ];
+  });
+}
+
+/**
+ * Commerce over the Digital Goods path (`createMicrosoftStoreCommerceProvider`)
+ * installed as `gateway.commerce` with its capability block. The purchase authority stays
+ * `configuration-required` until the game points it at its backend: the
+ * authority's ledger entry is the only settlement, and the reconciler still
+ * verifies it through game-services before anything is granted.
+ */
+export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {
+  const commerce = createMicrosoftStoreCommerceProvider({
+    getRecoveryScope: () => 'configuration-required',
+    products: resolveMicrosoftStoreProducts(runtime.configTarget),
+    authority: {
+      async getAvailability() {
+        return 'configuration-required';
+      },
+      async claimRecoveryOwnership() {
+        return { status: 'denied' } as const;
+      },
+      async hasRecoveryOwnership() {
+        return { status: 'denied' } as const;
+      },
+      async verifyAndGrant() {
+        return { status: 'failed' };
+      },
+    },
+  });
+  return withMicrosoftStoreCommerceProvider(base, commerce);
 }